livepilot 1.10.6 → 1.10.7

package/mcp_server/tools/_composition_engine/__init__.py

@@ -44,7 +44,7 @@ from .gestures import (
     plan_gesture,
     resolve_gesture_template,
 )
-from .harmony import build_harmony_field
+from .harmony import build_harmony_field, harmonic_score
 from .analysis import (
     COMPOSITION_DIMENSIONS,
     analyze_section_outcomes,
@@ -61,7 +61,7 @@ __all__ = [
     "run_form_critic", "run_section_identity_critic", "run_phrase_critic",
     "run_transition_critic", "run_emotional_arc_critic", "run_cross_section_critic",
     "GESTURE_TEMPLATES", "plan_gesture", "resolve_gesture_template",
-    "build_harmony_field",
+    "build_harmony_field", "harmonic_score",
     "COMPOSITION_DIMENSIONS", "analyze_section_outcomes",
     "evaluate_composition_move", "build_composition_taste_model",
 ]

package/mcp_server/tools/_composition_engine/harmony.py

@@ -14,6 +14,96 @@ from typing import Any, Optional
 
 from .models import HarmonyField
 
+
+# ── BUG-E3: harmonic-ness scoring ────────────────────────────────────────
+# get_harmony_field used to take the FIRST track in section.tracks_active
+# that had notes and lock in its key detection. When that track was
+# percussion (all notes at a single pitch, staccato), detect_key would
+# return a bogus "C major" for the whole section. The fix: score every
+# track's notes for harmonic-ness, aggregate notes from tracks that pass
+# a threshold, and run key detection on the combined pool.
+
+_PERC_NAME_TOKENS = (
+    "kick", "snare", "clap", "hat", "hihat", "hi-hat", "hh", "drum",
+    "drums", "perc", "percussion", "rim", "crash", "ride", "tom",
+    "cymbal", "shaker", "tambourine", "cowbell", "808", "909",
+    "breakbeat", "break", "stick", "click",
+)
+_HARMONIC_NAME_TOKENS = (
+    "pad", "pads", "bass", "sub", "lead", "chord", "chords", "keys",
+    "synth", "piano", "rhodes", "organ", "lush", "string", "strings",
+    "brass", "pluck", "arp", "melody", "harmony", "voice", "choir",
+)
+
+
+def harmonic_score(notes: list[dict], track_name: str = "") -> float:
+    """Rate how likely a track's notes carry harmonic content (0.0 - 1.0).
+
+    Used by get_harmony_field to decide which tracks to include in
+    aggregate key detection. Percussion (single-pitch, staccato) scores
+    near 0. Sustained chordal/melodic material scores near 1.
+
+    Signals combined:
+      - unique pitch classes (chords vary, kicks don't)
+      - median note duration (sustain vs staccato)
+      - pitch range (melody moves, drums don't)
+      - minimum pitch (above the GM drum range)
+      - track-name hint tokens (soft nudge)
+
+    Returns a score in [0.0, 1.0]. Callers typically threshold at 0.3 or 0.4.
+    """
+    if not notes:
+        return 0.0
+
+    pitches = [int(n.get("pitch", 60)) for n in notes]
+    durations = [float(n.get("duration", 0.0)) for n in notes]
+    pcs = set(p % 12 for p in pitches)
+
+    # Use statistics.median for a more stable middle value. Falling back
+    # to a manual median keeps this file free of an extra import.
+    sorted_durs = sorted(durations)
+    median_dur = sorted_durs[len(sorted_durs) // 2] if sorted_durs else 0.0
+    unique_pcs = len(pcs)
+    pitch_range = max(pitches) - min(pitches) if pitches else 0
+    min_pitch = min(pitches) if pitches else 0
+
+    score = 0.0
+    # Unique pitch-class diversity: 3+ distinct pcs is a strong harmonic signal
+    if unique_pcs >= 4:
+        score += 0.45
+    elif unique_pcs >= 3:
+        score += 0.35
+    elif unique_pcs >= 2:
+        score += 0.15
+
+    # Duration: sustained notes carry harmony; staccato is rhythmic
+    if median_dur >= 1.0:
+        score += 0.30
+    elif median_dur >= 0.5:
+        score += 0.25
+    elif median_dur >= 0.25:
+        score += 0.10
+
+    # Pitch range: melody spans more than an octave often; drums don't
+    if pitch_range >= 12:
+        score += 0.20
+    elif pitch_range >= 5:
+        score += 0.10
+
+    # Minimum pitch out of the GM drum-map range (35–51) suggests melody
+    if min_pitch >= 48:
+        score += 0.10
+
+    # Track-name hints — mild nudges either way
+    name_lower = str(track_name or "").lower()
+    if any(tok in name_lower for tok in _PERC_NAME_TOKENS):
+        score -= 0.45
+    if any(tok in name_lower for tok in _HARMONIC_NAME_TOKENS):
+        score += 0.20
+
+    return max(0.0, min(1.0, score))
+
+
 def build_harmony_field(
     section_id: str,
     harmony_analysis: Optional[dict] = None,

package/mcp_server/tools/_composition_engine/sections.py

@@ -194,6 +194,15 @@ def detect_phrases(
 
     Uses note density changes and gap detection to find phrase boundaries.
     Falls back to regular grid (4 or 8 bar phrases).
+
+    BUG-B22 fix: most clips are 4-8 bar loops. In an 8-bar section with
+    4-bar clips, notes have start_time 0..16 (one clip cycle). The old
+    algorithm placed them at absolute bars section.start_bar + 0..4 only,
+    leaving bars 4..7 of the section reading as "empty" — which produced
+    note_density=0 for the second half even though Ableton loops those
+    clips to fill the section. We now infer each track's clip length
+    from its max note start_time and wrap note bars modulo that length,
+    so a looping clip's density spreads across the whole section.
     """
     section_length = section.length_bars()
     if section_length <= 0:
@@ -204,12 +213,46 @@ def detect_phrases(
     for bar in range(section.start_bar, section.end_bar):
         bar_densities[bar] = 0
 
+    section_bar_count = section.end_bar - section.start_bar
+
     for track_notes in notes_by_track.values():
+        if not track_notes:
+            continue
+        # Infer this track's clip span (in bars) from the max start_time.
+        # The clip LOOPS to fill the section, so notes at start_time=0
+        # repeat every span bars. Round UP so a 3.5-beat phrase counts
+        # as 1 bar (not 0).
+        max_start_beat = max(
+            float(n.get("start_time", 0) or 0) for n in track_notes
+        )
+        clip_span_bars = max(
+            1,
+            int((max_start_beat / beats_per_bar) + 1),
+        )
+        # If we can't determine a sensible span, fall back to section length
+        if clip_span_bars <= 0:
+            clip_span_bars = section_bar_count
+
         for note in track_notes:
-            start_beat = note.get("start_time", 0)
-            note_bar = section.start_bar + int(start_beat / beats_per_bar)
-            if section.start_bar <= note_bar < section.end_bar:
-                bar_densities[note_bar] = bar_densities.get(note_bar, 0) + 1
+            start_beat = float(note.get("start_time", 0) or 0)
+            clip_bar = int(start_beat / beats_per_bar)
+            # Fill-copy the note across all loop iterations that fit
+            # inside the section. For a 4-bar clip in an 8-bar section
+            # that means each note contributes to bars 0..3 AND 4..7.
+            if clip_span_bars >= section_bar_count:
+                # Clip is already section-long (or longer) — no looping
+                positions = [clip_bar]
+            else:
+                # Wrap by modulo — project across the section
+                positions = list(range(
+                    clip_bar % clip_span_bars,
+                    section_bar_count,
+                    clip_span_bars,
+                ))
+            for offset in positions:
+                note_bar = section.start_bar + offset
+                if section.start_bar <= note_bar < section.end_bar:
+                    bar_densities[note_bar] = bar_densities.get(note_bar, 0) + 1
 
     # Find phrase boundaries using density drops (gaps)
     boundaries = [section.start_bar]

package/mcp_server/tools/_harmony_engine.py

@@ -195,13 +195,45 @@ def find_shortest_path(
 # ---------------------------------------------------------------------------
 
 def classify_transform_sequence(chords: list[tuple[int, str]]) -> list[str]:
-    """Identify the PRL transform between each consecutive pair of chords.
-
-    Tries single transforms (P, L, R) first, then 2-step compound
-    transforms (PL, PR, LP, LR, RP, RL) for richer classification.
+    """Identify the neo-Riemannian transform between each consecutive pair.
+
+    Tries (in order):
+      1. Single transforms: P, L, R
+      2. 2-step compounds: PL, PR, LP, LR, RP, RL, PP, LL, RR
+      3. 3-step compounds: PLR, PRL, LPR, LRP, RLP, RPL, PLP, PRP, LPL, …
+         (BUG-B24: needed for progressions that step through mediants)
+      4. Diatonic-step primitives: S2↑ / S2↓ (whole-step root motion,
+         same quality) and S1↑ / S1↓ (half-step root motion, same
+         quality). These aren't classical neo-Riemannian transforms —
+         but Gm → Am (D minor iv → v) IS a valid progression, so the
+         transform alphabet needs SOME label for it. Marking it with a
+         dedicated symbol is cleaner than returning "?", which cascades
+         into misleading "diatonic cycle fragment" classifications
+         downstream.
     """
-    _COMPOUNDS = ["PL", "PR", "LP", "LR", "RP", "RL",
-                  "PP", "LL", "RR"]
+    _TWO_STEP = ["PL", "PR", "LP", "LR", "RP", "RL",
+                 "PP", "LL", "RR"]
+    _THREE_STEP = [
+        "PLR", "PRL", "LPR", "LRP", "RLP", "RPL",
+        "PLP", "LPL", "PRP", "RPR", "LRL", "RLR",
+    ]
+
+    def _try_primitive_step(a: tuple[int, str], b: tuple[int, str]) -> str:
+        """Detect same-quality step motion → S1/S2 primitive."""
+        if a[1] != b[1]:
+            return "?"
+        interval = (b[0] - a[0]) % 12
+        # Prefer the signed direction symbol for readability
+        if interval == 1:
+            return "S1u"  # semitone up
+        if interval == 11:
+            return "S1d"  # semitone down
+        if interval == 2:
+            return "S2u"  # whole-step up (Gm → Am in Dm)
+        if interval == 10:
+            return "S2d"  # whole-step down
+        return "?"
+
     result = []
     for i in range(len(chords) - 1):
         found = "?"
@@ -210,15 +242,27 @@ def classify_transform_sequence(chords: list[tuple[int, str]]) -> list[str]:
             if fn(*chords[i]) == chords[i + 1]:
                 found = label
                 break
-        # Try 2-step compound transforms
+        # Try 2-step compounds
+        if found == "?":
+            for compound in _TWO_STEP:
+                try:
+                    if apply_transforms(*chords[i], compound) == chords[i + 1]:
+                        found = compound
+                        break
+                except (ValueError, KeyError):
+                    continue
+        # Try 3-step compounds (BUG-B24)
         if found == "?":
-            for compound in _COMPOUNDS:
+            for compound in _THREE_STEP:
                 try:
                     if apply_transforms(*chords[i], compound) == chords[i + 1]:
                         found = compound
                         break
                 except (ValueError, KeyError):
                     continue
+        # Final fallback: same-quality step motion (BUG-B24)
+        if found == "?":
+            found = _try_primitive_step(chords[i], chords[i + 1])
         result.append(found)
     return result
 

package/mcp_server/tools/_research_engine.py

@@ -162,15 +162,52 @@ def targeted_research(
     findings: list[ResearchFinding] = []
     sources_searched = []
 
-    # 1. Device atlas findings
+    # 1. Device atlas findings.
+    # BUG-B43 fix: device_atlas_results is a list of search_browser
+    # RESPONSES (each with {path, items: [...], count, ...}) — NOT a
+    # list of device entries. The old code read response.get("name")
+    # which always returned "" because the response has no top-level
+    # name. Every finding came back as "Device: Unknown". We now
+    # flatten the responses, look up each item's real atlas metadata,
+    # and build one finding per resolved device.
     if device_atlas_results:
         sources_searched.append("device_atlas")
-        for entry in device_atlas_results:
+        flattened_entries: list[dict] = []
+        for response in device_atlas_results:
+            if not isinstance(response, dict):
+                continue
+            # Accept old shape (single device dict) for forward compat
+            if response.get("name") and not response.get("items"):
+                flattened_entries.append(response)
+                continue
+            items = response.get("items") or response.get("results") or []
+            for item in items:
+                if not isinstance(item, dict):
+                    continue
+                flattened_entries.append({
+                    "name": item.get("name", ""),
+                    "uri": item.get("uri", ""),
+                    "category": response.get("path", ""),
+                    "is_loadable": item.get("is_loadable", False),
+                })
+
+        for entry in flattened_entries:
             name = entry.get("name", "")
+            if not name:
+                continue  # skip phantom empties
+            # Try to enrich with atlas lookup — gives real description,
+            # character_tags, genres.
+            try:
+                from ..atlas import _atlas_instance as _atlas
+                if _atlas is not None:
+                    full = _atlas.lookup(name)
+                    if full:
+                        entry = {**full, **entry}
+            except Exception:
+                pass
+
             text = _format_device_finding(entry)
             relevance = _score_finding_relevance(text, query_info["keywords"])
-
-            # Boost relevance if device was in our predicted list
             if name in query_info["likely_devices"]:
                 relevance = min(1.0, relevance + 0.3)
 
@@ -179,7 +216,10 @@ def targeted_research(
                 source_id=name,
                 relevance=round(relevance, 3),
                 content=text,
-                metadata={"device_name": name, "category": entry.get("category", "")},
+                metadata={
+                    "device_name": name,
+                    "category": entry.get("category", ""),
+                },
             ))
 
     # 2. Memory findings (technique cards, outcomes, research notes)
@@ -522,21 +562,60 @@ def get_style_tactics(
             if any(query in p.lower() for p in tactic.arrangement_patterns):
                 results.append(tactic)
 
-    # Search user memory tactics
+    # Search user memory tactics.
+    # BUG-B18 fix: TechniqueStore.search() strips the payload from
+    # summaries, so `mem.get("payload", {})` was always empty and the
+    # old match-by-payload.artist_or_genre code never fired. Users who
+    # saved 3 "Prefuse73" techniques via memory_learn got back 0
+    # tactics from get_style_tactics("prefuse73"). We now match on
+    # name + tags + qualities.summary + payload (if present) and
+    # adapt the memory-entry to a StyleTactic regardless of whether
+    # the caller formatted the payload in the exact style_tactic shape.
     if memory_tactics:
         for mem in memory_tactics:
-            payload = mem.get("payload", {})
-            if isinstance(payload, dict):
-                mem_genre = payload.get("artist_or_genre", "").lower()
-                mem_name = payload.get("tactic_name", "").lower()
-                if query in mem_genre or query in mem_name:
-                    results.append(StyleTactic(
-                        artist_or_genre=payload.get("artist_or_genre", ""),
-                        tactic_name=payload.get("tactic_name", ""),
-                        arrangement_patterns=payload.get("arrangement_patterns", []),
-                        device_chain=payload.get("device_chain", []),
-                        automation_gestures=payload.get("automation_gestures", []),
-                        verification=payload.get("verification", []),
-                    ))
+            if not isinstance(mem, dict):
+                continue
+            # Build the searchable text from whichever shape the memory
+            # entry uses. This is lenient on purpose — saved techniques
+            # don't need to pre-commit to a schema to surface here.
+            name = str(mem.get("name", ""))
+            tags = mem.get("tags", []) or []
+            qualities = mem.get("qualities", {}) or {}
+            summary = str(qualities.get("summary", "") or "")
+            payload = mem.get("payload", {}) or {}
+
+            searchable = " ".join([
+                name.lower(), summary.lower(),
+                " ".join(str(t).lower() for t in tags),
+                str(payload.get("artist_or_genre", "")).lower(),
+                str(payload.get("tactic_name", "")).lower(),
+            ])
+            if query not in searchable:
+                continue
+
+            # Adapt to StyleTactic — prefer payload fields when present,
+            # fall back to the summary for arrangement_patterns, etc.
+            artist_or_genre = str(
+                payload.get("artist_or_genre")
+                or next((t for t in tags if query in str(t).lower()), "")
+                or query
+            )
+            tactic_name = str(payload.get("tactic_name") or name or summary[:40])
+            arrangement_patterns = (
+                payload.get("arrangement_patterns")
+                or [summary] if summary else []
+            )
+            device_chain = payload.get("device_chain", []) or []
+            automation_gestures = payload.get("automation_gestures", []) or []
+            verification = payload.get("verification", []) or []
+
+            results.append(StyleTactic(
+                artist_or_genre=artist_or_genre,
+                tactic_name=tactic_name,
+                arrangement_patterns=arrangement_patterns,
+                device_chain=device_chain,
+                automation_gestures=automation_gestures,
+                verification=verification,
+            ))
 
     return results

package/mcp_server/tools/_theory_engine.py

@@ -218,16 +218,98 @@ def detect_key(notes: list[dict], mode_detection: bool = True) -> dict:
 
 
 def chord_name(midi_pitches: list[int]) -> str:
-    """Identify chord from MIDI pitches -> 'C-major triad'."""
-    pcs = sorted(set(p % 12 for p in midi_pitches))
-    if not pcs:
+    """Identify chord from MIDI pitches -> 'C-major triad'.
+
+    Root-selection rules (BUG-B2 / BUG-B5):
+      1) Prefer the bass note (lowest MIDI pitch) as root — matches
+         musical convention and handles partial voicings correctly.
+      2) Accept exact CHORD_PATTERNS match first.
+      3) If no exact match, allow subset match (partial chord e.g.
+         Dm7(no5)) and superset match (add-tone e.g. Gm7(add11)).
+      4) Only fall back to the pitch-class-0 guess when nothing else
+         works — previous code always returned pcs[0] on miss, which
+         mis-labeled Dm7 as a "C chord" just because C has pc=0.
+    """
+    if not midi_pitches:
         return "unknown"
-    # Try each pitch class as potential root
-    for root in pcs:
-        intervals = tuple(sorted((pc - root) % 12 for pc in pcs))
+    pcs_set = set(p % 12 for p in midi_pitches)
+    pcs_sorted_pc = sorted(pcs_set)  # numerical pc order, used for fallback only
+    bass_pc = min(midi_pitches) % 12
+
+    # Ordered candidate roots: bass first, then remaining pcs (low→high).
+    # This gives musical priority to the bass note without ignoring cases
+    # where a non-bass root yields a cleaner exact match (2nd-pass scoring).
+    ordered_roots: list[int] = [bass_pc] + [pc for pc in pcs_sorted_pc if pc != bass_pc]
+
+    # ── Pass 1: exact CHORD_PATTERNS match ─────────────────────────────
+    exact_matches: list[tuple[int, tuple[int, ...]]] = []
+    for root in ordered_roots:
+        intervals = tuple(sorted((pc - root) % 12 for pc in pcs_set))
         if intervals in CHORD_PATTERNS:
-            return f"{NOTE_NAMES[root]}-{CHORD_PATTERNS[intervals]}"
-    return f"{NOTE_NAMES[pcs[0]]} chord"
+            exact_matches.append((root, intervals))
+
+    if exact_matches:
+        # Prefer the match where root == bass_pc
+        for root, intervals in exact_matches:
+            if root == bass_pc:
+                return f"{NOTE_NAMES[root]}-{CHORD_PATTERNS[intervals]}"
+        # Otherwise the first (bass-first iteration) wins
+        root, intervals = exact_matches[0]
+        return f"{NOTE_NAMES[root]}-{CHORD_PATTERNS[intervals]}"
+
+    # ── Pass 2: subset match (partial chord — missing tones) ───────────
+    # e.g. D-F-C → (0, 3, 10) is a subset of (0, 3, 7, 10) = minor seventh.
+    # Report the canonical name with "(no X)" where X is the missing interval.
+    interval_names = {
+        0: "root", 2: "2", 3: "♭3", 4: "3", 5: "4", 6: "♭5",
+        7: "5", 8: "♭6", 9: "6", 10: "♭7", 11: "7",
+    }
+    # Prefer bass-pc first.
+    for root in ordered_roots:
+        intervals_set = set((pc - root) % 12 for pc in pcs_set)
+        if 0 not in intervals_set:
+            continue
+        for pattern, label in CHORD_PATTERNS.items():
+            pattern_set = set(pattern)
+            if intervals_set.issubset(pattern_set) and intervals_set != pattern_set:
+                missing = sorted(pattern_set - intervals_set)
+                missing_names = ",".join(interval_names.get(m, str(m)) for m in missing)
+                return f"{NOTE_NAMES[root]}-{label} (no {missing_names})"
+
+    # ── Pass 3: superset match (extended chord — added tensions) ───────
+    # e.g. G-Bb-D-F-A → pattern minor-seventh (0,3,7,10) is a subset of
+    # {0,2,3,7,10}; the extra 2 is an added 9 (or 11 depending on voicing).
+    # Report "Gm7(add2)".
+    add_interval_names = {
+        1: "♭9", 2: "9", 4: "♯9", 5: "11", 6: "♯11",
+        8: "♭13", 9: "13", 11: "maj7",
+    }
+    for root in ordered_roots:
+        intervals_set = set((pc - root) % 12 for pc in pcs_set)
+        if 0 not in intervals_set:
+            continue
+        # Try each pattern as the core, extras as tensions. Track the
+        # chosen pattern size so we prefer 7ths over triads (the bug in
+        # the first draft was using len(set(label_string)) — chars, not
+        # intervals — which broke the tie-break for BUG-B2.
+        best_superset: tuple[str, list[int], int] | None = None
+        for pattern, label in CHORD_PATTERNS.items():
+            pattern_set = set(pattern)
+            if pattern_set.issubset(intervals_set) and pattern_set != intervals_set:
+                extras = sorted(intervals_set - pattern_set)
+                # Prefer the longest pattern (seventh chords win over triads)
+                if best_superset is None or len(pattern_set) > best_superset[2]:
+                    best_superset = (label, extras, len(pattern_set))
+        if best_superset is not None:
+            label, extras, _ = best_superset
+            add_names = ",".join(add_interval_names.get(e, str(e)) for e in extras)
+            return f"{NOTE_NAMES[root]}-{label} (add {add_names})"
+
+    # ── Pass 4: fallback — name by bass note, not pcs[0] ───────────────
+    # Previous behavior returned NOTE_NAMES[pcs[0]] (numerically lowest pc,
+    # which put C first for any chord containing C). Bass-note is musically
+    # correct — if we can't identify the quality, at least the root is right.
+    return f"{NOTE_NAMES[bass_pc]} chord"
 
 
 def roman_numeral(chord_pcs: list[int], tonic: int, mode: str) -> dict:
@@ -399,8 +481,18 @@ def roman_figure_to_pitches(figure: str, tonic: int, mode: str) -> dict:
         p = base_midi + ((pc - root_pc) % 12)
         midi.append(p)
 
+    # BUG-B23: the original figure string's case can disagree with the
+    # resolved quality (e.g. "IV" resolving to a minor triad on the 4th
+    # scale degree of D minor). Convention says uppercase numerals encode
+    # major/augmented and lowercase encode minor/diminished. Return a
+    # normalized figure so callers receive internally consistent data;
+    # the raw input figure stays reflected in 'figure_requested' for
+    # debugging / compatibility.
+    normalized_figure = _normalize_figure_case(figure, quality)
+
     return {
-        "figure": figure,
+        "figure": normalized_figure,
+        "figure_requested": figure,
         "root_pc": root_pc,
         "pitches": [pitch_name(m) for m in midi],
         "midi_pitches": midi,
@@ -408,6 +500,43 @@ def roman_figure_to_pitches(figure: str, tonic: int, mode: str) -> dict:
     }
 
 
+def _normalize_figure_case(figure: str, quality: str) -> str:
+    """Return *figure* with its numeral's case matched to *quality*.
+
+    Uppercase numerals (I, II, …, VII) conventionally encode major-family
+    qualities; lowercase (i, ii, …, vii) encode minor-family. We preserve
+    any leading accidentals (b/#) and trailing suffix (7, maj7, °, etc.)
+    and only flip the numeral itself. Safe on edge cases: if the figure
+    doesn't start with a recognized numeral, it's returned unchanged.
+    """
+    if not figure:
+        return figure
+    # Split off leading accidentals
+    prefix = ""
+    remaining = figure
+    while remaining and remaining[0] in ("b", "#"):
+        prefix += remaining[0]
+        remaining = remaining[1:]
+    # Match numeral greedily (longest first so VII wins over VI wins over V)
+    numeral = ""
+    for rn in ["VII", "VI", "IV", "III", "II", "V", "I"]:
+        if remaining.upper().startswith(rn):
+            numeral = rn
+            break
+    if not numeral:
+        return figure
+    suffix = remaining[len(numeral):]
+    # Minor family: lowercase. Major family: uppercase.
+    q = quality.lower() if isinstance(quality, str) else ""
+    is_minor_family = (
+        q.startswith("minor")
+        or q.startswith("half-diminished")
+        or q.startswith("diminished")
+    )
+    new_numeral = numeral.lower() if is_minor_family else numeral
+    return prefix + new_numeral + suffix
+
+
 def check_voice_leading(prev_pitches: list[int], curr_pitches: list[int]) -> list[dict]:
     """Check voice leading issues between two chords."""
     issues = []

package/mcp_server/tools/agent_os.py

@@ -151,11 +151,28 @@ def build_world_model(ctx: Context) -> dict:
         if key_data:
             detected_key = key_data["value"] if isinstance(key_data["value"], dict) else {"key": key_data["value"]}
 
+        # BUG-E6 fix: derive flucoma_available from the same 6-stream probe
+        # that check_flucoma uses. Previously we read a dedicated
+        # "flucoma_status" key that the M4L bridge doesn't emit, so the
+        # fallback `{"flucoma_available": False}` always won even when all
+        # 6 FluCoMa streams were actively delivering data.
+        _flu_streams = ("spectral_shape", "mel_bands", "chroma",
+                        "onset", "novelty", "loudness")
+        active = sum(1 for k in _flu_streams if spectral.get(k) is not None)
+        flucoma_status = {
+            "flucoma_available": active > 0,
+            "active_streams": active,
+        }
+        # Keep any explicit flucoma_status payload the bridge may emit
+        # alongside as extra metadata — without letting it override the
+        # stream-based truth.
         flucoma_data = spectral.get("flucoma_status")
-        if flucoma_data:
-            flucoma_status = flucoma_data["value"] if isinstance(flucoma_data["value"], dict) else {}
+        if flucoma_data and isinstance(flucoma_data.get("value"), dict):
+            extras = {k: v for k, v in flucoma_data["value"].items()
+                      if k not in flucoma_status}
+            flucoma_status.update(extras)
     else:
-        flucoma_status = {"flucoma_available": False}
+        flucoma_status = {"flucoma_available": False, "active_streams": 0}
 
     # Build model
     wm = engine.build_world_model_from_data(