Fix ordinary-Sunday precedence and unify getDayLabel's commemoration rendering

Two related fixes surfaced while chasing why St. Gregory Thaumaturgus
appeared to be misdated on Nov 18:

- calendar/commemorations.ts's `ordinary-sunday` case was transferring a
  Semiduplex (or lower) saint off the Sunday instead of commemorating it
  in place — an earlier, unverified guess. Live-verified against both
  Tridentine 1906 and Divino Afflatu 1954 (St. Gregory Thaumaturgus, St.
  Clement, St. Apollinaris, St. Thomas Becket, all real cases): the saint
  stays and is commemorated on the Sunday itself, same as Simplex, never
  pushed to the next open day. This is what was actually moving Gregory
  onto Nov 18 — not a data error. `applyChristmasOctaveSunday`'s own
  Dec 26-29 special case needed a matching adjustment (per its own
  documented intent, the displaced saint there is deliberately *not*
  commemorated in place, since he reappears in full on Dec 30 instead).

- getDayLabel had five branches, each hand-assembling its own
  filter/format logic for which commemorations to show — which is why
  the octave phrasing, the closing-day title, and a missing Sunday
  commemoration turned into three separate bugs earlier instead of one.
  Replaced with a single shared `collectCommemorations` used by every
  branch. This also exposed that the sanctoral-winner branch never
  showed any commemorated saint at all, and every other branch only
  showed the *first* one (`.find()`), silently dropping real collisions
  — both now show every commemorated saint, matching this app's own
  generous-commemoration design.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

tests/calendar/christ-the-king.test.ts

@@ -11,7 +11,12 @@ describe('Christ the King (applyChristTheKing)', () => {
     const day = resolveDay('2026-10-25'); // last Sunday of October 2026
     expect(day.winner).toEqual({ kind: 'temporal', id: 'christ-the-king' });
     expect(day.commemorations).toContainEqual({ kind: 'temporal', id: 'post-pentecost-22' });
-    expect(getDayLabel(day)).toBe('Christ the King (Duplex I Class)');
+    // Live-verified (Divino Afflatu 1954): the day's own commemoration
+    // line also names whichever sanctoral entry the ordinary Sunday was
+    // already carrying (Ss. Chrysanthus and Daria, Simplex, per the next
+    // test below) -- this app's day label now surfaces every commemorated
+    // saint, not just the Sunday itself.
+    expect(getDayLabel(day)).toBe('Christ the King (Duplex I Class) — Ss. Chrysanthus and Daria, Martyrs');
   });
 
   it('preserves a nested commemoration: a Simplex saint already commemorated under the ordinary Sunday stays commemorated', () => {

tests/calendar/commemorations.test.ts

@@ -122,11 +122,16 @@ describe('decideOccurrence — ordinary-sunday', () => {
     expect(result.transfer).toBeUndefined();
   });
 
-  it('semiduplex gets nothing here — transfers forward', () => {
+  it('semiduplex stays and is commemorated, not transferred', () => {
+    // Live-verified (both Tridentine 1906 and Divino Afflatu 1954): St.
+    // Gregory Thaumaturgus (Semiduplex) lands on the 6th Sunday after
+    // Epiphany and is commemorated right there, not pushed to the next
+    // open day — same treatment as Simplex above, not a separate
+    // "too important to merely commemorate" tier.
     const result = decideOccurrence('ordinary-sunday', 'post-epiphany-2', saint('semiduplex'));
     expect(result.winner).toEqual({ kind: 'temporal', id: 'post-epiphany-2' });
-    expect(result.commemorations).toEqual([]);
-    expect(result.transfer).toEqual({ candidate: saint('semiduplex'), direction: 'forward' });
+    expect(result.commemorations).toEqual([{ kind: 'sanctoral', id: 'x', name: 'St. Ereden', rank: 'semiduplex' }]);
+    expect(result.transfer).toBeUndefined();
   });
 
   it('vigil gets nothing here — transfers backward', () => {

tests/calendar/day-label.test.ts

@@ -23,8 +23,13 @@ describe('getDayLabel — ordinal temporal label', () => {
     // here per the normal ordinary-Sunday rule (see
     // tests/calendar/transfer.test.ts's own May 31 case for the full
     // winner/commemorations breakdown), so the label now reflects her,
-    // not Trinity Sunday itself.
-    expect(getDayLabel(resolveDay('2026-05-31'))).toBe('The Queenship of the Blessed Virgin Mary (Duplex II Class)');
+    // not Trinity Sunday itself — but Trinity Sunday is still
+    // commemorated in return (`decideOccurrence`'s own `ordinary-sunday`
+    // branch), by bare name only — a commemoration never carries a rank
+    // parenthetical, only the day's own winner does.
+    expect(getDayLabel(resolveDay('2026-05-31'))).toBe(
+      'The Queenship of the Blessed Virgin Mary (Duplex II Class) — Trinity Sunday',
+    );
     expect(getDayLabel(resolveDay('2026-04-05'))).toBe('Easter (Duplex I Class)');
     expect(getDayLabel(resolveDay('2026-02-18'))).toBe('Ash Wednesday');
   });
@@ -77,16 +82,29 @@ describe('getDayLabel — resumed post-Epiphany Sunday (overflow years)', () =>
     );
     // 2024-11-11 is St. Martin of Tours (Duplex, pre-existing content) --
     // an ordinary (non-privileged) Monday fully yields to a real winning
-    // saint, so the label is just his name, not the ferial fallback; see
-    // the 2035-10-29 assertion below for that fallback format on a
-    // genuinely saint-free overflow-week Monday instead (no single
-    // Nov-dated Monday near this Sunday pair is clean any more, now that
-    // Nov 4/8/15/16/20 are all fixed real content).
-    expect(getDayLabel(resolveDay('2024-11-11'))).toBe('St. Martin of Tours, Bishop and Confessor (Duplex Majus)');
-    expect(getDayLabel(resolveDay('2024-11-17'))).toBe('The 6th Sunday after Epiphany (Semiduplex)');
+    // saint, so the label is just his name (plus St. Menna, Simplex, also
+    // real and commemorated alongside him -- live-verified, Divino
+    // Afflatu 1954), not the ferial fallback; see the 2035-10-29 assertion
+    // below for that fallback format on a genuinely saint-free
+    // overflow-week Monday instead (no single Nov-dated Monday near this
+    // Sunday pair is clean any more, now that Nov 4/8/15/16/20 are all
+    // fixed real content).
+    expect(getDayLabel(resolveDay('2024-11-11'))).toBe(
+      'St. Martin of Tours, Bishop and Confessor (Duplex Majus) — St. Menna, Martyr',
+    );
+    // St. Gregory Thaumaturgus (Semiduplex, his real date) is commemorated
+    // right here, not transferred to Nov 18 -- live-verified (both
+    // Tridentine 1906 and Divino Afflatu 1954): a Semiduplex saint landing
+    // on an ordinary Sunday stays and is commemorated there, the same as
+    // Simplex, not pushed to the next open day (see
+    // calendar/commemorations.ts's `ordinary-sunday` case).
+    expect(getDayLabel(resolveDay('2024-11-17'))).toBe(
+      'St. Gregory Thaumaturgus, Bishop and Confessor — The 6th Sunday after Epiphany (Semiduplex)',
+    );
     // 2024-11-18 is the Dedication of the Basilicas of Ss. Peter and Paul
-    // (pre-existing fixed content) -- again a real winning saint, not the
-    // ferial fallback.
+    // (pre-existing fixed content) alone now -- again a real winning
+    // saint, not the ferial fallback, and no longer also carrying St.
+    // Gregory Thaumaturgus (he stays on his own real day, Nov 17, above).
     expect(getDayLabel(resolveDay('2024-11-18'))).toBe('Dedication of the Basilicas of Ss. Peter and Paul (Duplex)');
     // 2035-10-29, a Monday in the 3rd week of a different overflow
     // stretch, is genuinely clean (no sanctoral entry, no commemoration)
@@ -102,15 +120,39 @@ describe('getDayLabel — resumed post-Epiphany Sunday (overflow years)', () =>
     // Every year 1900-2100 lands on this same id for its own last Sunday
     // before Advent, so this ordinal is fixed, not overflow-year-specific
     // -- confirmed against a non-overflow year (1943) too.
-    expect(getDayLabel(resolveDay('2026-11-22'))).toBe('The 23rd Sunday after Trinity (Semiduplex)');
+    // St. Cecilia (Semiduplex, her real date) is commemorated right here
+    // too, not transferred -- live-verified (Divino Afflatu 1954), same
+    // rule as St. Gregory Thaumaturgus above.
+    expect(getDayLabel(resolveDay('2026-11-22'))).toBe(
+      'St. Cecilia, Virgin and Martyr — The 23rd Sunday after Trinity (Semiduplex)',
+    );
     // 1943-11-21 is also the Presentation of the BVM (Duplex Majus, added
-    // 2026-08 — see presentation-of-the-bvm.yml), which meets this app's
-    // existing privileged-Sunday rank threshold (commemorations.ts's
-    // `privileged-sunday` case requires only duplex-majus+) and so wins
-    // outright rather than being commemorated — a pre-existing rule, not
-    // new behavior from adding her. 2026-11-22 above (no saint collision)
-    // still covers the fixed-ordinal label itself.
-    expect(getDayLabel(resolveDay('1943-11-21'))).toBe('The Presentation of the Blessed Virgin Mary (Duplex Majus)');
+    // 2026-08 — see presentation-of-the-bvm.yml). It's `ordinary-sunday`
+    // here (this app's Trinitytide Sundays, including the fixed final
+    // one, carry no special first-class standing of their own), so
+    // commemorations.ts's `ordinary-sunday` case's plain Duplex+ threshold
+    // is what lets her win outright rather than being commemorated — a
+    // pre-existing rule, not new behavior from adding her. This case
+    // additionally confirms the displaced Sunday is still commemorated in
+    // return, using the same fixed 23rd-after-Trinity ordinal, not a raw
+    // elapsed-week count recomputed for 1943.
+    expect(getDayLabel(resolveDay('1943-11-21'))).toBe(
+      'The Presentation of the Blessed Virgin Mary (Duplex Majus) — The 23rd Sunday after Trinity',
+    );
+  });
+});
+
+describe('getDayLabel — commemorated Sunday/feria under a sanctoral winner', () => {
+  it('a saint winning outright on a privileged-feria-minor day still leaves that feria commemorated', () => {
+    // 2027-12-07, a Tuesday of Advent: St. Ambrose (Duplex) clears
+    // privileged-feria-minor's own Semiduplex+ threshold and wins
+    // outright, but Advent's own feria is still commemorated in return
+    // (`decideOccurrence`'s `privileged-feria-minor` branch) -- live-
+    // verified shape, same mechanism as the ordinary-Sunday case above,
+    // for the feria-tier branch instead.
+    expect(getDayLabel(resolveDay('2027-12-07'))).toBe(
+      'St. Ambrose, Bishop, Confessor and Doctor of the Church (Duplex) — Tuesday in the 2nd week of Advent',
+    );
   });
 });
 
@@ -171,20 +213,39 @@ describe('getDayLabel — active octave', () => {
     // occurring saint (see octaves.test.ts and the December/September
     // sanctoral tests for those counterexamples). The Assumption's own
     // day 3 (semiduplex, genuinely active but outranked by Lawrence's
-    // elevated duplex) still gets named, not dropped, alongside it.
+    // elevated duplex) still gets named, not dropped, alongside it -- with
+    // its own full "Nth Day within the Octave of X" phrasing, not a bare
+    // name: live-verified directly (Divino Afflatu 1954, where Aug 17's
+    // real winner is Hyacinth himself, not Lawrence's octave -- a
+    // different rubric-track outcome, but the same commemoration phrasing
+    // question): "Commemoratio: Tertia die infra Octavam S. Assumptionis
+    // Beatæ Mariæ Virginis", not a bare "The Assumption of the Blessed
+    // Virgin Mary".
     expect(getDayLabel(resolveDay('2026-08-17'))).toBe(
-      'Octave of St. Lawrence, Martyr (Duplex) — The Assumption of the Blessed Virgin Mary — St. Hyacinth, Confessor',
+      'Octave of St. Lawrence, Martyr (Duplex) — 3rd Day within the Octave of The Assumption of the Blessed Virgin Mary — St. Hyacinth, Confessor',
     );
     expect(getDayLabel(resolveDay('2026-08-18'))).toBe(
       '4th Day within the Octave of The Assumption of the Blessed Virgin Mary (Semiduplex)',
     );
   });
 
-  it('a real Sunday with standing of its own wins over both octaves entirely, showing the plain ordinal Sunday label -- not an octave name at all', () => {
+  it('a sanctoral winner on a Sunday still leaves the Sunday commemorated, but neither octave it also happens to overlap -- not an octave name at all', () => {
     // 2026-08-16 is a Sunday genuinely within both St. Lawrence's and the
-    // Assumption's overlapping octave windows.
+    // Assumption's overlapping octave windows -- St. Joachim (Duplex II
+    // Class) wins outright per the ordinary-Sunday Duplex+ threshold, not
+    // the Sunday itself (this test's own name was wrong about that before
+    // this case existed). Live-verified against Divino Afflatu 1954: the
+    // commemoration line reads only "Dominica XII Post Pentecosten" (this
+    // app's own Trinity-counted display is one week off from that
+    // Pentecost-counted number, so "11th ... after Trinity" here) -- no
+    // octave named at all, even though both are technically active, same
+    // as this app's own established `ordinary-feria`-only gate for
+    // octave mentions alongside a sanctoral winner.
     const day = resolveDay('2026-08-16');
     expect(day.weekday).toBe('sunday');
+    expect(getDayLabel(day)).toBe(
+      'St. Joachim, Confessor, Father of the Blessed Virgin Mary (Duplex II Class) — The 11th Sunday after Trinity',
+    );
     expect(getDayLabel(day)).not.toContain('Octave');
   });
 

tests/calendar/january-sanctoral.test.ts

@@ -48,10 +48,21 @@ describe('January sanctoral pull (first pass)', () => {
   it('a simplex saint on an ordinary Sunday is commemorated, not dropped or made to win', () => {
     // Jan 14, 2029 is the Second Sunday after Epiphany (ordinary, not
     // privileged) — St. Felix (simplex) is commemorated per the ordinary-
-    // Sunday rule, matching the historical calendar exactly.
+    // Sunday rule, matching the historical calendar exactly. St. Hilary of
+    // Poitiers (Semiduplex, also native to this date) is commemorated too
+    // -- live-verified (Divino Afflatu 1954) as the real, sole
+    // commemoration named there; this app's own generous-commemoration
+    // design (see CLAUDE.md) additionally keeps St. Felix rather than
+    // dropping him now that Hilary no longer needs the day to himself.
     const day = resolveDay('2029-01-14');
     expect(day.winner).toEqual({ kind: 'temporal', id: 'post-epiphany-2' });
     expect(day.commemorations).toEqual([
+      {
+        kind: 'sanctoral',
+        id: 'st-hilary-of-poitiers',
+        name: 'St. Hilary of Poitiers, Bishop, Confessor and Doctor of the Church',
+        rank: 'semiduplex',
+      },
       { kind: 'sanctoral', id: 'st-felix-presbyter', name: 'St. Felix, Priest and Martyr', rank: 'simplex' },
     ]);
   });

tests/calendar/july-sanctoral.test.ts

@@ -32,15 +32,25 @@ describe('July sanctoral pull (first pass)', () => {
     ]);
   });
 
-  it('the Vigil of St. James resolves alongside its own commemorated saint, distinct from St. James Day itself', () => {
+  it('St. Apollinaris (Semiduplex) is commemorated on his own Sunday rather than transferring, so the Vigil of St. James the next day is unaffected', () => {
+    // Corrects an earlier, unverified "transfer+collision" assumption —
+    // live-verified (Divino Afflatu 1954): a Semiduplex saint landing on
+    // an ordinary Sunday is commemorated right there, not pushed forward
+    // (see calendar/commemorations.ts's `ordinary-sunday` case). 2028's
+    // Jul 23 is a Sunday.
+    const sunday = resolveDay('2028-07-23');
+    expect(sunday.winner).toEqual({ kind: 'temporal', id: 'post-pentecost-07' });
+    expect(sunday.commemorations).toEqual([
+      { kind: 'sanctoral', id: 'st-apollinaris', name: 'St. Apollinaris, Bishop and Martyr', rank: 'semiduplex' },
+      { kind: 'sanctoral', id: 'st-liborius', name: 'St. Liborius, Bishop and Confessor', rank: 'simplex' },
+    ]);
+    // The Vigil of St. James wins its own day outright (Vigil outranks
+    // Simplex), with St. Christina commemorated -- no incoming transfer
+    // to contend with any more.
     const day = resolveDay('2028-07-24');
-    expect(day.winner.kind).toBe('sanctoral');
-    // 2028's Jul 23 is a Sunday, so St. Apollinaris transfers forward into
-    // this day and wins the collision against the Vigil/St. Christina —
-    // real transfer+collision interaction, not a data error.
-    expect(day.commemorations.map((c) => (c.kind === 'sanctoral' ? c.id : null)).sort()).toEqual([
-      'st-christina',
-      'vigil-of-st-james',
+    expect(day.winner).toEqual({ kind: 'sanctoral', id: 'vigil-of-st-james', name: 'Vigil of St. James the Greater', rank: 'vigil' });
+    expect(day.commemorations).toEqual([
+      { kind: 'sanctoral', id: 'st-christina', name: 'St. Christina, Virgin and Martyr', rank: 'simplex' },
     ]);
   });
 

tests/calendar/november-sanctoral.test.ts

@@ -53,7 +53,15 @@ describe('November sanctoral pull (first pass)', () => {
     expect(day.commemorations).toEqual([]);
   });
 
-  it('St. Clement transfers forward into St. Chrysogonus\'s day whenever his own date falls on a Sunday -- a single-day transfer this app models correctly, unlike August\'s multi-day-skip case', () => {
+  it("St. Clement (Semiduplex) is commemorated on his own Sunday rather than transferring, so St. Chrysogonus's own following day is unaffected either way", () => {
+    // Corrects an earlier, unverified assumption that a Semiduplex saint
+    // landing on an ordinary Sunday transfers forward -- live-verified
+    // (Divino Afflatu 1954) St. Clement is commemorated right there on
+    // Nov 23 ("Commemoratio: S. Clementis Papæ et Martyris"), same
+    // treatment Simplex already got (see calendar/commemorations.ts's
+    // `ordinary-sunday` case). St. Felicitas (Simplex, also native to
+    // Nov 23) is commemorated alongside him too, per this app's own
+    // generous-commemoration design.
     const clean = resolveDay('2032-11-24'); // Nov 23, 2032 is not a Sunday
     expect(clean.winner).toEqual({
       kind: 'sanctoral',
@@ -61,16 +69,22 @@ describe('November sanctoral pull (first pass)', () => {
       name: 'St. Chrysogonus, Martyr',
       rank: 'simplex',
     });
-    const transferred = resolveDay('2025-11-24'); // Nov 23, 2025 IS a Sunday
-    expect(transferred.winner).toEqual({
-      kind: 'sanctoral',
-      id: 'st-clement',
-      name: 'St. Clement I, Pope and Martyr',
-      rank: 'semiduplex',
-    });
-    expect(transferred.commemorations).toEqual([
-      { kind: 'sanctoral', id: 'st-chrysogonus', name: 'St. Chrysogonus, Martyr', rank: 'simplex' },
+    const onceASunday = resolveDay('2025-11-23'); // a Sunday
+    expect(onceASunday.winner).toEqual({ kind: 'temporal', id: 'post-pentecost-24' });
+    expect(onceASunday.commemorations).toEqual([
+      { kind: 'sanctoral', id: 'st-clement', name: 'St. Clement I, Pope and Martyr', rank: 'semiduplex' },
+      { kind: 'sanctoral', id: 'st-felicitas', name: 'St. Felicitas, Martyr', rank: 'simplex' },
     ]);
+    // St. Chrysogonus's own following day is untouched either way -- no
+    // incoming transfer any more.
+    const followingDay = resolveDay('2025-11-24');
+    expect(followingDay.winner).toEqual({
+      kind: 'sanctoral',
+      id: 'st-chrysogonus',
+      name: 'St. Chrysogonus, Martyr',
+      rank: 'simplex',
+    });
+    expect(followingDay.commemorations).toEqual([]);
   });
 
   it('St. Andrew wins outright at Duplex II. classis with a real proper collect and antiphon, commemorating the Advent feria itself in years his fixed date falls within Advent', () => {