calendar: split privileged-feria into two real precedence tiers

A plain Duplex saint was losing to any privileged feria (Ember days
included) since the occurrence engine only let duplex-1-classis+ get
even a commemoration there. Verified this was wrong: St. Gregory the
Great, plain Duplex, outright wins against a Lenten Ember Saturday in
the real Monastic 1617 engine.

Splits TemporalCategory's single privileged-feria into privileged-feria
(the lesser tier — Lent's Ember days, verified — now behaves like an
ordinary Sunday: Duplex+ wins outright) and privileged-feria-major (Ash
Wednesday, Holy Week, the Easter Octave, verified via St. Mark only ever
being commemorated there, never winning — behaves like privileged-
Sunday). Everywhere else the old single category was ambiguous
(Pentecost's own Ember days/Vigil/Octave, the Vigil of Christmas)
defaults to the stricter major tier pending verification.

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

src/calendar/commemorations.ts

@@ -8,10 +8,14 @@
 // Modeled as explicit rules per category, not a numeric-weight comparison
 // like the reference engine's occurrence()/concurrence() — see
 // data/calendar/temporal-categories.yml's header for why. Verified in part
-// against real dates (the Sunday-vs-Duplex threshold below was corrected
-// after finding St. Anthony Abbot, plain Duplex, outright winning against
-// an ordinary Sunday in the real Monastic 1617 engine — a genuine
-// correction, not a guess); the rest is the result of a design discussion,
+// against real dates: the Sunday-vs-Duplex threshold was corrected after
+// finding St. Anthony Abbot, plain Duplex, outright winning against an
+// ordinary Sunday in the real Monastic 1617 engine, and privileged-feria
+// was later split into two real tiers after finding St. Gregory the Great,
+// also plain Duplex, outright winning against a Lenten Ember Saturday
+// (which the original single-tier model wrongly forbade) while St. Mark,
+// Duplex II. classis, only ever gets commemorated — never wins outright —
+// within the Easter Octave. The rest is the result of a design discussion,
 // not yet independently verified against a primary source.
 
 import type { Commemoration, DayWinner, FeastClass, SanctoralIdentity, TemporalCategory } from './types';
@@ -81,11 +85,33 @@ export function decideOccurrence(
       return { winner: sanctoralWinner(sanctoral), commemorations: [] };
 
     case 'privileged-feria':
-      // Preferred to any feast whatsoever; admits no commemoration except
-      // one of the very highest class.
+      // The lesser of the two privileged-feria tiers (Ember days outside
+      // Holy Week/the Easter Octave, etc.) — behaves exactly like an
+      // ordinary Sunday: real standing of its own, but not enough to
+      // resist a sufficiently ranked feast the way privileged-feria-major
+      // does.
+      if (isAtLeast(sanctoral.rank, 'duplex')) {
+        return { winner: sanctoralWinner(sanctoral), commemorations: [{ kind: 'temporal', id: temporalId }] };
+      }
+      if (sanctoral.rank === 'simplex') {
+        return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
+      }
       return {
         winner: temporalWinner,
-        commemorations: isAtLeast(sanctoral.rank, 'duplex-1-classis') ? [sanctoralCommemoration(sanctoral)] : [],
+        commemorations: [],
+        transfer: { candidate: sanctoral, direction: transferDirectionOf(sanctoral.rank) },
+      };
+
+    case 'privileged-feria-major':
+      // Ash Wednesday, Holy Week, the Easter Octave, the Vigil of
+      // Christmas — never displaced, same as privileged-sunday.
+      if (isAtLeast(sanctoral.rank, 'duplex-majus')) {
+        return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
+      }
+      return {
+        winner: temporalWinner,
+        commemorations: [],
+        transfer: { candidate: sanctoral, direction: transferDirectionOf(sanctoral.rank) },
       };
 
     case 'ordinary-sunday':

src/calendar/index.ts

@@ -48,12 +48,14 @@ function applyIncomingTransfer(
   winner: DayWinner,
   commemorations: Commemoration[],
 ): DayWinner {
-  if (temporalCategory === 'privileged-feria') {
-    // Deferred: a transfer landing on a privileged feria (the concrete
-    // case is Holy Week, right after Palm Sunday) needs its own
-    // Easter-date-keyed lookup table, the same way the reference engine
-    // handles it — not modeled yet. The transfer is simply not delivered
-    // here rather than guessed at.
+  if (temporalCategory === 'privileged-feria-major') {
+    // Deferred: a transfer landing on one of these (the concrete case is
+    // Holy Week, right after Palm Sunday) needs its own Easter-date-keyed
+    // lookup table, the same way the reference engine handles it — not
+    // modeled yet. The transfer is simply not delivered here rather than
+    // guessed at. The lesser privileged-feria tier doesn't need this —
+    // ordinary collision/transfer logic is fine there, same as any
+    // ordinary-sunday landing.
     return winner;
   }
   if (winner.kind === 'temporal') {

src/calendar/types.ts

@@ -70,7 +70,24 @@ export type FeastClass =
 // category — reconstructed from general knowledge of the pre-1955
 // tradition, not yet verified against a primary source, so expect
 // corrections.
-export type TemporalCategory = 'ordinary-feria' | 'privileged-feria' | 'ordinary-sunday' | 'privileged-sunday';
+// `privileged-feria` and `privileged-feria-major` are two real, distinct
+// tiers (confirmed by finding a plain Duplex saint, St. Gregory the Great,
+// outright winning against a Lenten Ember Saturday in the real Monastic
+// 1617 engine, which the original single-tier model wrongly forbade) —
+// see calendar/commemorations.ts's rules for `privileged-feria` (behaves
+// like `ordinary-sunday`: Duplex+ wins outright) vs `privileged-feria-major`
+// (behaves like `privileged-sunday`: never displaced at all, confirmed by
+// checking St. Mark, Duplex II. classis, merely commemorated rather than
+// winning within the Easter Octave). See data/calendar/temporal-
+// categories.yml for exactly which days fall in which tier — some of that
+// split (e.g. whether Pentecost's own Ember days share Lent's lesser tier
+// or Easter's major one) is still a reconstructed guess, not verified.
+export type TemporalCategory =
+  | 'ordinary-feria'
+  | 'privileged-feria'
+  | 'privileged-feria-major'
+  | 'ordinary-sunday'
+  | 'privileged-sunday';
 
 export interface SanctoralIdentity {
   id: string;

src/calendar/vespers.ts

@@ -42,7 +42,12 @@ function hasFirstVespers(day: LiturgicalDay): boolean {
 
 /** Does this day keep its own Second Vespers regardless of what tomorrow is? */
 function keepsOwnSecondVespers(day: LiturgicalDay): boolean {
-  if (day.weekday === 'sunday' || day.temporalCategory === 'privileged-feria' || isMajorFixedFeastOfTheLord(day.date)) {
+  if (
+    day.weekday === 'sunday' ||
+    day.temporalCategory === 'privileged-feria' ||
+    day.temporalCategory === 'privileged-feria-major' ||
+    isMajorFixedFeastOfTheLord(day.date)
+  ) {
     return true;
   }
   return day.winner.kind === 'sanctoral' && isAtLeast(day.winner.rank, 'duplex-2-classis');