Correct chord spelling with local keys and canonicalize key labels

Apply the SheetSage2 LM chord-spelling scorer at each chord midpoint in LAB, ABC and playback exports. Canonicalize key labels using the LM/NoLM key map without changing numeric token IDs or the vocabulary fingerprint. Verify pitch spelling against NoLM, preserve raw decoded chord events, and add regression coverage for key changes, inversions, in-memory exports, paper mode and melody-only mode.

README.md

@@ -46,6 +46,12 @@ Built on [MERT-v2-FullSong](https://huggingface.co/m-a-p/MERT-v2-FullSong), with
 
 ![SheetSage2 architecture](assets/architecture.png)
 
+**Update log:**
+
+**2026-09-21:** Fixed missing enharmonic spelling correction for key and chord labels. Chord spelling now follows the local key. It affects ABC output only.
+
+If you downloaded the repository or model before this update (2026-09-21), please update to the latest repository code. **Model weights are unchanged.**
+
 <a id="quick-start"></a>
 
 ## 🚀 Quick start
@@ -101,6 +107,21 @@ model = AutoModel.from_pretrained(
 )
 ```
 
+### Key and chord spelling
+
+Chord LAB annotations and ABC symbols use the local key at each chord
+interval's midpoint to correct enharmonic root spelling, following SheetSage2 LM
+(for example, D#/G#/A# become Eb/Ab/Bb in C minor). Timing, chord quality,
+inversion and sounding pitches stay unchanged. Without a decoded key, spelling
+is preserved. Decoded events and tokens retain the original model predictions.
+This applies to both in-memory results and saved exports, including `paper=True`.
+
+Key labels use the canonical LM/NoLM spelling (D#:major becomes Eb:major;
+C#:major becomes Db:major; A#:minor becomes Bb:minor) in decoded events,
+token display and exported key intervals. Numeric token IDs and the vocabulary
+fingerprint are unchanged. ABC melody spelling follows NoLM's key-relative
+pitch table, including accidental resets at barlines and key changes.
+
 ### Melody-only ABC for covers
 
 Set `melody_only=True` to retain both the `Vocal` and `Ins` melodies while omitting chord symbols from the ABC and chord accompaniment from playback/combined MIDI. Raw predicted annotations remain available; the default full transcription is unchanged.

chord_spelling_sheetsage2.py

@@ -0,0 +1,177 @@
+"""Local-key chord spelling, ported from SheetSage2 LM."""
+import numpy as np
+import mir_eval.chord
+
+KEY_MAP = [
+    ['C:major', 'Db:major', 'D:major', 'Eb:major', 'E:major', 'F:major', 'F#:major', 'G:major', 'Ab:major', 'A:major', 'Bb:major', 'B:major'],
+    ['D:dorian', 'Eb:dorian', 'E:dorian', 'F:dorian', 'F#:dorian', 'G:dorian', 'G#:dorian', 'A:dorian', 'Bb:dorian', 'B:dorian', 'C:dorian', 'C#:dorian'],
+    ['E:phrygian', 'F:phrygian', 'F#:phrygian', 'G:phrygian', 'G#:phrygian', 'A:phrygian', 'A#:phrygian', 'B:phrygian', 'C:phrygian', 'C#:phrygian', 'D:phrygian', 'D#:phrygian'],
+    ['F:lydian', 'Gb:lydian', 'G:lydian', 'Ab:lydian', 'A:lydian', 'Bb:lydian', 'B:lydian', 'C:lydian', 'Db:lydian', 'D:lydian', 'Eb:lydian', 'E:lydian'],
+    ['G:mixolydian', 'Ab:mixolydian', 'A:mixolydian', 'Bb:mixolydian', 'B:mixolydian', 'C:mixolydian', 'C#:mixolydian', 'D:mixolydian', 'Eb:mixolydian', 'E:mixolydian', 'F:mixolydian', 'F#:mixolydian'],
+    ['A:minor', 'Bb:minor', 'B:minor', 'C:minor', 'C#:minor', 'D:minor', 'D#:minor', 'E:minor', 'F:minor', 'F#:minor', 'G:minor', 'G#:minor'],
+    ['B:locrian', 'C:locrian', 'C#:locrian', 'D:locrian', 'D#:locrian', 'E:locrian', 'E#:locrian', 'F#:locrian', 'G:locrian', 'G#:locrian', 'A:locrian', 'A#:locrian']
+]
+
+MODE_NAMES = ['major', 'dorian', 'phrygian', 'lydian', 'mixolydian', 'minor', 'locrian']
+MODE_STARTS = [0, 2, 4, 5, 7, 9, 11]
+
+
+QUALITIES = {
+    #           1     2     3     4  5     6     7
+    'maj':     [2, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0],
+    'min':     [2, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0],
+    'aug':     [2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
+    'dim':     [2, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0],
+    'sus4':    [2, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0],
+    'sus4(b7)':[2, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0],
+    'sus4(b7,9)':[2, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0],
+    'sus2':    [2, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+    '7':       [2, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0],
+    'maj7':    [2, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1],
+    'min7':    [2, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0],
+    'minmaj7': [2, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1],
+    'maj6':    [2, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0],
+    'min6':    [2, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0],
+    '9':       [2, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0],
+    'maj9':    [2, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1],
+    'min9':    [2, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0],
+    '7(b9)':   [2, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0],
+    '7(#9)':   [2, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0],
+    'maj6(9)': [2, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0],
+    'min6(9)': [2, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0],
+    'maj(9)':  [2, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0],
+    'min(9)':  [2, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0],
+    'maj(11)': [2, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1],
+    'min(11)': [2, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
+    '11':      [2, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0],
+    'maj9(11)':[2, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1],
+    'min11':   [2, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0],
+    '13':      [2, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0],
+    'maj13':   [2, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1],
+    'min13':   [2, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0],
+    'dim7':    [2, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0],
+    'hdim7':   [2, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0],
+    #'5':       [2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
+    }
+DEFAULT_SPELLING = ['1', 'b2', '2', 'b3', '3', '4', 'b5', '5', '#5', '6', 'b7', '7']
+CHORD_SPELLING_TABLE = None
+CIRCLE_OF_FIFTH = np.array([3, 0, 5, 1, 6, 2, 7])
+CIRCLE_OF_FIFTH_INV = np.array([1, 3, 5, 0, 2, 4, 6])
+NOTE_NAMES = 'CDEFGAB'
+
+def scale_degree_to_tuple(scale_degree):
+    offset = 0
+    if scale_degree.startswith("#"):
+        offset = scale_degree.count("#")
+        scale_degree = scale_degree.strip("#")
+    elif scale_degree.startswith("b"):
+        offset = -1 * scale_degree.count("b")
+        scale_degree = scale_degree.strip("b")
+    return np.array([int(scale_degree) - 1, offset], dtype=int)
+
+def note_name_to_tuple(note_name):
+    scale_degree = NOTE_NAMES.index(note_name[0])
+    offset = 0
+    if note_name.endswith("#"):
+        offset = note_name.count("#")
+    elif note_name.endswith("b"):
+        offset = -1 * note_name.count("b")
+    return np.array([scale_degree, offset], dtype=int)
+
+def scale_degrees_to_tuple(scale_degrees):
+    return np.stack([scale_degree_to_tuple(sd) for sd in scale_degrees], axis=0)
+
+
+def get_chord_spelling_table():
+    global CHORD_SPELLING_TABLE
+    if CHORD_SPELLING_TABLE is not None:
+        return CHORD_SPELLING_TABLE
+    chord_spelling_table = {}
+    for quality in QUALITIES:
+        quality_spelling = []
+        chroma = QUALITIES[quality]
+        for i in range(12):
+            if chroma[i] > 0:
+                if '#9' in quality and i == DEFAULT_SPELLING.index('b3'):
+                    quality_spelling.append('#2')
+                elif 'dim7' in quality and i == DEFAULT_SPELLING.index('6'):
+                    quality_spelling.append('bb7')
+                else:
+                    quality_spelling.append(DEFAULT_SPELLING[i])
+        chord_spelling_table[quality] = scale_degrees_to_tuple(quality_spelling)
+    CHORD_SPELLING_TABLE = chord_spelling_table
+    return chord_spelling_table
+
+def score_spelling_under_key(spelling, key):
+    '''
+    Score the chord spelling under a given key.
+    :param spelling: Numpy array of shape (N, 2)
+    :param key: Numpy array of shape (2,) representing the degree of 1 (DO)
+    :return: Score of the chord spelling under the key.
+    '''
+    key_pos = CIRCLE_OF_FIFTH_INV[key[0]] + key[1] * 7
+    spelling_pos = CIRCLE_OF_FIFTH_INV[spelling[:, 0] % 7] + spelling[:, 1] * 7
+    relative_pos = np.clip(np.abs((spelling_pos - (key_pos + 2))) - 3, 0, None)
+    return np.sum(relative_pos) + np.sum(relative_pos[:1]) * 1.0  # root matters more
+
+def normalize_key_name(key_name):
+    """Use the same canonical tonal spelling as SheetSage2 LM/NoLM."""
+    tonic, mode = key_name.split(':')
+    mode_id = MODE_NAMES.index(mode)
+    scale = (mir_eval.chord.pitch_class_to_semitone(tonic) - MODE_STARTS[mode_id]) % 12
+    return KEY_MAP[mode_id][scale]
+
+
+def correct_chord_spelling(label, key_name):
+    if label == 'N' or label == 'X':
+        return label
+    key_tonal, key_mode = key_name.split(':')
+    key_mode = MODE_NAMES.index(key_mode)
+    scale_semitone = (mir_eval.chord.pitch_class_to_semitone(key_tonal) - MODE_STARTS[key_mode]) % 12
+    # Tokenizer keys use sharps; map enharmonic aliases to the LM key signature.
+    key_spelling = note_name_to_tuple(KEY_MAP[0][scale_semitone].split(':')[0])
+    # Ignore all inversions
+    inversion = ''
+    if '/' in label:
+        label, inversion = label.split('/')
+    # Separate quality and root
+    root, quality = label.split(':')
+    root_semitone = mir_eval.chord.pitch_class_to_semitone(root)
+    scores = []
+    for possible_root_id in range(7):
+        possible_root = NOTE_NAMES[possible_root_id]
+        root_spelling = np.array([
+            possible_root_id,
+            (root_semitone - mir_eval.chord.pitch_class_to_semitone(possible_root) + 6) % 12 - 6
+        ])
+        chord_spelling = get_chord_spelling_table()[quality] + root_spelling[None, :]
+        scores.append(score_spelling_under_key(chord_spelling, key_spelling))
+    best_root_id = np.argmin(scores)
+    best_root = NOTE_NAMES[best_root_id]
+    best_root_spelling = np.array([
+        best_root_id,
+        (root_semitone - mir_eval.chord.pitch_class_to_semitone(best_root) + 6) % 12 - 6
+    ])
+    if best_root_spelling[1] < 0:
+        best_root = best_root + 'b' * abs(best_root_spelling[1])
+    else:
+        best_root = best_root + '#' * best_root_spelling[1]
+    if inversion:
+        return f"{best_root}:{quality}/{inversion}"
+    else:
+        return f"{best_root}:{quality}"
+
+
+def correct_chord_rows(chords, keys):
+    """Use the local key at each chord midpoint, as in SheetSage2 LM.
+
+    Match LM's left-boundary tie rule. Extend the first/last decoded key to
+    uncovered edges. Without a decoded key, preserve the original spelling.
+    Return new rows without changing event values, timing, quality or inversion.
+    """
+    if not keys:
+        return [list(row) for row in chords]
+    boundaries = np.array([row[1] for row in keys[:-1]])
+    return [[start, end, correct_chord_spelling(
+        label, keys[np.searchsorted(boundaries, (start + end) / 2.0)][2])]
+        for start, end, label in chords]

exports_sheetsage2.py

@@ -1,4 +1,4 @@
-"""Lossless decoded events/LAB/MIDI, then independently validated ABC."""
+"""Raw decoded events, key-aware chord LAB, MIDI and validated ABC."""
 from pathlib import Path
 import json
 from fractions import Fraction
@@ -9,6 +9,7 @@ import pretty_midi
 from .notation_sheetsage2 import generate_abc_from_data
 from .io_sheetsage2 import atomic_write_text
 from .generation_sheetsage2 import field_text
+from .chord_spelling_sheetsage2 import correct_chord_rows, normalize_key_name
 from .midi_sheetsage2 import build_playback, midi_bytes
 
 
@@ -76,7 +77,7 @@ def export_result(decoded, tokenizer, output_dir=None, duration=None, paper=Fals
     Statistics retain their file-interface names. ``payload`` contains the
     in-memory ABC text, MIDI bytes, decoded event list, LAB texts and playback.
     melody_only removes chords from notation and playback without changing
-    decoded events or raw LAB annotations.
+    decoded events or the key-corrected LAB annotations.
     """
     if not isinstance(melody_only, bool):
         raise ValueError("melody_only must be True or False")
@@ -118,6 +119,10 @@ def export_result(decoded, tokenizer, output_dir=None, duration=None, paper=Fals
             for i, row in enumerate(rows):
                 row[1] = max(row[0], rows[i + 1][0]) if i + 1 < len(rows) else float(duration)
         intervals[field] = rows
+    intervals["key"] = [[start, end, normalize_key_name(key)]
+                        for start, end, key in intervals["key"]]
+    intervals["chord"] = correct_chord_rows(intervals["chord"], intervals["key"])
+    for field, rows in intervals.items():
         keep_rows(f"{field}.lab", rows)
     if paper:
         rows = []
@@ -154,6 +159,10 @@ def export_result(decoded, tokenizer, output_dir=None, duration=None, paper=Fals
         notation_intervals = {}
         for field, suffix in (("chord", "chords"), ("key", "keys"), ("structure", "structures")):
             rows = interval_rows(events, field, duration)
+            if field == "chord":
+                rows = correct_chord_rows(rows, interval_rows(events, "key", duration))
+            elif field == "key":
+                rows = [[start, end, normalize_key_name(key)] for start, end, key in rows]
             # Clip to the actual beat domain: events beyond it have no ABC bin.
             rows = [[max(abc_beats[0][0], a), min(abc_beats[-1][0], b), v]
                     for a, b, v in rows if b > abc_beats[0][0] and a < abc_beats[-1][0]]

tests/test_spelling.py

@@ -0,0 +1,128 @@
+import copy
+import json
+from pathlib import Path
+from tempfile import TemporaryDirectory
+import unittest
+
+import mir_eval.chord
+import numpy as np
+
+from ..chord_spelling_sheetsage2 import correct_chord_rows, correct_chord_spelling, normalize_key_name
+from ..tokenization_sheetsage2 import SheetSage2Tokenizer as Tokenizer, FULL_CHORD_VOCABULARY
+from ..exports_sheetsage2 import export_result
+from ..notation_sheetsage2 import get_key_accidentals, note_to_abc
+
+
+def example():
+    events = []
+    for i in range(16):
+        values = {'rhythm': {'meter': [4, 4], 'eighth_position': i % 4 * 2},
+                  'melody': [{'pitch': [63, 68, 70, 67][i % 4], 'track': 1,
+                              'end_time': (i + 1) * .5, 'duration_bin': 2, 'duration_steps': 4}]}
+        if i == 0:
+            values.update(key='D#:major', chord='D#:maj/3', structure='verse')
+        if i == 4:
+            values['chord'] = 'G#:maj'
+        if i == 8:
+            values.update(key='G#:minor', chord='D#:min')
+        events.append({'time': i * .5, 'global_subbeat': i * 4, 'values': values})
+    return {'events': events}
+
+
+class SpellingTests(unittest.TestCase):
+    def test_cm_chords_and_inversions(self):
+        for raw, expected in [('D#:maj', 'Eb:maj'), ('G#:maj', 'Ab:maj'),
+                              ('A#:7/3', 'Bb:7/3'), ('D#:min7/b7', 'Eb:min7/b7'),
+                              ('C:min', 'C:min'), ('N', 'N'), ('X', 'X')]:
+            self.assertEqual(correct_chord_spelling(raw, 'C:minor'), expected)
+
+    def test_local_midpoint_including_boundary_and_missing_keys(self):
+        rows = [[0, 2, 'G#:maj'], [2, 6, 'G#:maj'], [6, 8, 'G#:maj']]
+        keys = [[0, 4, 'C:minor'], [4, 8, 'E:major']]
+        original = copy.deepcopy((rows, keys))
+        self.assertEqual([r[2] for r in correct_chord_rows(rows, keys)], ['Ab:maj', 'Ab:maj', 'G#:maj'])
+        self.assertEqual((rows, keys), original)
+        self.assertEqual(correct_chord_rows(rows, []), rows)
+        self.assertEqual(correct_chord_rows([], keys), [])
+
+    def test_key_labels_keep_ids_and_checkpoint_fingerprint(self):
+        tokenizer = Tokenizer(300, 100)
+        self.assertEqual(tokenizer.vocab_fingerprint, '5ba3325af0344c7f')
+        major = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'F#', 'G', 'Ab', 'A', 'Bb', 'B']
+        minor = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'Bb', 'B']
+        for offset, roots, mode in [(0, major, 'major'), (12, minor, 'minor')]:
+            for i, root in enumerate(roots):
+                label = f'{root}:{mode}'
+                token = tokenizer.key_token_start + offset + i
+                self.assertEqual(tokenizer._decode_field('key', [token], ()), label)
+                self.assertEqual(tokenizer.describe(token), f'<key_{label}>')
+                self.assertEqual(tokenizer.key_to_token(label), token)
+                self.assertEqual(normalize_key_name(label), label)
+        self.assertEqual(tokenizer.key_to_token('D#:major'), tokenizer.key_to_token('Eb:major'))
+
+    def test_entire_chord_vocabulary_preserves_sounding_pitches(self):
+        for key in ('C:minor', 'E:major', 'A#:minor', 'C#:major', 'F#:major'):
+            for chord in FULL_CHORD_VOCABULARY:
+                spelled = correct_chord_spelling(chord, key)
+                before = mir_eval.chord.encode(chord)
+                after = mir_eval.chord.encode(spelled)
+                self.assertEqual(before[0], after[0])
+                np.testing.assert_array_equal(before[1], after[1])
+                self.assertEqual(before[2], after[2])
+                if chord != 'N':
+                    self.assertEqual(chord.split(':', 1)[1], spelled.split(':', 1)[1])
+
+    def test_nolm_key_relative_pitch_examples(self):
+        state = {}
+        self.assertEqual([note_to_abc(n, get_key_accidentals('Cm'), state) for n in (63, 68, 70, 75)],
+                         ['E', 'A', 'B', 'e'])
+        self.assertEqual(note_to_abc(67, get_key_accidentals('G#m'), {}), '^^F')
+        self.assertEqual(note_to_abc(59, get_key_accidentals('Db'), {}), '_C')
+        self.assertEqual(note_to_abc(60, get_key_accidentals('C#m'), {}), '^B,')
+        state = {}
+        self.assertEqual([note_to_abc(n, get_key_accidentals('Cm'), state) for n in (64, 76, 63)],
+                         ['=E', 'e', '_E'])
+        self.assertEqual(note_to_abc(63, get_key_accidentals('Cm'), {}), 'E')
+
+    def test_export_uses_corrected_labels_without_mutating_events(self):
+        decoded = example()
+        original = copy.deepcopy(decoded)
+        with TemporaryDirectory() as td:
+            root = Path(td)
+            result = export_result(decoded, Tokenizer(300, 100), root, 8)
+            self.assertIsNone(result['abc_error'])
+            self.assertEqual(decoded, original)
+            self.assertEqual(json.loads((root/'events.json').read_text()), original)
+            self.assertIn('Eb:major', (root/'key.lab').read_text())
+            self.assertNotIn('D#:major', (root/'notation/song_keys.txt').read_text())
+            for path in ['chord.lab', 'notation/song_chords.txt']:
+                text = (root/path).read_text()
+                self.assertIn('Eb:maj/3', text)
+                self.assertIn('Ab:maj', text)
+                self.assertIn('D#:min', text)
+            abc = (root/'score.abc').read_text()
+            self.assertIn('K:Eb', abc)
+            self.assertIn('"Eb/G"', abc)
+            self.assertIn('"Ab"', abc)
+            self.assertIn('K:G#m', abc)
+
+    def test_in_memory_paper_and_melody_only_exports(self):
+        for paper in (False, True):
+            for melody_only in (False, True):
+                decoded = example()
+                original = copy.deepcopy(decoded)
+                result = export_result(decoded, Tokenizer(300, 100), duration=8,
+                                       paper=paper, melody_only=melody_only)
+                self.assertIsNone(result['abc_error'])
+                payload = result['payload']
+                self.assertEqual(decoded, original)
+                self.assertEqual(payload['events'], original['events'])
+                self.assertIn('Eb:major', payload['labs']['key'])
+                self.assertIn('Eb:maj/3', payload['labs']['chord'])
+                self.assertIn('K:Eb', payload['abc'])
+                self.assertIn('K:G#m', payload['abc'])
+                self.assertEqual('"Eb/G"' in payload['abc'], not melody_only)
+
+
+if __name__ == '__main__':
+    unittest.main()

tokenization_sheetsage2.py

@@ -5,6 +5,8 @@ import json
 import mir_eval.chord
 import numpy as np
 
+from .chord_spelling_sheetsage2 import normalize_key_name
+
 from .durations_sheetsage2 import DURATION_TEMPLATES, duration_boundaries
 from .labels_sheetsage2 import STRUCTURE_LABELS
 from .schema_sheetsage2 import get_prompt_multitask_schema
@@ -495,7 +497,7 @@ class SheetSage2Tokenizer:
         if field == "key":
             key_id = field_tokens[0] - self.key_token_start
             mode = "minor" if key_id >= 12 else "major"
-            return f"{CHROMATIC_SHARPS[key_id % 12]}:{mode}"
+            return normalize_key_name(f"{CHROMATIC_SHARPS[key_id % 12]}:{mode}")
         if field == "chord":
             if token_types[0] == "chord_majmin":
                 return self.majmin_chord_labels[
@@ -714,7 +716,8 @@ class SheetSage2Tokenizer:
         if token_type == "key":
             key_id = token - self.key_token_start
             mode = "minor" if key_id >= 12 else "major"
-            return f"<key_{CHROMATIC_SHARPS[key_id % 12]}:{mode}>"
+            label = normalize_key_name(f"{CHROMATIC_SHARPS[key_id % 12]}:{mode}")
+            return f"<key_{label}>"
         if token_type == "chord_majmin":
             return f"<chord_majmin_{self.majmin_chord_labels[token - self.majmin_chord_token_start]}>"
         if token_type == "chord_full":