refactor: Improve passaggio calculation and dissonance detection context awareness

Enhance music theory utilities with better context-sensitive behavior:

Passaggio calculation:
- Add vocal_low and vocal_high fields to TessituraRange struct
- Use dynamic passaggio calculation based on actual vocal range instead of
  fixed zones (isInPassaggioRange replaces isInPassaggio)
- Update getComfortScore() and nearestChordToneWithinInterval() to use
  dynamic calculation

Dissonance detection:
- Add simultaneous parameter to isDissonantIntervalWithContext()
- Major 2nd (2 semitones) is now only dissonant for vertical intervals
  (simultaneous notes), not for melodic/horizontal intervals where it
  represents a natural scale step

Chord tension expansion:
- iii minor chord now includes b13th as available tension (natural 13th
  from scale = minor 6th from root)

Bass pattern selection:
- Extract selectPatternWithPolicyCore() template function to eliminate
  code duplication between selectPatternWithPolicy() and
  selectPatternWithPolicyForVocal()

MIDI writer:
- Remove debug assertions for meta text length (silent truncation is
  acceptable behavior for production)

Tests:
- Update all TessituraRange initializations to include vocal range fields

Author: libraz

src/core/chord_utils.cpp

@@ -92,7 +92,7 @@ std::vector<int> getAvailableTensionPitchClasses(int8_t degree) {
   // Available tensions by degree (in semitones from root):
   // I (0): 9th (+2), 13th (+9) - avoid 11th (#4 clashes with 3rd)
   // ii (1): 9th (+2), 11th (+5), 13th (+9)
-  // iii (2): 11th (+5) - avoid 9th (b9), avoid 13th (b13)
+  // iii (2): 11th (+5), b13th (+8) - avoid 9th (b9)
   // IV (3): 9th (+2), #11th (+6), 13th (+9)
   // V (4): 9th (+2), 13th (+9) - 11th only if sus4
   // vi (5): 9th (+2), 11th (+5) - avoid 13th (b13)
@@ -110,6 +110,8 @@ std::vector<int> getAvailableTensionPitchClasses(int8_t degree) {
       break;
     case 2:                                  // iii minor
       result.push_back((root_pc + 5) % 12);  // 11th
+      result.push_back((root_pc + 8) %
+                       12);  // b13th (natural 13th from scale = minor 6th from root)
       break;
     case 3:                                  // IV major
       result.push_back((root_pc + 2) % 12);  // 9th
@@ -211,7 +213,9 @@ int nearestChordToneWithinInterval(int target_pitch, int prev_pitch, int8_t chor
         if (candidate >= tessitura->low && candidate <= tessitura->high) {
           score += 15;  // Bonus for being in tessitura
         }
-        if (isInPassaggio(static_cast<uint8_t>(candidate))) {
+        // Use dynamic passaggio calculation based on vocal range
+        if (isInPassaggioRange(static_cast<uint8_t>(candidate), tessitura->vocal_low,
+                               tessitura->vocal_high)) {
           score -= 5;
         }
       }

src/core/pitch_utils.cpp

@@ -22,6 +22,8 @@ TessituraRange calculateTessitura(uint8_t vocal_low, uint8_t vocal_high) {
   t.low = static_cast<uint8_t>(vocal_low + margin);
   t.high = static_cast<uint8_t>(vocal_high - margin);
   t.center = static_cast<uint8_t>((t.low + t.high) / 2);
+  t.vocal_low = vocal_low;
+  t.vocal_high = vocal_high;
 
   // Ensure valid range
   if (t.low >= t.high) {
@@ -38,7 +40,7 @@ bool isInTessitura(uint8_t pitch, const TessituraRange& tessitura) {
 }
 
 float getComfortScore(uint8_t pitch, const TessituraRange& tessitura, uint8_t vocal_low,
-                      uint8_t /* vocal_high */) {
+                      uint8_t vocal_high) {
   // Perfect score for tessitura center
   if (pitch == tessitura.center) return 1.0f;
 
@@ -51,8 +53,8 @@ float getComfortScore(uint8_t pitch, const TessituraRange& tessitura, uint8_t vo
     return 0.8f + 0.2f * (1.0f - static_cast<float>(dist_from_center) / tessitura_half);
   }
 
-  // Reduced score for passaggio
-  if (isInPassaggio(pitch)) {
+  // Reduced score for passaggio (dynamically calculated based on voice range)
+  if (isInPassaggioRange(pitch, vocal_low, vocal_high)) {
     return 0.4f;
   }
 
@@ -140,7 +142,7 @@ bool isDissonantInterval(int pc1, int pc2) {
   return interval == 1 || interval == 6;
 }
 
-bool isDissonantIntervalWithContext(int pc1, int pc2, int8_t chord_degree) {
+bool isDissonantIntervalWithContext(int pc1, int pc2, int8_t chord_degree, bool simultaneous) {
   int interval = std::abs(pc1 - pc2);
   if (interval > 6) interval = 12 - interval;
 
@@ -149,10 +151,10 @@ bool isDissonantIntervalWithContext(int pc1, int pc2, int8_t chord_degree) {
     return true;
   }
 
-  // Major 2nd (2) is dissonant when tracks overlap
-  // While acceptable as passing tone or tension within a chord,
-  // it sounds harsh when Chord and Vocal play simultaneously
-  if (interval == 2) {
+  // Major 2nd (2) is dissonant only for simultaneous (vertical) intervals.
+  // In melodic (horizontal) context, it's a natural scale step and acceptable.
+  // When tracks play at the same time, M2 creates audible beating.
+  if (interval == 2 && simultaneous) {
     return true;
   }
 

src/core/pitch_utils.h

@@ -197,9 +197,11 @@ inline uint8_t transposePitch(uint8_t pitch, Key key) {
 
 /// @brief Tessitura: The comfortable singing range within full vocal range.
 struct TessituraRange {
-  uint8_t low;     ///< Lower bound of comfortable range
-  uint8_t high;    ///< Upper bound of comfortable range
-  uint8_t center;  ///< Center of tessitura (optimal pitch)
+  uint8_t low;         ///< Lower bound of comfortable range
+  uint8_t high;        ///< Upper bound of comfortable range
+  uint8_t center;      ///< Center of tessitura (optimal pitch)
+  uint8_t vocal_low;   ///< Full vocal range lower bound (for passaggio calculation)
+  uint8_t vocal_high;  ///< Full vocal range upper bound (for passaggio calculation)
 };
 
 /**
@@ -282,14 +284,18 @@ bool isDissonantInterval(int pc1, int pc2);
 /**
  * @brief Check for dissonance with chord context awareness.
  *
- * Tritone is allowed on V chord (dominant function).
+ * - Minor 2nd (1): always dissonant (harsh beating)
+ * - Major 2nd (2): dissonant only for simultaneous (vertical) intervals
+ * - Tritone (6): allowed on V chord (dominant function) and vii° chord
  *
  * @param pc1 First pitch class (0-11)
  * @param pc2 Second pitch class (0-11)
  * @param chord_degree Current chord's scale degree (0=I, 4=V, etc.)
+ * @param simultaneous true for vertical (same-time) intervals, false for melodic
  * @return true if interval is dissonant in this harmonic context
  */
-bool isDissonantIntervalWithContext(int pc1, int pc2, int8_t chord_degree);
+bool isDissonantIntervalWithContext(int pc1, int pc2, int8_t chord_degree,
+                                    bool simultaneous = true);
 
 /**
  * @brief Check if an actual semitone interval is dissonant (Pop theory).

src/midi/midi_writer.cpp

@@ -86,9 +86,7 @@ void MidiWriter::writeTrack(const MidiTrack& track, const std::string& name, uin
   // Defensive: BPM should be validated at buildSMF1() entry point
   if (bpm == 0) bpm = 120;
 
-  // Track name (Meta event 0x03) - truncate if too long
-  // NOTE: Truncation is silent; assert in debug builds to catch oversized names
-  assert(name.size() <= kMaxMetaTextLength && "Track name exceeds MIDI meta text limit");
+  // Track name (Meta event 0x03) - truncate if too long for MIDI meta text limit
   std::string track_name =
       name.size() > kMaxMetaTextLength ? name.substr(0, kMaxMetaTextLength) : name;
   track_data.push_back(0x00);
@@ -249,9 +247,7 @@ void MidiWriter::writeMarkerTrack(const MidiTrack& track, uint16_t bpm,
     Tick delta = marker.time - prev_time;
     prev_time = marker.time;
 
-    // Truncate marker text if too long
-    // NOTE: Truncation is silent; assert in debug builds to catch oversized text
-    assert(marker.text.size() <= kMaxMetaTextLength && "Marker text exceeds MIDI meta text limit");
+    // Truncate marker text if too long for MIDI meta text limit
     std::string marker_text = marker.text.size() > kMaxMetaTextLength
                                   ? marker.text.substr(0, kMaxMetaTextLength)
                                   : marker.text;

src/track/aux_track.h

@@ -134,13 +134,13 @@ class AuxTrackGenerator {
  public:
   /// Context for aux generation.
   struct AuxContext {
-    Tick section_start = 0;                        ///< Absolute start tick of the section
-    Tick section_end = 0;                          ///< Absolute end tick of the section
-    int8_t chord_degree = 0;                       ///< Starting chord degree (0-based scale degree)
-    int key_offset = 0;                            ///< Key offset from C major (for transposition)
-    uint8_t base_velocity = 100;                   ///< Base MIDI velocity for notes
-    TessituraRange main_tessitura = {60, 72, 66};  ///< Main melody's comfortable range
-    const std::vector<NoteEvent>* main_melody = nullptr;  ///< Reference to main melody notes
+    Tick section_start = 0;       ///< Absolute start tick of the section
+    Tick section_end = 0;         ///< Absolute end tick of the section
+    int8_t chord_degree = 0;      ///< Starting chord degree (0-based scale degree)
+    int key_offset = 0;           ///< Key offset from C major (for transposition)
+    uint8_t base_velocity = 100;  ///< Base MIDI velocity for notes
+    TessituraRange main_tessitura = {60, 72, 66, 55, 77};  ///< Main melody's comfortable range
+    const std::vector<NoteEvent>* main_melody = nullptr;   ///< Reference to main melody notes
     /// Phrase boundaries from vocal generation (for breath coordination)
     const std::vector<PhraseBoundary>* phrase_boundaries = nullptr;
     SectionType section_type =

src/track/bass.cpp

@@ -405,18 +405,25 @@ BassPattern selectPattern(SectionType section, bool drums_enabled, Mood mood,
   return selected;
 }
 
-/// Select pattern based on RiffPolicy, using cache for Locked/Evolving modes.
+// ============================================================================
+// RiffPolicy Pattern Selection (Generic Template)
+// ============================================================================
+
+/// Core implementation of pattern selection with RiffPolicy support.
+/// Extracts common logic for Locked/Evolving/Free mode handling.
+/// @tparam PatternSelector Callable returning BassPattern (invoked for new selection)
 /// @param cache Riff cache to store/retrieve cached pattern
-/// @param section Current section info
 /// @param sec_idx Current section index
 /// @param params Generator parameters (contains riff_policy)
 /// @param rng Random number generator
+/// @param selector Callable that returns a new pattern when selection is needed
 /// @return Selected bass pattern
-BassPattern selectPatternWithPolicy(BassRiffCache& cache, const Section& section, size_t sec_idx,
-                                    const GeneratorParams& params, std::mt19937& rng) {
+template <typename PatternSelector>
+BassPattern selectPatternWithPolicyCore(BassRiffCache& cache, size_t sec_idx,
+                                        const GeneratorParams& params, std::mt19937& rng,
+                                        PatternSelector&& selector) {
   BassPattern pattern;
 
-  // Check RiffPolicy
   RiffPolicy policy = params.riff_policy;
 
   // Handle Locked variants (LockedContour, LockedPitch, LockedAll) as same behavior
@@ -431,18 +438,15 @@ BassPattern selectPatternWithPolicy(BassRiffCache& cache, const Section& section
     std::uniform_real_distribution<float> evolve_dist(0.0f, 1.0f);
     if (sec_idx % 2 == 0 && evolve_dist(rng) < 0.3f) {
       // Allow evolution - select new pattern
-      pattern = selectPattern(section.type, params.drums_enabled, params.mood,
-                              section.backing_density, rng);
-      // Update cache with evolved pattern
+      pattern = selector();
       cache.pattern = pattern;
     } else {
       // Keep using cached pattern
       pattern = cache.pattern;
     }
   } else {
     // Free: select pattern normally (per-section)
-    pattern = selectPattern(section.type, params.drums_enabled, params.mood,
-                            section.backing_density, rng);
+    pattern = selector();
   }
 
   // Cache the first valid pattern for Locked/Evolving modes
@@ -454,6 +458,21 @@ BassPattern selectPatternWithPolicy(BassRiffCache& cache, const Section& section
   return pattern;
 }
 
+/// Select pattern based on RiffPolicy, using cache for Locked/Evolving modes.
+/// @param cache Riff cache to store/retrieve cached pattern
+/// @param section Current section info
+/// @param sec_idx Current section index
+/// @param params Generator parameters (contains riff_policy)
+/// @param rng Random number generator
+/// @return Selected bass pattern
+BassPattern selectPatternWithPolicy(BassRiffCache& cache, const Section& section, size_t sec_idx,
+                                    const GeneratorParams& params, std::mt19937& rng) {
+  return selectPatternWithPolicyCore(cache, sec_idx, params, rng, [&]() {
+    return selectPattern(section.type, params.drums_enabled, params.mood, section.backing_density,
+                         rng);
+  });
+}
+
 // Helper to add a bass note with safety check against vocal
 // If the desired pitch clashes, uses harmony context to find safe alternative
 // IMPORTANT: For bass, the result must always be a chord tone to define harmony
@@ -1181,40 +1200,9 @@ BassPattern selectPatternForVocalDensity(float vocal_density, SectionType sectio
 BassPattern selectPatternWithPolicyForVocal(BassRiffCache& cache, const Section& section,
                                             size_t sec_idx, const GeneratorParams& params,
                                             float vocal_density, std::mt19937& rng) {
-  BassPattern pattern;
-
-  // Check RiffPolicy
-  RiffPolicy policy = params.riff_policy;
-
-  // Handle Locked variants as same behavior
-  bool is_locked = (policy == RiffPolicy::LockedContour || policy == RiffPolicy::LockedPitch ||
-                    policy == RiffPolicy::LockedAll);
-
-  if (is_locked && cache.cached) {
-    // Locked: always use cached pattern
-    pattern = cache.pattern;
-  } else if (policy == RiffPolicy::Evolving && cache.cached) {
-    // Evolving: 30% chance to select new pattern every 2 sections
-    std::uniform_real_distribution<float> evolve_dist(0.0f, 1.0f);
-    if (sec_idx % 2 == 0 && evolve_dist(rng) < 0.3f) {
-      // Allow evolution - select new pattern based on vocal density
-      pattern = selectPatternForVocalDensity(vocal_density, section.type, params.mood, rng);
-      cache.pattern = pattern;
-    } else {
-      pattern = cache.pattern;
-    }
-  } else {
-    // Free: select pattern based on vocal density
-    pattern = selectPatternForVocalDensity(vocal_density, section.type, params.mood, rng);
-  }
-
-  // Cache the first valid pattern
-  if (!cache.cached) {
-    cache.pattern = pattern;
-    cache.cached = true;
-  }
-
-  return pattern;
+  return selectPatternWithPolicyCore(cache, sec_idx, params, rng, [&]() {
+    return selectPatternForVocalDensity(vocal_density, section.type, params.mood, rng);
+  });
 }
 
 // Helper: motion type to string for logging

tests/core/chord_utils_test.cpp

@@ -185,7 +185,7 @@ TEST(ChordUtilsTest, NearestChordToneWithinIntervalNoPrev) {
 }
 
 TEST(ChordUtilsTest, NearestChordToneWithinIntervalWithTessitura) {
-  TessituraRange t{60, 72, 66};
+  TessituraRange t{60, 72, 66, 55, 77};
 
   // Target G4 (67), prev E4 (64), max interval 7, I chord
   // Both E4 and G4 are chord tones and within tessitura

tests/core/melody_evaluator_test.cpp

@@ -275,7 +275,7 @@ MelodyDesigner::SectionContext createTestSectionContext(SectionType type, Tick s
   ctx.section_bars = bars;
   ctx.chord_degree = 0;
   ctx.key_offset = 0;
-  ctx.tessitura = {60, 79, 69};  // C4-G5, center ~A4
+  ctx.tessitura = {60, 79, 69, 60, 79};  // C4-G5, center ~A4
   ctx.vocal_low = 60;
   ctx.vocal_high = 79;
   ctx.density_modifier = 1.0f;

tests/core/pitch_utils_test.cpp

@@ -49,7 +49,7 @@ TEST(PitchUtilsTest, CalculateTessituraNarrowRange) {
 }
 
 TEST(PitchUtilsTest, IsInTessitura) {
-  TessituraRange t{60, 72, 66};
+  TessituraRange t{60, 72, 66, 55, 77};
 
   EXPECT_TRUE(isInTessitura(60, t));   // Low boundary
   EXPECT_TRUE(isInTessitura(66, t));   // Center
@@ -72,11 +72,12 @@ TEST(PitchUtilsTest, GetComfortScoreInTessitura) {
 }
 
 TEST(PitchUtilsTest, GetComfortScorePassaggio) {
-  // Create a tessitura that excludes the passaggio zone
-  // Passaggio is 64-71, so use tessitura above it
-  TessituraRange t{72, 82, 77};  // Tessitura above passaggio
-  // Pitch 68 (G#4) is in passaggio but outside tessitura
-  float score = getComfortScore(68, t, 60, 85);
+  // Dynamic passaggio calculation: 55%-75% of vocal range
+  // For vocal_low=50, vocal_high=80: range=30, passaggio=50+16=66 to 50+22=72
+  // Create tessitura that excludes the passaggio zone
+  TessituraRange t{74, 80, 77, 50, 80};  // Tessitura above passaggio (66-72)
+  // Pitch 69 is in dynamic passaggio zone (66-72) but outside tessitura
+  float score = getComfortScore(69, t, 50, 80);
   EXPECT_FLOAT_EQ(score, 0.4f);  // Reduced score for passaggio
 }
 

tests/track/aux_chorus_behavior_test.cpp

@@ -80,7 +80,7 @@ TEST(AuxChorusBehaviorTest, ChorusAuxUsesChordTones) {
     ctx.chord_degree = 0;
     ctx.key_offset = 0;
     ctx.base_velocity = 100;
-    ctx.main_tessitura = {72, 84, 78};  // High vocal tessitura (C5-C6)
+    ctx.main_tessitura = {72, 84, 78, 67, 89};  // High vocal tessitura (C5-C6)
     ctx.main_melody = &vocal_melody;
 
     // Configure as EmotionalPad (what Chorus should use)
@@ -150,7 +150,7 @@ TEST(AuxChorusBehaviorTest, ChorusAuxInLowerRegisterThanVocal) {
     ctx.chord_degree = 0;
     ctx.key_offset = 0;
     ctx.base_velocity = 100;
-    ctx.main_tessitura = {72, 84, 78};
+    ctx.main_tessitura = {72, 84, 78, 67, 89};
     ctx.main_melody = &vocal_melody;
 
     AuxConfig config;
@@ -203,7 +203,7 @@ TEST(AuxChorusBehaviorTest, ChorusAuxNoExactUnisonWithVocal) {
     ctx.chord_degree = 0;
     ctx.key_offset = 0;
     ctx.base_velocity = 100;
-    ctx.main_tessitura = {72, 84, 78};
+    ctx.main_tessitura = {72, 84, 78, 67, 89};
     ctx.main_melody = &vocal_melody;
 
     // Using EmotionalPad (correct behavior)
@@ -264,7 +264,7 @@ TEST(AuxChorusBehaviorTest, UnisonFunctionCreatesExactMatches) {
   ctx.chord_degree = 0;
   ctx.key_offset = 0;
   ctx.base_velocity = 100;
-  ctx.main_tessitura = {72, 84, 78};
+  ctx.main_tessitura = {72, 84, 78, 67, 89};
   ctx.main_melody = &vocal_melody;
 
   // Using Unison (what we want to AVOID in Chorus)
@@ -321,7 +321,7 @@ TEST(AuxChorusBehaviorTest, EmotionalPadProducesSustainedNotes) {
     ctx.chord_degree = 0;
     ctx.key_offset = 0;
     ctx.base_velocity = 100;
-    ctx.main_tessitura = {72, 84, 78};
+    ctx.main_tessitura = {72, 84, 78, 67, 89};
     ctx.main_melody = &vocal_melody;
 
     AuxConfig config;