Upload 2 files

app.py

@@ -0,0 +1,386 @@
+import streamlit as st
+import uuid
+from harmonic_engine import (
+    note_name_to_pc, pc_to_note_name, midi_to_name, midi_to_freq,
+    parse_chord_symbol, roman_to_chord,
+    GenreVoicer, VoiceLeader, SpectralAuditor, NegativeHarmony,
+    MidiExporter, NOTE_NAMES
+)
+
+st.set_page_config(page_title="Harmonic Catalyst PRO", page_icon="🎹", layout="wide")
+
+st.markdown("""
+<style>
+    .stApp {background-color: #0d1117; color: #c9d1d9;}
+    .stButton>button {
+        width: 100%; border-radius: 8px;
+        background: linear-gradient(135deg, #238636, #2ea043);
+        color: white; font-weight: bold; font-size: 16px; padding: 10px;
+    }
+    hr {border: 0; border-top: 1px solid #30363d;}
+    .chord-header {
+        font-size: 22px; font-weight: bold; color: #f0f6fc;
+        border-left: 4px solid #58a6ff; padding-left: 12px; margin-bottom: 8px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+st.title("🎹 Harmonic Catalyst PRO")
+st.caption("Genre-Aware Voicing Engine • Multi-Section Builder • Voice Leading • Spectral Analysis")
+
+if 'song_sections' not in st.session_state:
+    st.session_state.song_sections = []
+
+if 'section_counter' not in st.session_state:
+    st.session_state.section_counter = 0
+
+def add_section():
+    st.session_state.section_counter += 1
+    new_section = {
+        'id': str(uuid.uuid4())[:8],
+        'number': st.session_state.section_counter,
+        'name': f'Section {st.session_state.section_counter}',
+        'chords': '',
+        'genre': 'Pop',
+        'lh_octave': 2,
+        'rh_octave': 4
+    }
+    st.session_state.song_sections.append(new_section)
+
+def remove_section(section_id):
+    st.session_state.song_sections = [
+        s for s in st.session_state.song_sections if s['id'] != section_id
+    ]
+
+def duplicate_section(section_id):
+    section = next(s for s in st.session_state.song_sections if s['id'] == section_id)
+    st.session_state.section_counter += 1
+    new_section = section.copy()
+    new_section['id'] = str(uuid.uuid4())[:8]
+    new_section['number'] = st.session_state.section_counter
+    new_section['name'] = f"{section['name']} (Copy)"
+    idx = st.session_state.song_sections.index(section)
+    st.session_state.song_sections.insert(idx + 1, new_section)
+
+def move_section_up(section_id):
+    sections = st.session_state.song_sections
+    idx = next(i for i, s in enumerate(sections) if s['id'] == section_id)
+    if idx > 0:
+        sections[idx], sections[idx - 1] = sections[idx - 1], sections[idx]
+
+def move_section_down(section_id):
+    sections = st.session_state.song_sections
+    idx = next(i for i, s in enumerate(sections) if s['id'] == section_id)
+    if idx < len(sections) - 1:
+        sections[idx], sections[idx + 1] = sections[idx + 1], sections[idx]
+
+with st.sidebar:
+    st.header("⚙️ Global Settings")
+    
+    input_mode = st.radio(
+        "Input Mode",
+        ["Chord Symbols (Cmaj7, Am7...)", "Roman Numerals (I, vi, IV, V)"]
+    )
+    
+    if "Roman" in input_mode:
+        key_name = st.selectbox("Key", NOTE_NAMES, index=0)
+        key_pc = note_name_to_pc(key_name)
+    else:
+        key_pc = 0
+    
+    st.divider()
+    context = st.radio("🎚️ Mix Context", ["Full Band", "Solo Piano"])
+    
+    st.divider()
+    st.subheader("🔧 Voice Leading")
+    use_voice_leading = st.checkbox("🔗 Connect sections smoothly", value=True)
+    
+    st.divider()
+    use_negative = st.checkbox("🌌 Negative Harmony", value=False)
+    if use_negative:
+        neg_key = st.selectbox("Mirror Key", NOTE_NAMES, index=0)
+        neg_key_pc = note_name_to_pc(neg_key)
+    
+    st.divider()
+    if st.button("🗑️ Clear All Sections"):
+        st.session_state.song_sections = []
+        st.session_state.section_counter = 0
+        st.rerun()
+
+def draw_piano_svg(notes, label, start_midi=36, num_keys=37):
+    white_key_w = 22
+    black_key_w = 14
+    white_key_h = 90
+    black_key_h = 55
+    padding = 20
+    white_pcs = {0, 2, 4, 5, 7, 9, 11}
+    black_x_offset = {1: 0.65, 3: 1.65, 6: 3.65, 8: 4.65, 10: 5.65}
+    
+    white_positions = {}
+    w_idx = 0
+    for i in range(num_keys):
+        midi = start_midi + i
+        pc = midi % 12
+        if pc in white_pcs:
+            white_positions[midi] = w_idx
+            w_idx += 1
+    
+    total_width = w_idx * (white_key_w + 1) + padding * 2
+    total_height = white_key_h + 60
+    
+    svg = f'<svg width="{total_width}" height="{total_height}" style="background:#161b22; border-radius:10px; padding:10px; border:1px solid #30363d;">'
+    svg += f'<text x="{padding}" y="18" fill="#8b949e" font-family="monospace" font-size="12" font-weight="bold">{label}</text>'
+    y_start = 28
+    
+    for midi, wx in white_positions.items():
+        x = padding + wx * (white_key_w + 1)
+        is_active = midi in notes
+        fill = "#58a6ff" if is_active else "#e6edf3"
+        stroke = "#1f6feb" if is_active else "#8b949e"
+        svg += f'<rect x="{x}" y="{y_start}" width="{white_key_w}" height="{white_key_h}" fill="{fill}" stroke="{stroke}" stroke-width="{"2" if is_active else "1"}" rx="2"/>'
+        if is_active:
+            name = midi_to_name(midi)
+            svg += f'<text x="{x + white_key_w//2}" y="{y_start + white_key_h - 6}" fill="#0d1117" font-family="monospace" font-size="8" text-anchor="middle" font-weight="bold">{name}</text>'
+    
+    for i in range(num_keys):
+        midi = start_midi + i
+        pc = midi % 12
+        if pc in black_x_offset:
+            octave_offset = (midi - pc - start_midi) // 12
+            x = padding + (black_x_offset[pc] + (octave_offset * 7)) * (white_key_w + 1)
+            is_active = midi in notes
+            fill = "#1f6feb" if is_active else "#0d1117"
+            stroke = "#58a6ff" if is_active else "#30363d"
+            svg += f'<rect x="{x}" y="{y_start}" width="{black_key_w}" height="{black_key_h}" fill="{fill}" stroke="{stroke}" rx="1"/>'
+            if is_active:
+                name = midi_to_name(midi)
+                svg += f'<text x="{x + black_key_w//2}" y="{y_start + black_key_h + 12}" fill="#58a6ff" font-family="monospace" font-size="7" text-anchor="middle">{name}</text>'
+    
+    svg += '</svg>'
+    return svg
+
+st.markdown("---")
+st.subheader("🎵 Song Structure Builder")
+st.caption("Build your song section by section. Add any section in any order!")
+
+if len(st.session_state.song_sections) == 0:
+    st.info("👇 Click below to add your first section (Verse, Chorus, Intro, Bridge, etc.)")
+    if st.button("➕ Add First Section", type="primary", use_container_width=True):
+        add_section()
+        st.rerun()
+
+for idx, section in enumerate(st.session_state.song_sections):
+    with st.container():
+        col_num, col_name, col_up, col_down, col_dup, col_del = st.columns([0.5, 3, 0.5, 0.5, 0.5, 0.5])
+        
+        with col_num:
+            st.markdown(f"<div style='background: linear-gradient(135deg, #238636, #2ea043); border-radius: 8px; padding: 0.5rem; text-align: center; color: white; font-weight: bold;'>#{idx + 1}</div>", unsafe_allow_html=True)
+        
+        with col_name:
+            section['name'] = st.text_input(
+                "Section Name",
+                value=section['name'],
+                key=f"name_{section['id']}",
+                label_visibility="collapsed",
+                placeholder="e.g., Verse 1, Chorus, Bridge, Drop..."
+            )
+        
+        with col_up:
+            if st.button("⬆️", key=f"up_{section['id']}", help="Move up", disabled=(idx == 0)):
+                move_section_up(section['id'])
+                st.rerun()
+        
+        with col_down:
+            if st.button("⬇️", key=f"down_{section['id']}", help="Move down", disabled=(idx == len(st.session_state.song_sections) - 1)):
+                move_section_down(section['id'])
+                st.rerun()
+        
+        with col_dup:
+            if st.button("📋", key=f"dup_{section['id']}", help="Duplicate"):
+                duplicate_section(section['id'])
+                st.rerun()
+        
+        with col_del:
+            if st.button("🗑️", key=f"del_{section['id']}", help="Delete"):
+                remove_section(section['id'])
+                st.rerun()
+        
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            if "Roman" in input_mode:
+                help_text = "Roman numerals: I ii iii IV V vi vii°"
+            else:
+                help_text = "e.g., Cmaj7 Am7 Fmaj7 G7"
+            
+            section['chords'] = st.text_input(
+                "Chord Progression",
+                value=section['chords'],
+                key=f"chords_{section['id']}",
+                placeholder=help_text,
+                help=help_text
+            )
+        
+        with col2:
+            section['genre'] = st.selectbox(
+                "Genre/Style",
+                ["Pop", "Jazz", "Gospel", "Blues", "Classical", "RnB", "Waltz"],
+                index=["Pop", "Jazz", "Gospel", "Blues", "Classical", "RnB", "Waltz"].index(section['genre']),
+                key=f"genre_{section['id']}"
+            )
+        
+        with st.expander("⚙️ Advanced Settings", expanded=False):
+            col_lh, col_rh = st.columns(2)
+            with col_lh:
+                section['lh_octave'] = st.slider(
+                    "Left Hand Octave",
+                    1, 4, section['lh_octave'],
+                    key=f"lh_{section['id']}"
+                )
+            with col_rh:
+                section['rh_octave'] = st.slider(
+                    "Right Hand Octave",
+                    3, 6, section['rh_octave'],
+                    key=f"rh_{section['id']}"
+                )
+        
+        st.markdown("---")
+
+col_add, col_space = st.columns([1, 3])
+with col_add:
+    if st.button("➕ Add Section", use_container_width=True):
+        add_section()
+        st.rerun()
+
+st.markdown("---")
+
+if st.button("🎹 Generate Full Song", type="primary", use_container_width=True):
+    if len(st.session_state.song_sections) == 0:
+        st.error("❌ Please add at least one section first!")
+    else:
+        all_results = []
+        progression_data = []
+        prev_rh = None
+        
+        for section_idx, section in enumerate(st.session_state.song_sections):
+            if not section['chords'].strip():
+                st.warning(f"⚠️ Section '{section['name']}' has no chords. Skipping.")
+                continue
+            
+            st.markdown(f"### 🎵 {section['name']}")
+            st.caption(f"**Genre:** {section['genre']} • **Chords:** {section['chords']}")
+            
+            tokens = section['chords'].strip().split()
+            section_results = []
+            
+            for token in tokens:
+                try:
+                    if "Roman" in input_mode:
+                        root_pc, quality = roman_to_chord(token, key_pc)
+                        chord_label = f"{pc_to_note_name(root_pc)}{quality} ({token})"
+                    else:
+                        root_pc, quality = parse_chord_symbol(token)
+                        chord_label = token
+                    
+                    lh, rh = GenreVoicer.voice(
+                        root_pc, quality, section['genre'],
+                        octave_lh=section['lh_octave'],
+                        octave_rh=section['rh_octave']
+                    )
+                    
+                    if use_negative:
+                        lh = NegativeHarmony.mirror_in_key(lh, neg_key_pc)
+                        rh = NegativeHarmony.mirror_in_key(rh, neg_key_pc)
+                    
+                    if use_voice_leading and prev_rh:
+                        rh = VoiceLeader.lead(prev_rh, rh)
+                    
+                    has_issues, report, mud = SpectralAuditor.audit(lh, rh, context)
+                    
+                    if has_issues and context == "Full Band":
+                        mud_midis = {n for n, f in mud}
+                        rh = sorted([n + 12 if n in mud_midis and n < 60 else n for n in rh])
+                        has_issues, report, mud = SpectralAuditor.audit(lh, rh, context)
+                    
+                    prev_rh = rh
+                    
+                    result = {
+                        'section': section['name'],
+                        'label': chord_label,
+                        'lh': lh,
+                        'rh': rh,
+                        'report': report,
+                        'has_issues': has_issues,
+                        'lh_names': [midi_to_name(n) for n in lh],
+                        'rh_names': [midi_to_name(n) for n in rh],
+                        'genre': section['genre']
+                    }
+                    
+                    section_results.append(result)
+                    all_results.append(result)
+                    progression_data.append({'lh': lh, 'rh': rh})
+                    
+                except Exception as e:
+                    st.error(f"❌ Error parsing '{token}' in {section['name']}: {e}")
+            
+            if section_results:
+                for r in section_results:
+                    cols = st.columns([1.5, 2.5, 2.5])
+                    
+                    with cols[0]:
+                        st.markdown(f"**{r['label']}**")
+                        st.caption(f"🎨 {r['genre']}")
+                        st.code(f"LH: {', '.join(r['lh_names'])}", language=None)
+                        st.code(f"RH: {', '.join(r['rh_names'])}", language=None)
+                        if r['has_issues']:
+                            st.warning(r['report'])
+                        else:
+                            st.success(r['report'])
+                    
+                    with cols[1]:
+                        piano_lh = draw_piano_svg(r['lh'], "LEFT HAND", 24, 36)
+                        st.markdown(piano_lh, unsafe_allow_html=True)
+                    
+                    with cols[2]:
+                        piano_rh = draw_piano_svg(r['rh'], "RIGHT HAND", 48, 37)
+                        st.markdown(piano_rh, unsafe_allow_html=True)
+                
+                st.markdown("---")
+        
+        if progression_data:
+            st.subheader("💾 Export Full Song")
+            
+            try:
+                files = MidiExporter.export(progression_data, filename_prefix="full_song")
+                col1, col2 = st.columns(2)
+                with col1:
+                    with open(files['lh'], 'rb') as f:
+                        st.download_button(
+                            "⬇️ Download Left Hand MIDI",
+                            f, file_name="full_song_LH.mid",
+                            mime="audio/midi",
+                            use_container_width=True
+                        )
+                with col2:
+                    with open(files['rh'], 'rb') as f:
+                        st.download_button(
+                            "⬇️ Download Right Hand MIDI",
+                            f, file_name="full_song_RH.mid",
+                            mime="audio/midi",
+                            use_container_width=True
+                        )
+            except Exception as e:
+                st.error(f"❌ MIDI export error: {e}")
+            
+            st.subheader("📊 Full Song Summary")
+            summary_data = []
+            for r in all_results:
+                summary_data.append({
+                    'Section': r['section'],
+                    'Chord': r['label'],
+                    'Genre': r['genre'],
+                    'LH Notes': ", ".join(r['lh_names']),
+                    'RH Notes': ", ".join(r['rh_names']),
+                    'Status': '✅ Clear' if not r['has_issues'] else '⚠️ Fixed'
+                })
+            st.dataframe(summary_data, use_container_width=True)

harmonic_engine.py

@@ -0,0 +1,365 @@
+import mido
+
+NOTE_NAMES = ['C','C#','D','D#','E','F','F#','G','G#','A','A#','B']
+ENHARMONIC = {
+    'Db':'C#','Eb':'D#','Fb':'E','Gb':'F#',
+    'Ab':'G#','Bb':'A#','Cb':'B'
+}
+
+def note_name_to_pc(name):
+    clean = ENHARMONIC.get(name, name)
+    return NOTE_NAMES.index(clean)
+
+def pc_to_note_name(pc):
+    return NOTE_NAMES[pc % 12]
+
+def midi_to_name(midi_num):
+    octave = (midi_num // 12) - 1
+    return f"{NOTE_NAMES[midi_num % 12]}{octave}"
+
+def midi_to_freq(n):
+    return 440.0 * (2 ** ((n - 69) / 12))
+
+MAJOR_SCALE_INTERVALS = [0, 2, 4, 5, 7, 9, 11]
+
+MAJOR_SCALE_QUALITIES = {
+    1: 'maj', 2: 'min', 3: 'min', 4: 'maj',
+    5: 'maj', 6: 'min', 7: 'dim'
+}
+
+ROMAN_MAP = {
+    'I':1, 'II':2, 'III':3, 'IV':4,
+    'V':5, 'VI':6, 'VII':7,
+    'i':1, 'ii':2, 'iii':3, 'iv':4,
+    'v':5, 'vi':6, 'vii':7
+}
+
+CHORD_INTERVALS = {
+    'maj':       [0, 4, 7],
+    'min':       [0, 3, 7],
+    'dim':       [0, 3, 6],
+    'aug':       [0, 4, 8],
+    'maj7':      [0, 4, 7, 11],
+    'min7':      [0, 3, 7, 10],
+    'dom7':      [0, 4, 7, 10],
+    '7':         [0, 4, 7, 10],
+    'dim7':      [0, 3, 6, 9],
+    'hdim7':     [0, 3, 6, 10],
+    'sus2':      [0, 2, 7],
+    'sus4':      [0, 5, 7],
+    'add9':      [0, 4, 7, 14],
+    '6':         [0, 4, 7, 9],
+    'min6':      [0, 3, 7, 9],
+    '9':         [0, 4, 7, 10, 14],
+    'min9':      [0, 3, 7, 10, 14],
+    'maj9':      [0, 4, 7, 11, 14],
+    '11':        [0, 4, 7, 10, 14, 17],
+    '13':        [0, 4, 7, 10, 14, 21],
+}
+
+def parse_chord_symbol(symbol):
+    symbol = symbol.strip()
+    if len(symbol) > 1 and symbol[1] in '#b':
+        root_str = symbol[:2]
+        quality_str = symbol[2:]
+    else:
+        root_str = symbol[0]
+        quality_str = symbol[1:]
+
+    root_pc = note_name_to_pc(root_str)
+
+    q = quality_str.lower()
+    if q in ('', 'maj', 'major'):
+        quality = 'maj'
+    elif q in ('m', 'min', 'minor'):
+        quality = 'min'
+    elif q in ('maj7', 'major7'):
+        quality = 'maj7'
+    elif q in ('m7', 'min7', 'minor7'):
+        quality = 'min7'
+    elif q == '7':
+        quality = 'dom7'
+    elif q in ('dim', 'dim7', 'o', 'o7'):
+        quality = 'dim7' if '7' in q else 'dim'
+    elif q in ('hdim7', 'm7b5', 'ø7', 'ø'):
+        quality = 'hdim7'
+    elif q in ('aug', '+'):
+        quality = 'aug'
+    elif q == 'sus2':
+        quality = 'sus2'
+    elif q == 'sus4':
+        quality = 'sus4'
+    elif q == 'add9':
+        quality = 'add9'
+    elif q in ('6',):
+        quality = '6'
+    elif q in ('m6', 'min6'):
+        quality = 'min6'
+    elif q == '9':
+        quality = '9'
+    elif q in ('m9', 'min9'):
+        quality = 'min9'
+    elif q == 'maj9':
+        quality = 'maj9'
+    elif q == '11':
+        quality = '11'
+    elif q == '13':
+        quality = '13'
+    else:
+        quality = 'maj'
+
+    return root_pc, quality
+
+def roman_to_chord(roman_str, key_root_pc):
+    roman_str = roman_str.strip()
+
+    suffix = ''
+    base_roman = roman_str
+    for s in ['maj7','min7','m7','7','dim','aug','sus2','sus4','9','11','13']:
+        if roman_str.lower().endswith(s):
+            suffix = s
+            base_roman = roman_str[:-len(s)]
+            break
+
+    upper = base_roman.upper()
+    if upper not in ROMAN_MAP:
+        raise ValueError(f"Unknown Roman numeral: {roman_str}")
+
+    degree = ROMAN_MAP[upper]
+    is_minor_numeral = base_roman == base_roman.lower() and base_roman != base_roman.upper()
+
+    root_pc = (key_root_pc + MAJOR_SCALE_INTERVALS[degree - 1]) % 12
+
+    if suffix:
+        q = suffix.lower()
+        if q in ('m7', 'min7'):
+            quality = 'min7'
+        elif q == 'maj7':
+            quality = 'maj7'
+        elif q == '7':
+            quality = 'dom7'
+        elif q == 'dim':
+            quality = 'dim'
+        elif q == 'aug':
+            quality = 'aug'
+        else:
+            quality = q if q in CHORD_INTERVALS else 'maj'
+    else:
+        if is_minor_numeral:
+            quality = 'min'
+        else:
+            quality = MAJOR_SCALE_QUALITIES.get(degree, 'maj')
+
+    return root_pc, quality
+
+class GenreVoicer:
+    @staticmethod
+    def voice(root_pc, quality, genre, octave_lh=2, octave_rh=4):
+        lh_base = (octave_lh + 1) * 12
+        rh_base = (octave_rh + 1) * 12
+
+        root_lh = lh_base + root_pc
+        root_rh = rh_base + root_pc
+
+        intervals = CHORD_INTERVALS.get(quality, [0, 4, 7])
+
+        third = 4 if 4 in intervals else (3 if 3 in intervals else None)
+        fifth = 7 if 7 in intervals else (6 if 6 in intervals else (8 if 8 in intervals else None))
+        seventh = None
+        for s in [11, 10, 9]:
+            if s in intervals:
+                seventh = s
+                break
+
+        method = getattr(GenreVoicer, f'_voice_{genre.lower()}', GenreVoicer._voice_pop)
+        return method(root_pc, root_lh, root_rh, intervals, third, fifth, seventh, quality)
+
+    @staticmethod
+    def _voice_pop(root_pc, root_lh, root_rh, intervals, third, fifth, seventh, quality):
+        lh = [root_lh]
+        rh = []
+        if third is not None:
+            rh.append(root_rh + third)
+        if fifth is not None:
+            rh.append(root_rh + fifth)
+        if seventh is not None:
+            rh.append(root_rh + seventh)
+        if not rh:
+            rh = [root_rh + iv for iv in intervals if iv != 0]
+        if len(rh) < 3:
+            rh.append(root_rh + 12)
+        return lh, sorted(rh)
+
+    @staticmethod
+    def _voice_jazz(root_pc, root_lh, root_rh, intervals, third, fifth, seventh, quality):
+        lh = [root_lh]
+        if seventh is not None:
+            lh.append(root_lh + seventh)
+        else:
+            lh.append(root_lh + (10 if third == 3 else 11))
+
+        rh = []
+        if third is not None:
+            rh.append(root_rh + third)
+        sev = seventh if seventh else (10 if third == 3 else 11)
+        rh.append(root_rh + sev)
+        rh.append(root_rh + 14)
+        if third == 4:
+            rh.append(root_rh + 21)
+
+        return lh, sorted(rh)
+
+    @staticmethod
+    def _voice_gospel(root_pc, root_lh, root_rh, intervals, third, fifth, seventh, quality):
+        lh = [root_lh]
+        if fifth is not None:
+            lh.append(root_lh + fifth)
+
+        rh = []
+        if third is not None:
+            rh.append(root_rh + third)
+        if fifth is not None:
+            rh.append(root_rh + fifth)
+        sev = seventh if seventh else 11
+        rh.append(root_rh + sev)
+        rh.append(root_rh + 14)
+        rh.append(root_rh + 12)
+
+        return lh, sorted(rh)
+
+    @staticmethod
+    def _voice_blues(root_pc, root_lh, root_rh, intervals, third, fifth, seventh, quality):
+        lh = [root_lh, root_lh + 10]
+
+        rh = []
+        t = third if third else 4
+        rh.append(root_rh + t)
+        if fifth:
+            rh.append(root_rh + fifth)
+        rh.append(root_rh + 10)
+        rh.append(root_rh + 14)
+
+        return lh, sorted(rh)
+
+    @staticmethod
+    def _voice_classical(root_pc, root_lh, root_rh, intervals, third, fifth, seventh, quality):
+        lh = [root_lh, root_lh + 12]
+        rh = [root_rh + iv for iv in intervals if iv != 0]
+        if not rh:
+            rh = [root_rh + 4, root_rh + 7]
+        return lh, sorted(rh)
+
+    @staticmethod
+    def _voice_rnb(root_pc, root_lh, root_rh, intervals, third, fifth, seventh, quality):
+        lh = [root_lh]
+        rh = []
+        if third:
+            rh.append(root_rh + third)
+        sev = seventh if seventh else (10 if third == 3 else 11)
+        rh.append(root_rh + sev)
+        rh.append(root_rh + 14)
+        if third == 3:
+            rh.append(root_rh + 17)
+        else:
+            rh.append(root_rh + 21)
+        return lh, sorted(rh)
+
+    @staticmethod
+    def _voice_waltz(root_pc, root_lh, root_rh, intervals, third, fifth, seventh, quality):
+        lh = [root_lh]
+        rh = []
+        if third:
+            rh.append(root_rh + third)
+        if fifth:
+            rh.append(root_rh + fifth)
+        if seventh:
+            rh.append(root_rh + seventh)
+        if not rh:
+            rh = [root_rh + 4, root_rh + 7]
+        return lh, sorted(rh)
+
+class VoiceLeader:
+    @staticmethod
+    def lead(prev_rh, current_rh):
+        if not prev_rh or not current_rh:
+            return current_rh
+
+        centroid = sum(prev_rh) / len(prev_rh)
+        result = []
+        for note in current_rh:
+            pc = note % 12
+            candidates = [pc + (oct * 12) for oct in range(2, 8)]
+            best = min(candidates, key=lambda x: abs(x - centroid))
+            result.append(best)
+
+        return sorted(result)
+
+class SpectralAuditor:
+    MUD_ZONE = (160, 400)
+
+    @classmethod
+    def audit(cls, lh_notes, rh_notes, context="Full Band"):
+        issues = []
+        suggestions = []
+
+        all_notes = lh_notes + rh_notes
+        freqs = [(n, midi_to_freq(n)) for n in all_notes]
+
+        mud_notes = [(n, f) for n, f in freqs if cls.MUD_ZONE[0] <= f <= cls.MUD_ZONE[1]]
+
+        if context == "Full Band" and len(mud_notes) > 2:
+            issues.append(
+                f"⚠️ MUD WARNING: {len(mud_notes)} notes in {cls.MUD_ZONE[0]}-{cls.MUD_ZONE[1]}Hz"
+            )
+            suggestions.append("💡 Shift inner RH notes up one octave")
+
+        low_notes = sorted([n for n in all_notes if n < 48])
+        for i in range(len(low_notes) - 1):
+            if low_notes[i+1] - low_notes[i] < 5:
+                issues.append(
+                    f"⚠️ LOW CLASH: {midi_to_name(low_notes[i])} and {midi_to_name(low_notes[i+1])}"
+                )
+
+        if not issues:
+            status = "✅ MIX CLEAR"
+        else:
+            status = "\n".join(issues + suggestions)
+
+        return len(issues) > 0, status, mud_notes
+
+class NegativeHarmony:
+    @staticmethod
+    def mirror_in_key(notes, key_root_pc):
+        root_midi = 60 + key_root_pc
+        fifth_midi = root_midi + 7
+        axis = (root_midi + fifth_midi) / 2
+        return sorted([int(2 * axis - n) for n in notes])
+
+class MidiExporter:
+    @staticmethod
+    def export(progression_data, filename_prefix="session"):
+        files = {}
+        for lane in ["lh", "rh"]:
+            mid = mido.MidiFile(ticks_per_beat=480)
+            track = mido.MidiTrack()
+            mid.tracks.append(track)
+            track.append(mido.MetaMessage('track_name', name=f'{lane.upper()}'))
+
+            for chord_data in progression_data:
+                notes = chord_data[lane]
+                velocity = 70 if lane == "lh" else 85
+
+                for n in notes:
+                    n = max(0, min(127, n))
+                    track.append(mido.Message('note_on', note=n, velocity=velocity, time=0))
+
+                track.append(mido.Message('note_off', note=max(0, min(127, notes[0])), velocity=0, time=1920))
+                for n in notes[1:]:
+                    n = max(0, min(127, n))
+                    track.append(mido.Message('note_off', note=n, velocity=0, time=0))
+
+            fname = f"{filename_prefix}_{lane}.mid"
+            mid.save(fname)
+            files[lane] = fname
+
+        return files