Comping Gen

README.md

@@ -104,7 +104,9 @@ Electric accompaniment and electric melody share compact chord families on strin
 
 Accompaniment uses independently authored two-bar jazz pattern families: Charleston and shifted Charleston, forward-motion syncopation, anticipated heavy beats, syncopated riffs, quarters, dotted spacing, shifting motifs, call-response and anticipated beat four. Acoustic distributes a single figure between bass and upper chord, normally 1–3 total attacks per full bar, without mandatory beat-one bass. Separate attacks are quarters/eighths and never overlap; a combined bass-plus-upper chord is allowed only when both attack and sustain together for more than one beat. Electric has distinct patterns with normally 0–2 attacks per bar, stabs, sustained chords and space. The source melody and harmonic rhythm guide complete-pattern selection. Half-beat upper/electric anticipations may establish the next written chord; bass stays on current harmony. Explicit cross-bar holds use ties, never automatic merging of repeated attacks. Canonical patterns repeat at corresponding form positions with documented harmonic/pickup exceptions, and changing only tempo leaves the music unchanged.
 
-Acoustic voicing selection balances movement with lower sounding register and a soft cost for mean fret positions above nine; comfortable shifts can win over staying high. Compact spans and preferred chord families remain higher priorities. The same preference applies to the final sustained chord, without changing rhythm choices.
+Both accompaniment parts balance movement with sounding register and a soft cost for mean fret positions above nine; comfortable shifts can win over staying high. Acoustic uses a register center of MIDI 53 and electric uses 60. Compact spans and preferred chord families remain higher priorities, including for the final sustained chord. Electric melody's supporting chords use the same balance after the existing melody-string and foreground priorities; the original melody pitches and rhythm remain fixed. Voicing preferences do not reseed accompaniment rhythms.
+
+The first new acoustic accompaniment attack in every measure includes bass, either alone or with the upper chord in a combined sustain longer than one beat. This can be a delayed entrance; no beat-one attack is required. Pattern fitting exchanges upper/bass assignments when needed, without inserting attacks. Tied carries and silent bars do not require a new bass attack.
 
 **Registered Solo 1 is notated exactly in the acoustic part and Solo 2 exactly in the electric part.** Unregistered song/slot pairs use deterministic prediction from one pooled statistical model trained on both slots. There is no learned acoustic/electric style distinction. Prediction uses up to four recent pitch/rhythm events, source-melody features, harmony, and metrical position; it does not plan complete themes or guarantee long-range phrase development. The current corpus is four authored solos from Autumn Leaves and All of Me.
 

TECHNICAL_GUIDE.md

@@ -127,7 +127,7 @@ Electric accompaniment shares the electric melody's `guitar.chord_positions(...,
 
 Acoustic families are transposable degree orders for triads, tetrads and extended chords, with root/fifth alternatives on both bass strings. Slots resolve to the written third/suspension, sixth/seventh, fifth and extension, including alterations and omissions. They are not per-song grip tables. Only harmonically and physically valid realizations enter selection; unavailable bass/inversion variants are discarded. Coverage checks exercise 35 common qualities in all 12 keys. Four-fret fallbacks support previously unavailable acoustic Bb9, BbM9, Bb7#9 and Bb6add9; for example, Bb9 uses fifth-bass frets 8/10/7/9 on strings 5/4/3/2. Acoustic Bbm9 and Bm9 still have no grip meeting all constraints. Unsupported chords fail with source measure, beat and chord rather than silently omitting defining tones.
 
-The active voicing selector compares complete paths with dynamic programming over concrete grips. The leading cost minimizes four-fret grip selections: every span of one, two or three positions has zero cost in this tier. Existing criteria then apply within the tier. Electric accompaniment prioritizes chord size and shared family rank, then grip effort plus hand-center travel, missing optional tones and register preference. Acoustic prefers declared degree-order families on either bass string, then a combined travel/register/position cost, optional-tone coverage and register tie-breaking. Stable role-specific keys resolve equal costs. Since accompaniment transitions have travel costs but no hard travel cutoff, four-fret candidates are safely removed from a span when any primary grip exists; this exact dominance reduction keeps the repeat search small. Electric placement retains distinct alternatives where future held/tied notes can constrain feasibility, and does not charge tied continuations as fresh grip choices. The remaining acoustic placement helper uses the same leading fallback tier.
+The active voicing selector compares complete paths with dynamic programming over concrete grips. The leading cost minimizes four-fret grip selections: every span of one, two or three positions has zero cost in this tier. Existing criteria then apply within the tier. Electric accompaniment prioritizes chord size and shared family rank, then combined grip effort, hand-center travel, register and position costs, followed by missing optional tones and register tie-breaking. Acoustic prefers declared degree-order families on either bass string, then a combined travel/register/position cost, optional-tone coverage and register tie-breaking. Stable role-specific keys resolve equal costs. Since accompaniment transitions have travel costs but no hard travel cutoff, four-fret candidates are safely removed from a span when any primary grip exists; this exact dominance reduction keeps the repeat search small. Electric placement retains distinct alternatives where future held/tied notes can constrain feasibility, and does not charge tied continuations as fresh grip choices. The remaining acoustic placement helper uses the same leading fallback tier.
 
 Silent spans retain the preceding hand position. A continuous accompaniment repeat includes the last-to-first transition. Source-harmony variants, such as relocated pickup harmony, are solved between fixed canonical neighbors without mutating a shared previous-grip state; request order cannot change them. Per-span composition reports include candidate counts, selected family, bass/string family availability, selected positions, bass degree and movement, plus `fret_span`, `span_group` and `span_candidates` (primary/fallback counts before dominance reduction). These are diagnostic sidecar fields; the score/runtime format is unchanged.
 
@@ -135,6 +135,8 @@ Silent spans retain the preceding hand position. A continuous accompaniment repe
 
 Normal acoustic figures use 1–3 total attacks per full bar, interleaving bass and upper chords without a downbeat-bass quota. Ordinary events last a quarter or eighth and must release before the next event. Only a single combined event lasting more than one quarter-note beat can sound bass and upper together; its components start/release together. This is checked again on complete sounding tie chains. Electric figures normally have 0–2 attacks per bar and mix stabs, sustains and space. A figure may cross its internal barline: flat sounding events are selected and voiced first, then projected into notation with exact ties. Repeated attacks remain attacks. Figures do not extend beyond their selected two-bar span.
 
+The acoustic `first_attack: bass_or_combined` policy applies separately to every measure, including pickups. After removing unavailable events under missing harmony and participation limits, fitting exchanges an upper-first event with the earliest later bass event in that measure, or assigns it to bass when no exchange is possible. Timing and attack count stay intact apart from existing harmonic clipping. Reassigned bass loses any anticipation permission and binds to current harmony. Anticipations and releases are resolved afterward, and invalid figures are rejected. Delayed entrances remain delayed; a combined first attack must last more than one beat. A tied carry is not an attack and a silent measure remains silent. Pattern reports record `layer_assignment` changes, and complete sounding-event validation checks bass-first again after projection. The three-bar ending remains one combined chord attack.
+
 Direct events release at changed harmony. Eligible upper/electric events also offer a half-beat anticipation: the upcoming written chord must begin exactly half a beat after the attack, the event must continue into that chord, and it must release by the following change or protected participation boundary. The selected grip belongs to that upcoming chord. Bass and combined acoustic events cannot anticipate. Direct alternatives remain available. Missing harmony/N.C. stays silent; incompatible short durations reject a complete candidate rather than introducing unexplained subdivisions.
 
 Named activity, melody-support, harmonic-support and articulation contributions evaluate complete figures. A bounded dynamic program selects the form path, with a modest preference against immediate exact repetition. Family representatives survive the candidate cutoff. Source entrances, movement and space affect selection, while no generated role does. Effective final turnarounds and pickup masks revalidate the whole affected figure between fixed canonical neighbors. Reports identify the chosen pattern, its start measure, projected events, continuations, anticipation target times, score contributions and source-context exceptions. Tempo affects metadata/cache identity but never musical choice.
@@ -143,9 +145,13 @@ Acoustic events use temporary bass/upper notation lanes for projection; then `ac
 
 Monophonic solos use strings 1–6 and frets 1–12, with no open strings or acoustic/electric string restrictions. Placement compares complete paths through legal positions, accounting for hand-region changes, travel time and string crossings. Ties retain their position. Chord placement retains its separate policy: frets 1–20, a sounding anchor on frets 1–12, primary spans of up to three consecutive positions and fallback spans of exactly four. The span is inclusive: 7–9 is three positions, 7–10 is four. Five positions are always invalid. The anchor must remain sounding, including after shorter notes release. Acoustic accompaniment additionally keeps its bass within frets 1–12 and requires an independent anchor in its upper three-note cluster, preserving the option of separate bass/upper attacks. These costs approximate physical feasibility; they do not assign fingers or guarantee comfortable playing.
 
-Acoustic voicing selection retains the lexicographic compact-span and preferred-family tiers. Within those tiers, the whole-form cost is finger travel plus `register_weight * abs(mean sounding MIDI - center)` plus `high_position_weight * max(0, mean fret - comfortable_max_fret)`, summed once per active harmonic span. The acoustic role's `voicing` policy defaults to weights 1 and 1, threshold 9, and the existing register center 53. All arithmetic is rational. Missing allowed tones and the original register distance remain later tie-breakers. Existing finger-travel costs include bass-string changes, source-form repeat joins and neighboring grips; high positions can still win when avoiding a costly shift. No preferred bass string or song-specific grip list is added. The ending uses the same local cost and its incoming grip.
+Both accompaniment roles add `register_weight * abs(mean sounding MIDI - center)` and `high_position_weight * max(0, mean fret - comfortable_max_fret)` to their existing grip effort and movement tier, once per active harmonic span. The three role policies (`acoustic_accompaniment`, `electric_accompaniment`, `electric_melody`) use weights 1 and 1 and threshold 9; their register centers are 53, 60 and 60 respectively. All arithmetic is rational. Electric melody adds the same costs only to harmonized attacks, below compact-span, melody-string, foreground, chord-size and family priorities. Exact melody pitches are never transposed to meet the register center; monophonic placement is unchanged. Scoring and scored-pruning caches explicitly include the normalized preference tuple. Tied continuations incur no second chord cost. Existing travel costs and source-form joins remain in place; high positions can still win when avoiding a costly shift. The ending uses its own accompaniment role's local cost and incoming grip.
 
-Each selected acoustic span reports `voicing_cost` contributions for movement, weighted register, weighted position and their combined effort. These contributions describe the balanced tier, not the higher span/family priorities; repeat-join travel is assigned to the first canonical span. New acoustic `voicing` settings remain in concrete cache dependencies but are excluded from rhythmic choice seeds, including settings overrides, preserving the pre-policy rhythm choices. Other role policies and electric selection are unchanged.
+Each selected accompaniment span reports `voicing_cost` contributions for movement, base grip effort, weighted register, weighted position and their combined effort. These describe the balanced tier, not the higher span/family priorities; repeat-join travel is assigned to the first canonical span. Both accompaniment roles keep `voicing` settings in concrete cache dependencies but exclude them from rhythmic choice seeds, including settings overrides. Acoustic rhythm selection can change under its new bass-first policy, but changing voicing weights alone never reshuffles rhythm. Each role still composes independently.
+
+Shared-preference and bass-first verification on October 6, 2026: `python3 modulus.py python -m unittest discover -s tests -p 'test_*.py'` passed 408 tests in 61.35 seconds, and the native test target passed all 124 cases. Both product builds passed asset checks; 139 native/ARM score and page files matched byte for byte. All 273 acoustic measures containing new attacks started with bass, including 69 delayed entrances. Tied carries did not trigger new attacks. Both solos, vocals, electric accompaniment rhythms, and electric foreground melody pitches/timing/TAB matched the saved baseline exactly. Some All of Me melody support chords changed; Autumn Leaves' complete electric melody document did not. All of Me's canonical electric accompaniment mean fret dropped from 7.26 to 4.13 and movement cost from 57 to 48; Autumn Leaves stayed at 2.95 and 46. Recordings were unchanged. These are score checks and page inspections, not a listening assessment.
+
+With no concurrent build, isolated cold role generation measured 0.56–0.57 seconds for acoustic accompaniment, 0.35–0.37 for electric accompaniment, and 0.26–0.29 for electric melody; cache hits took 0.02–0.04 seconds and matched clean regeneration for both songs. The normal two-worker native asset stage took about 14 seconds (4 composing, 9 engraving, 1 other); ARM reused the caches in about 4 seconds. Application compilation is separate from these asset-stage timings.
 
 Lower-position verification on October 6, 2026: all 400 Python tests and 124 native test cases passed. Native and ARM builds passed asset checks; all 139 score/page files matched byte for byte. Against the saved production output, acoustic rhythms and all other five role documents were identical for both songs. Mean fret across canonical active acoustic grips changed from 8.90 to 4.50 in Autumn Leaves and 5.19 to 4.29 in All of Me; movement costs rose from 144 to 190 and 128 to 140 respectively. In the requested six-chord passage, five suggested grips won; Em7b5 instead chose its valid fifth-bass shape on strings 6/4/3/2 at frets 6/5/7/5. Tests also verify that the complete suggested sequence beats the previous higher sequence with fixed neighbors, and that sufficiently costly travel can still retain a higher grip. These are score/selection facts, not an ear-based audition.
 

data/composition/accompaniment.json

@@ -5,6 +5,7 @@
   "pattern_candidates": 32,
   "instruments": {
     "acoustic": {
+      "first_attack": "bass_or_combined",
       "patterns": [
         {
           "id": "acoustic.charleston.statement",

data/composition/roles.json

@@ -18,10 +18,21 @@
     "electric_accompaniment": {
       "seed": "electric_comp",
       "bass": "essential",
-      "center": 60
+      "center": 60,
+      "voicing": {
+        "register_weight": 1,
+        "high_position_weight": 1,
+        "comfortable_max_fret": 9
+      }
     },
     "electric_melody": {
-      "seed": "head"
+      "seed": "head",
+      "center": 60,
+      "voicing": {
+        "register_weight": 1,
+        "high_position_weight": 1,
+        "comfortable_max_fret": 9
+      }
     },
     "vocal_melody": {
       "seed": "voice"

generator/acoustic.py

@@ -146,3 +146,10 @@ def validate_comping(document: dict) -> None:
   events.sort()
   if any(a[1] > b[0] for a, b in zip(events, events[1:])):
     raise ValueError('acoustic bass and upper must release together or remain separate')
+  cursor = fractions.Fraction()
+  for measure in document['staves'][0]['measures']:
+    length = generator.model.fraction(measure['duration'])
+    first = next((event for event in events if cursor <= event[0] < cursor + length), None)
+    if first and 'bass' not in groups[first]:
+      raise ValueError(f'measure {measure["number"]}: first acoustic attack must include bass')
+    cursor += length

generator/comping.py

@@ -75,36 +75,27 @@ class VoicingCost(typing.NamedTuple):
   def moved(self, distance):
     return self._replace(effort=self.effort + distance)
 
-def acoustic_preferences(grip, center):
+def voicing_preferences(part, grip, center):
-  """Soft register/hand-position costs, in the same units as finger travel."""
+  return generator.guitar.voicing_preferences(grip, generator.guitar.voicing_preference(part + '_accompaniment', center))
-  policy = generator.vocabulary.role('acoustic_accompaniment').get('voicing', {})
-  register_weight = fractions.Fraction(str(policy.get('register_weight', 1)))
-  position_weight = fractions.Fraction(str(policy.get('high_position_weight', 1)))
-  threshold = fractions.Fraction(str(policy.get('comfortable_max_fret', 9)))
-  if register_weight < 0 or position_weight < 0 or threshold < 1:
-    raise ValueError('acoustic voicing requires nonnegative weights and a positive fret threshold')
-  register = abs(fractions.Fraction(sum(p.midi for p in grip), len(grip)) - center)
-  position = max(fractions.Fraction(), fractions.Fraction(sum(p.fret for p in grip), len(grip)) - threshold)
-  return register_weight * register, position_weight * position
 
 def local_cost(part, key, grip, center):
   required = requirements(json.loads(key), part)
   register = abs(fractions.Fraction(sum(p.midi for p in grip), len(grip)) - center)
+  preference = sum(voicing_preferences(part, grip, center))
   if part == 'electric':
     value = generator.guitar.voicing_cost(grip, 'electric', required.allowed)
-    return VoicingCost(value.extended_grips, 3 * value.string_shortfall + value.family_penalty, value.effort, value.missing_tones, register)
+    return VoicingCost(value.extended_grips, 3 * value.string_shortfall + value.family_penalty, value.effort + preference, value.missing_tones, register)
   # Familiar degree orders on either bass string, then balanced whole-form
   # movement, sounding register and hand position. Neither is an absolute ban.
   family = generator.chord_families.acoustic(json.loads(key), grip)
-  effort = sum(acoustic_preferences(grip, center))
+  return VoicingCost(generator.fretboard.span_penalty(grip), int(not family['preferred']), preference, len(set(required.allowed) - {p.midi % 12 for p in grip}), register)
-  return VoicingCost(generator.fretboard.span_penalty(grip), int(not family['preferred']), effort, len(set(required.allowed) - {p.midi % 12 for p in grip}), register)
 
 def select_grips(layers, costs, part, seed, *, left=(), right=(), close=False):
   """Exact small-state dynamic programming; never prune by hand center.
 
-  Electric effort includes its melody grip cost and hand-center travel.
+  Both roles balance register/position with travel. Electric includes its
-  Acoustic effort balances register/position with travel of all four voices,
+  base grip effort; acoustic follows all four voices and bass-string changes.
-  including a bass-string change. Compact span and family remain higher tiers.
+  Compact span and family remain higher tiers.
   Fixing the first grip permits an exact repeat-join cost without a beam.
   """
   if not layers:
@@ -319,10 +310,11 @@ class Canonical:
         'bass_degree': next((d for d, a in degrees.items() if bass and (root + generator.harmony.degree_semitones(d, a)) % 12 == bass.midi % 12), None),
         'bass_string': bass.string_number if bass else None,
         'movement': movement(self.part, previous, grip), 'voicing_candidates': len(span.options)})
-      if grip and self.part == 'acoustic':
+      if grip:
-        register, position = acoustic_preferences(grip, self.policy.get('center', 55))
+        register, position = voicing_preferences(self.part, grip, self.policy.get('center', 55))
         travel = movement(self.part, previous, grip)
-        rows[-1]['voicing_cost'] = {'movement': travel, 'register': str(register), 'position': str(position), 'combined': str(travel + register + position)}
+        effort = generator.guitar.voicing_cost(grip, 'electric').effort if self.part == 'electric' else 0
+        rows[-1]['voicing_cost'] = {'movement': travel, 'grip_effort': str(effort), 'register': str(register), 'position': str(position), 'combined': str(travel + effort + register + position)}
       for event in span.events:
         lanes = ['bass', 'upper'] if event.lane == 'combined' else [event.lane]
         for lane in lanes:

generator/comping_rhythm.py

@@ -64,7 +64,7 @@ def flatten(inputs):
   result['duration'] = generator.model.rational(cursor)
   return result
 
-def validate_events(events, part):
+def validate_events(events, part, lengths=None):
   ordered = sorted(events, key=lambda e: e.start)
   for e in ordered:
     duration = e.end - e.start
@@ -80,13 +80,20 @@ def validate_events(events, part):
       raise ValueError('electric comping requires chord events')
   if any(a.end > b.start for a, b in zip(ordered, ordered[1:])):
     raise ValueError('separate comping events cannot overlap; use one combined sustain')
+  if part == 'acoustic' and lengths is not None:
+    cursor = fractions.Fraction()
+    for length in lengths:
+      first = next((e for e in ordered if cursor <= e.start < cursor + length), None)
+      if first and first.lane not in ('bass', 'combined'):
+        raise ValueError('first acoustic attack in each measure must include bass')
+      cursor += length
 
 def fit(pattern, measure, prior, part, *, anticipate=False, limit=None):
   """Bind a complete figure to written harmony, with bounded early arrivals."""
   length = generator.model.fraction(measure['duration'])
   limit = length if limit is None else min(length, limit)
   harmony = spans(measure, prior)
-  events, exceptions = [], []
+  events, exceptions, available = [], [], []
   for row in pattern['events']:
     start = fractions.Fraction(row['onset'])
     end = min(start + fractions.Fraction(row['duration']), limit)
@@ -96,6 +103,22 @@ def fit(pattern, measure, prior, part, *, anticipate=False, limit=None):
     if active is None or active[2] is None:
       exceptions.append(('space', 'no written harmony at ' + str(start)))
       continue
+    available.append((dict(row), start, end, active))
+  lengths = tuple(map(fractions.Fraction, pattern.get('lengths', (length,))))
+  if part == 'acoustic' and generator.vocabulary.accompaniment(part)['first_attack'] == 'bass_or_combined':
+    cursor = fractions.Fraction()
+    for span in lengths:
+      local = [(row, start) for row, start, _, _ in available if cursor <= start < cursor + span]
+      if local and local[0][0]['layer'] == 'upper':
+        first, onset = local[0]
+        later = next(((row, start) for row, start in local[1:] if row['layer'] == 'bass'), None)
+        first['layer'] = 'bass'
+        first.pop('anticipate', None)
+        if later:
+          later[0]['layer'] = 'upper'
+        exceptions.append(('layer_assignment', f'bass first at {onset}' + (f'; upper exchanged with bass at {later[1]}' if later else '; no later bass to exchange')))
+      cursor += span
+  for row, start, end, active in available:
     _, boundary, chord = active
     target = None
     if anticipate and row.get('anticipate') and row['layer'] in ('upper', 'electric'):
@@ -105,7 +128,7 @@ def fit(pattern, measure, prior, part, *, anticipate=False, limit=None):
     end = min(end, boundary)
     events.append(Attack(row['layer'], start, end, target))
   try:
-    validate_events(events, part)
+    validate_events(events, part, lengths)
   except ValueError:
     return None
   return tuple(events), tuple(exceptions)

generator/guitar.py

@@ -23,7 +23,7 @@ class VoicingCost(typing.NamedTuple):
   covering_tones: int = 0
   string_shortfall: int = 0
   family_penalty: int = 0
-  effort: int = 0
+  effort: fractions.Fraction = fractions.Fraction()
   missing_tones: int = 0
   def plus(self, other: VoicingCost) -> VoicingCost:
     return VoicingCost(*(a + b for a, b in zip(self, other)))
@@ -31,18 +31,38 @@ class VoicingCost(typing.NamedTuple):
   def moved(self, distance: int) -> VoicingCost:
     return self._replace(effort=self.effort + distance)
 
-def voicing_cost(positions: tuple[generator.fretboard.TabPosition, ...], profile: str = '', allowed: tuple[int, ...] = (), melody: tuple[int, ...] = ()) -> VoicingCost:
+def voicing_preference(role, center=None):
-  families = tuple(generator.vocabulary.accompaniment('electric')['voicing_families']['rank'].items()) if profile == 'electric' else ()
+  """Immutable role settings for both selection and scored-retrieval caches."""
-  return _voicing_cost(positions, profile, allowed, melody, families)
+  settings = generator.vocabulary.role(role)
+  policy = settings.get('voicing', {})
+  center = settings.get('center', 53 if role.startswith('acoustic') else 60) if center is None else center
+  result = tuple(fractions.Fraction(str(v)) for v in (center, policy.get('register_weight', 1), policy.get('high_position_weight', 1), policy.get('comfortable_max_fret', 9)))
+  if result[1] < 0 or result[2] < 0 or result[3] < 1:
+    raise ValueError('voicing preference requires nonnegative weights and a positive fret threshold')
+  return result
 
 @functools.lru_cache(maxsize=8192)
-def _voicing_cost(positions, profile, allowed, melody, families):
+def voicing_preferences(positions, preference):
+  if not positions or not preference:
+    return fractions.Fraction(), fractions.Fraction()
+  center, register_weight, position_weight, threshold = preference
+  register = abs(fractions.Fraction(sum(p.midi for p in positions), len(positions)) - center)
+  position = max(fractions.Fraction(), fractions.Fraction(sum(p.fret for p in positions), len(positions)) - threshold)
+  return register_weight * register, position_weight * position
+
+def voicing_cost(positions: tuple[generator.fretboard.TabPosition, ...], profile: str = '', allowed: tuple[int, ...] = (), melody: tuple[int, ...] = ()) -> VoicingCost:
+  families = tuple(generator.vocabulary.accompaniment('electric')['voicing_families']['rank'].items()) if profile == 'electric' else ()
+  preference = voicing_preference('electric_melody') if profile == 'electric' and melody else ()
+  return _voicing_cost(positions, profile, allowed, melody, families, preference)
+
+@functools.lru_cache(maxsize=8192)
+def _voicing_cost(positions, profile, allowed, melody, families, preference):
   frets = {p.fret for p in positions}
   classes = {p.midi % 12 for p in positions}
   above = sum(p.midi > max(melody) for p in positions) if melody else 0
   span = compactness(positions)
   if profile == 'electric':
-    effort = 2 * max(0, len(frets) - 1) + 3 * span
+    effort = 2 * max(0, len(frets) - 1) + 3 * span + sum(voicing_preferences(positions, preference))
   else:
     effort = 2 * max(0, max(frets, default=0) - PREFERRED_MAX_FRET) + span
   family_penalty = dict(families).get(generator.chord_families.electric(positions), 0) if positions and families else 0
@@ -51,10 +71,11 @@ def _voicing_cost(positions, profile, allowed, melody, families):
 
 def chord_positions(requirements: generator.fretboard.ChordRequirements, prune: bool = True, profile: str = '', melody: tuple[int, ...] = ()) -> tuple[tuple[generator.fretboard.TabPosition, ...], ...]:
   families = tuple(generator.vocabulary.accompaniment('electric')['voicing_families']['rank'].items()) if profile == 'electric' else ()
-  return _chord_positions(requirements, prune, profile, melody, families)
+  preference = voicing_preference('electric_melody') if profile == 'electric' and melody else ()
+  return _chord_positions(requirements, prune, profile, melody, families, preference)
 
 @functools.lru_cache(maxsize=256)
-def _chord_positions(requirements, prune, profile, melody, families):
+def _chord_positions(requirements, prune, profile, melody, families, preference):
   result = []
   options = [tuple(generator.fretboard.TabPosition(string, fret, open_midi + fret) for fret in range(generator.fretboard.MIN_FRET, generator.fretboard.MAX_FRET + 1) if (open_midi + fret) % 12 in requirements.allowed or open_midi + fret in melody) for string, open_midi in generator.fretboard.STANDARD_TUNING]
 
@@ -90,7 +111,7 @@ def _chord_positions(requirements, prune, profile, melody, families):
   best = {}
   for positions in result:
     center = position_center(positions)
-    rank = (voicing_cost(positions, profile, requirements.allowed, melody), positions)
+    rank = (_voicing_cost(positions, profile, requirements.allowed, melody, families, preference), positions)
     if center not in best or rank < best[center][0]:
       best[center] = (rank, positions)
   return tuple(sorted(item[1] for item in best.values()))

generator/production.py

@@ -214,7 +214,7 @@ def _generate_role(source, role, data_dir, settings=None, cache_dir=None):
     'vocabulary': generator.vocabulary.fingerprint(inputs['vocabulary']), 'settings': settings, 'algorithm': algorithm, 'code': inputs['code'], 'cache_key': key}
   choice_source = source.accompaniment_key() if role.endswith('_accompaniment') else source.musical_key
   choice_data, choice_settings = inputs['vocabulary'], settings
-  if role == 'acoustic_accompaniment':
+  if role.endswith('_accompaniment'):
     # Voicing weights invalidate the concrete cache, but must not reshuffle
     # rhythm patterns. Removing this new field preserves the pre-policy seed.
     choice_data = copy.deepcopy(choice_data)

generator/vocabulary.py

@@ -29,6 +29,8 @@ def _load(contents):
       signatures = {}
       for part in ('electric', 'acoustic'):
         policy = value['instruments'][part]
+        if part == 'acoustic' and policy.get('first_attack') != 'bass_or_combined':
+          raise ValueError('acoustic patterns require a bass-or-combined first attack policy')
         identifiers = set()
         signatures[part] = set()
         for pattern in policy['patterns']:

tests/test_comping_rhythm.py

@@ -43,7 +43,7 @@ class LayeredComping(unittest.TestCase):
     for part, candidates in choices.items():
       self.assertTrue(expected <= {dict(c.families)['pattern'] for c in candidates})
       for c in candidates:
-        generator.comping_rhythm.validate_events(c.events, part)
+        generator.comping_rhythm.validate_events(c.events, part, (4, 4))
         for start in (0, 4):
           self.assertLessEqual(sum(start <= e.start < start + 4 for e in c.events), 3 if part == 'acoustic' else 2)
         self.assertAlmostEqual(c.cost, sum(dict(c.contributions).values()))
@@ -51,7 +51,7 @@ class LayeredComping(unittest.TestCase):
     e = {tuple(e.start for e in c.events) for c in choices['electric']}
     self.assertFalse(a & e)
     self.assertTrue(any(c.events[0].start > 0 for c in choices['acoustic']))
-    self.assertTrue(any(c.events[0].lane == 'upper' for c in choices['acoustic']))
+    self.assertTrue(all(c.events[0].lane in ('bass', 'combined') for c in choices['acoustic'] if c.events))
     self.assertTrue(any(e.end - e.start > 1 for c in choices['electric'] for e in c.events))
   def test_separate_short_attacks_and_only_synchronized_long_combinations(self):
     F = fractions.Fraction
@@ -61,6 +61,61 @@ class LayeredComping(unittest.TestCase):
     for events in ((attack('combined', F(0), F(1)),), (attack('bass', F(0), F(1)), attack('upper', F(1, 2), F(1))), (attack('bass', F(0), F(2)),)):
       with self.assertRaises(ValueError):
         generator.comping_rhythm.validate_events(events, 'acoustic')
+  def test_bass_first_reassigns_layers_without_moving_or_adding_attacks(self):
+    source = tests.solo_fixtures.song(count=2, chords=('C7',))
+    flat = generator.comping_rhythm.flatten(tuple((m, None, i) for i, m in enumerate(source['staves'][0]['measures'])))
+    patterns = self.resources['accompaniment']['instruments']['acoustic']['patterns']
+    before = copy.deepcopy(patterns)
+    for pattern in patterns:
+      if pattern['lengths'] != ['4', '4']:
+        continue
+      events, _ = generator.comping_rhythm.fit(pattern, flat, None, 'acoustic')
+      self.assertEqual([(e.start, e.end - e.start) for e in events], [(fractions.Fraction(r['onset']), fractions.Fraction(r['duration'])) for r in pattern['events']])
+      for start in (0, 4):
+        local = [e for e in events if start <= e.start < start + 4]
+        if local:
+          self.assertIn(local[0].lane, ('bass', 'combined'))
+    self.assertEqual(before, patterns)
+  def test_missing_harmony_reassigns_first_survivor_before_anticipation(self):
+    m = copy.deepcopy(self.source['staves'][0]['measures'][0])
+    m['harmonies'] = [{'id': 'absent', 'kind': 'none', 'onset': generator.model.rational(0)},
+      {**generator.harmony.parse_symbol('C7'), 'id': 'current', 'onset': generator.model.rational(1)},
+      {**generator.harmony.parse_symbol('FM7'), 'id': 'next', 'onset': generator.model.rational(2)}]
+    pattern = {'lengths': ['4'], 'events': [
+      {'onset': '0', 'duration': '1', 'layer': 'bass'},
+      {'onset': '3/2', 'duration': '1', 'layer': 'upper', 'anticipate': True},
+      {'onset': '7/2', 'duration': '1/2', 'layer': 'bass'}]}
+    events, changes = generator.comping_rhythm.fit(pattern, m, None, 'acoustic', anticipate=True)
+    self.assertEqual([(e.lane, e.start, e.end, e.harmonic_time) for e in events], [('bass', fractions.Fraction(3, 2), 2, None), ('upper', fractions.Fraction(7, 2), 4, None)])
+    self.assertIn('layer_assignment', {kind for kind, _ in changes})
+    limited, _ = generator.comping_rhythm.fit(pattern, m, None, 'acoustic', anticipate=True, limit=fractions.Fraction(2))
+    self.assertEqual(limited, (events[0],))
+  def test_combined_first_attack_and_carried_hold_do_not_require_reattacks(self):
+    attack, F = generator.comping_rhythm.Attack, fractions.Fraction
+    valid = (attack('combined', F(3), F(5)), attack('bass', F(6), F(7)))
+    generator.comping_rhythm.validate_events(valid, 'acoustic', (4, 4))
+    generator.comping_rhythm.validate_events(valid[:1], 'acoustic', (4, 4))
+    invalid = (valid[0], attack('upper', F(6), F(7)))
+    with self.assertRaisesRegex(ValueError, 'first acoustic attack'):
+      generator.comping_rhythm.validate_events(invalid, 'acoustic', (4, 4))
+  def test_completed_score_rejects_upper_first_even_after_a_rest(self):
+    source = tests.solo_fixtures.song(count=2, chords=('C7',))
+    pattern = {'id': 'test.delayed', 'family': 'call_response', 'lengths': ['4', '4'], 'events': [
+      {'onset': '1', 'duration': '1/2', 'layer': 'upper'}, {'onset': '2', 'duration': '1', 'layer': 'bass'},
+      {'onset': '5', 'duration': '1', 'layer': 'combined'}]}
+    # The final combined event must be longer than one beat.
+    pattern['events'][-1]['duration'] = '2'
+    resources = copy.deepcopy(self.resources)
+    resources['accompaniment']['instruments']['acoustic']['patterns'] = [pattern]
+    with generator.vocabulary.using(resources, 'acoustic_accompaniment'):
+      canonical = generator.comping.Canonical(source, 'acoustic', 'bass-first')
+      measures = source['staves'][0]['measures']
+      source['staves'][0]['measures'] = [canonical(m, None, i) for i, m in enumerate(measures)]
+    generator.acoustic.validate_comping(source)
+    first = source['staves'][0]['measures'][0]
+    first['voices'] = [v for v in first['voices'] if v['id'] != 'bass']
+    with self.assertRaisesRegex(ValueError, 'first acoustic attack'):
+      generator.acoustic.validate_comping(source)
   def test_harmonic_changes_clip_direct_holds_without_extra_attacks(self):
     source = copy.deepcopy(self.source)
     for m in source['staves'][0]['measures'][:2]:

tests/test_comping_voicings.py

@@ -19,6 +19,7 @@ import generator.score
 import generator.vocabulary
 import tests.solo_fixtures
 import tests.test_acoustic_voicing
+import tests.test_voicing
 
 def options(symbol, part):
   return generator.comping.voicings(generator.comping.semantic_key(generator.harmony.parse_symbol(symbol)), part)
@@ -30,6 +31,29 @@ def path_cost(path, costs, part, left=(), right=(), close=False):
   return tuple(total)
 
 class CompingVoicings(unittest.TestCase):
+  def test_electric_prefers_lower_grip_but_can_avoid_a_large_shift(self):
+    low, high = (tests.test_voicing.grip(f) for f in ((2, 3, 1, 3), (10, 12, 11, 12)))
+    key = generator.comping.semantic_key(generator.harmony.parse_symbol('C7'))
+    self.assertTrue(all(v in options('C7', 'electric') for v in (low, high)))
+    costs = {v: generator.comping.local_cost('electric', key, v, 60) for v in (low, high)}
+    self.assertEqual(costs[low][:2], costs[high][:2])
+    self.assertLess(costs[low], costs[high])
+    path, _ = generator.comping.select_grips(((low, high),), (costs,), 'electric', 'lower')
+    self.assertEqual(path, (low,))
+    path, _ = generator.comping.select_grips(((low, high),), (costs,), 'electric', 'lower', left=high, right=high)
+    self.assertEqual(path, (high,))
+  def test_electric_voicing_policy_does_not_reseed_rhythm(self):
+    source = generator.production.SourceAnalysis.read(tests.solo_fixtures.song(count=4, chords=('C7', 'FM7', 'Dm7', 'G7')))
+    root = pathlib.Path('data')
+    current = generator.production.generate_role(source, 'electric_accompaniment', root)
+    with tempfile.TemporaryDirectory() as cache:
+      settings = {'voicing': {'register_weight': 0, 'high_position_weight': 0}}
+      other = generator.production.generate_role(source, 'electric_accompaniment', root, settings, cache)
+      warm = generator.production.generate_role(source, 'electric_accompaniment', root, settings, cache)
+      self.assertTrue(warm['cache_hit'])
+      self.assertEqual(other['document'], warm['document'])
+    self.assertNotEqual(current['trace']['cache_key'], other['trace']['cache_key'])
+    self.assertEqual(current['details']['accompaniment_rhythm'], other['details']['accompaniment_rhythm'])
   def test_lower_progression_can_outweigh_extra_boundary_travel(self):
     symbols = ('Em7b5', 'A7b9', 'Dm7', 'G7', 'Cm7', 'F7')
     low = tuple(tests.test_acoustic_voicing.voicing(f) for f in ((7, 8, 7, 8), (7, 8, 6, 8), (5, 7, 5, 6), (5, 5, 4, 6), (3, 5, 3, 4), (3, 3, 2, 4)))
@@ -61,8 +85,8 @@ class CompingVoicings(unittest.TestCase):
     low = tests.test_acoustic_voicing.voicing((7, 8, 7, 8))
     resources = generator.vocabulary.load()
     key = generator.comping.semantic_key(generator.harmony.parse_symbol('Em7b5'))
-    self.assertEqual(generator.comping.acoustic_preferences(high, 53), (fractions.Fraction(39, 4), fractions.Fraction(11, 4)))
+    self.assertEqual(generator.comping.voicing_preferences('acoustic', high, 53), (fractions.Fraction(39, 4), fractions.Fraction(11, 4)))
-    self.assertEqual(generator.comping.acoustic_preferences(low, 53)[1], 0)
+    self.assertEqual(generator.comping.voicing_preferences('acoustic', low, 53)[1], 0)
     baseline = generator.comping.local_cost('acoustic', key, high, 53)
     for field, expected in (('register_weight', fractions.Fraction(39, 4)), ('high_position_weight', fractions.Fraction(11, 4)), ('comfortable_max_fret', -1)):
       policy = dict(resources['roles']['roles']['acoustic_accompaniment']['voicing'])
@@ -159,7 +183,7 @@ class CompingVoicings(unittest.TestCase):
   def test_complete_path_beats_greedy_and_matches_exhaustive_search(self):
     for part in ('acoustic', 'electric'):
       with self.subTest(part=part):
-        chords = ('C', 'Dm7', 'A7b9') if part == 'acoustic' else ('C', 'C', 'Dm7')
+        chords = ('C', 'Dm7', 'A7b9') if part == 'acoustic' else ('C', 'FM7', 'C')
         layers = tuple(options(s, part) for s in chords)
         costs = tuple({v: generator.comping.local_cost(part, generator.comping.semantic_key(generator.harmony.parse_symbol(s)), v, 55) for v in layer} for s, layer in zip(chords, layers))
         path, cost = generator.comping.select_grips(layers, costs, part, 'test')

tests/test_voicing.py

@@ -9,6 +9,7 @@ import generator.harmony
 import generator.model
 import generator.musicxml
 import generator.score
+import generator.vocabulary
 import tests.test_musicxml
 import tests.test_parts
 
@@ -23,6 +24,30 @@ def ranked(symbol, melody=(), profile='electric', prune=False):
   return sorted(candidates, key=lambda shape: (generator.guitar.voicing_cost(shape, profile, requirements.allowed, melody), shape))
 
 class VoicingTests(unittest.TestCase):
+  def test_melody_preferences_cannot_purchase_a_lower_priority_string(self):
+    resources = generator.vocabulary.load()
+    with generator.vocabulary.using(resources, 'electric_melody', {'voicing': {'register_weight': 1000, 'high_position_weight': 1000}}):
+      for symbol, melody in (('C7', (67,)), ('FM7', (69,)), ('Cm7', (70,))):
+        candidates = ranked(symbol, melody)
+        primary = [c for c in candidates if generator.fretboard.span_penalty(c) == generator.fretboard.span_penalty(candidates[0])]
+        self.assertEqual(min(p.string_number for p in candidates[0] if p.midi in melody), min(p.string_number for c in primary for p in c if p.midi in melody))
+        self.assertTrue(set(melody) <= {p.midi for p in candidates[0]})
+  def test_melody_preference_cost_and_pruning_caches_include_role_settings(self):
+    resources = generator.vocabulary.load()
+    shape = grip((10, 12, 11, 12))
+    original = generator.guitar.voicing_cost(shape, 'electric', melody=(76,))
+    preference = generator.guitar.voicing_preferences(shape, generator.guitar.voicing_preference('electric_melody'))
+    with generator.vocabulary.using(resources, 'electric_melody', {'voicing': {'register_weight': 0, 'high_position_weight': 0}}):
+      plain = generator.guitar.voicing_cost(shape, 'electric', melody=(76,))
+    self.assertEqual(original.effort - plain.effort, sum(preference))
+    self.assertEqual(original[:6], plain[:6])
+    self.assertEqual(original, generator.guitar.voicing_cost(shape, 'electric', melody=(76,)))
+    for center in (45, 76, 45):
+      with generator.vocabulary.using(resources, 'electric_melody', {'center': center}):
+        best = {}
+        for candidate in ranked('C7', (72,)):
+          best.setdefault(generator.guitar.position_center(candidate), candidate)
+        self.assertEqual(set(ranked('C7', (72,), prune=True)), set(best.values()))
   def test_electric_chords_use_the_shared_four_fret_limit(self):
     for prune in (False, True):
       candidates = ranked('CM7', prune=prune)