Trim TODO.md's Open Work section down to actual open items

Cut the intro/priority blurb, dropped the epilogue prose after
"none currently open" (that detail lives in the dated log below),
stripped New Features down to just the features, and removed the
Known Simplifications list entirely since it isn't open work — that
detail already lives as comments in temporal-categories.yml.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LGsATZvfnpQ81HQuoF5JuL

.gitignore

@@ -2,3 +2,7 @@ node_modules
 dist
 dev-dist
 *.local
+
+CLAUDE.md
+MEMORY.md
+.claude/

README.md

@@ -0,0 +1,72 @@
+# vu
+
+A static, offline-first PWA for praying the Divine Office — Matins, Lauds, Prime, Terce, Sext,
+None, Vespers, and Compline — in bilingual Latin/English, for any given date.
+
+This isn't a reconstruction of any single historical breviary. It's a personal design that
+draws on several historical sources without reproducing any one of them exactly: hour
+structure chiefly from the Monastic Tridentinum (1617), precedence/rubrics from Divino
+Afflatu, and a calendar merged from both the Tridentine 1906 and Divino Afflatu calendars,
+with more generous handling of commemorations and octaves than any one historical rite used.
+See `CLAUDE.md` (gitignored, not shipped in this repo) or the project's own notes for the full
+rationale if you're extending it.
+
+There's no backend and no database — everything is a pre-built static bundle, and the app is
+designed to keep working fully offline once it's been loaded once.
+
+## Development
+
+Requires Node.js (developed against Node 20+).
+
+```sh
+npm install
+npm run dev        # start the Vite dev server
+npm run build       # type-check (tsc --noEmit) and produce a production build in dist/
+npm run preview     # serve the production build locally
+npm test            # run the test suite (vitest)
+```
+
+Run a single test file or a subset by name:
+
+```sh
+npx vitest run tests/hours/vespers.test.ts
+npx vitest run -t "some test name"
+```
+
+## Running in production
+
+The app is entirely static once built, so "running it" just means serving `dist/` — any static
+file host works, as long as it falls back to `index.html` for unknown paths (the app does its
+own client-side routing for URLs like `/2026-08-09/prime`).
+
+### Docker
+
+A `Dockerfile` builds the static bundle with Node and serves it with Caddy:
+
+```sh
+docker build -t vu .
+docker run -p 8080:80 vu
+```
+
+Or with Docker Compose (`docker-compose.yml` is included):
+
+```sh
+docker compose up -d --build
+```
+
+This serves the app on `http://localhost:8080`. Put a reverse proxy/TLS terminator in front of
+it for a real deployment; the container itself just listens on port 80 internally and has no
+configuration, secrets, or external dependencies.
+
+### Without Docker
+
+Any static file server works — build the app, then serve `dist/` with SPA-style fallback
+routing. For example, with Caddy directly:
+
+```sh
+npm run build
+caddy file-server --root dist --listen :8080
+```
+
+(For a real deployment you'll want a fallback rule so unknown paths resolve to `index.html` —
+see the `Caddyfile` in this repo for the pattern.)

docker-compose.yml

@@ -0,0 +1,10 @@
+# Generic production compose file — builds the static bundle and serves it
+# with Caddy on port 8080. Not tied to any particular host's network/proxy
+# setup; put a reverse proxy or TLS terminator in front of it as needed.
+services:
+  vu:
+    build: .
+    container_name: vu
+    restart: unless-stopped
+    ports:
+      - "8080:80"

src/app-state.ts

@@ -16,9 +16,22 @@ export function todayIso(): string {
   return `${yyyy}-${mm}-${dd}`;
 }
 
+/** Which hour to default to when the URL doesn't specify one, based on local wall-clock time. */
+export function defaultHourForTime(date: Date): HourId {
+  const h = date.getHours();
+  if (h < 6) return 'matins';
+  if (h < 8) return 'lauds';
+  if (h < 9) return 'prime';
+  if (h < 12) return 'terce';
+  if (h < 15) return 'sext';
+  if (h < 17) return 'none';
+  if (h < 21) return 'vespers';
+  return 'compline';
+}
+
 const state: AppState = {
   date: todayIso(),
-  selectedHour: 'prime',
+  selectedHour: defaultHourForTime(new Date()),
   languages: ['en'],
 };
 
@@ -43,14 +56,35 @@ export function setDate(date: string): void {
   notify();
 }
 
+/**
+ * Which hour the "Today" link should point to: if we're already viewing
+ * today, the current time-of-day default (as if freshly visiting `/vu`
+ * right now); otherwise the hour currently selected, unchanged. Shared by
+ * `goToToday()` and the link's `href` (`day-nav.ts`) so a plain click and
+ * a right-click-open-in-new-tab land on the same target.
+ */
+export function todayTargetHour(): HourId {
+  return state.date === todayIso() ? defaultHourForTime(new Date()) : state.selectedHour;
+}
+
 export function goToToday(): void {
-  setDate(todayIso());
+  const today = todayIso();
+  const hour = todayTargetHour();
+  if (state.date === today) {
+    setSelectedHour(hour);
+  } else {
+    setDate(today);
+  }
+}
+
+export function addDays(date: string, days: number): string {
+  const d = new Date(`${date}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + days);
+  return d.toISOString().slice(0, 10);
 }
 
 export function shiftDate(days: number): void {
-  const d = new Date(`${state.date}T00:00:00Z`);
+  setDate(addDays(state.date, days));
-  d.setUTCDate(d.getUTCDate() + days);
-  setDate(d.toISOString().slice(0, 10));
 }
 
 export function setSelectedHour(hourId: HourId): void {

src/calendar/collision.ts

@@ -19,11 +19,11 @@ export interface CollisionResult {
 }
 
 function asWinner(candidate: SanctoralIdentity): DayWinner {
-  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, rank: candidate.rank };
+  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, nameLa: candidate.nameLa, rank: candidate.rank };
 }
 
 function asCommemoration(candidate: SanctoralIdentity): Commemoration {
-  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, rank: candidate.rank };
+  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, nameLa: candidate.nameLa, rank: candidate.rank };
 }
 
 /**

src/calendar/commemorations.ts

@@ -38,6 +38,34 @@ export function isAtLeast(rank: FeastClass, threshold: FeastClass): boolean {
   return compareFeastClass(rank, threshold) >= 0;
 }
 
+/**
+ * The minimum rank a real sanctoral candidate needs to win each temporal
+ * category outright, per `decideOccurrence`'s own branches above —
+ * factored out so calendar/octaves.ts can ask the identical question of an
+ * *octave*'s own effective standing (not a real occurring saint) on a day
+ * where nothing else won. `undefined` where nothing ever wins outright no
+ * matter how high-ranked (`privileged-feria-major`/`privileged-sunday` —
+ * Ash Wednesday, Holy Week, a privileged Sunday — only ever get a
+ * commemoration at best, per those branches above). `ordinary-feria` has
+ * no real threshold at all (any real content wins), included here as
+ * `'simplex'` (the weakest real rank) only for completeness — callers
+ * needing that case already have their own unconditional path and don't
+ * need to call this. */
+export function minimumOutrightWinningRank(category: TemporalCategory): FeastClass | undefined {
+  switch (category) {
+    case 'ordinary-feria':
+      return 'simplex';
+    case 'privileged-feria-minor':
+      return 'semiduplex';
+    case 'privileged-feria':
+    case 'ordinary-sunday':
+      return 'duplex';
+    case 'privileged-feria-major':
+    case 'privileged-sunday':
+      return undefined;
+  }
+}
+
 /** Vigils belong to the day *before* their feast, so an impeded vigil is
  * shifted backward rather than forward like everything else — see
  * calendar/transfer.ts. */
@@ -55,11 +83,11 @@ export interface OccurrenceResult {
 }
 
 function sanctoralCommemoration(candidate: SanctoralIdentity): Commemoration {
-  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, rank: candidate.rank };
+  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, nameLa: candidate.nameLa, rank: candidate.rank };
 }
 
 function sanctoralWinner(candidate: SanctoralIdentity): DayWinner {
-  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, rank: candidate.rank };
+  return { kind: 'sanctoral', id: candidate.id, name: candidate.name, nameLa: candidate.nameLa, rank: candidate.rank };
 }
 
 /**
@@ -115,11 +143,22 @@ export function decideOccurrence(
       };
 
     case 'privileged-feria-major':
-      // Ash Wednesday, Holy Week, the Easter Octave, the Vigil of
+      // Ash Wednesday, Holy Week, the Easter Octave, Low Sunday, the
-      // Christmas — never displaced, same as privileged-sunday.
+      // Vigils of Christmas/Pentecost — never displaced, and never gives
-      if (isAtLeast(sanctoral.rank, 'duplex-majus')) {
+      // even a bare commemoration to any rank, same as privileged-sunday.
-        return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
+      // The "duplex-majus+ still gets a nod" branch this case used to
-      }
+      // have was wrong, not just unverified: the one case that seemed to
+      // support it (St. Mark, Duplex II. classis, "merely commemorated"
+      // within the Easter Octave) turns out to have been a misreading —
+      // live-verified 2026-09-01, direct instruction ("you dont
+      // commemorate -anything- from palm sunday through low sunday"),
+      // confirmed with two more dates on top of the Annunciation/Palm-
+      // Easter-Sunday evidence already in the privileged-sunday case
+      // below: the Annunciation (Duplex I. classis) transfers with zero
+      // commemoration on Holy Thursday itself in years it lands there
+      // (2027/2032/2043), and Chair of St. Peter at Antioch (Duplex
+      // majus) transfers off Ash Wednesday the same way (2034) — so the
+      // exception was wrong for Ash Wednesday too, not just Holy Week.
       return {
         winner: temporalWinner,
         commemorations: [],
@@ -137,8 +176,22 @@ export function decideOccurrence(
         return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
       }
       // Semiduplex or Vigil: no room here at all, in either direction —
-      // better to preserve the feast whole on another day than downgrade
+      // per direct instruction, an ordinary Sunday's own standing pushes
-      // it to a bare commemoration.
+      // a Semiduplex feast off to the next open day (typically the
+      // Monday right after) rather than downgrading it to a bare
+      // commemoration. This `transfer` signal is only half of the
+      // mechanism: it's just this day noting "I couldn't hold onto this
+      // candidate." The other half — a later day actually claiming a
+      // transferred-in candidate — lives entirely in calendar/index.ts's
+      // resolveDay: for *every* date it resolves, it independently
+      // recomputes `resolveNativeOccurrence` for both the day before and
+      // the day after, checks whether *that* neighbor's own native
+      // occurrence produced a `transfer` pointed this direction, and only
+      // then folds it in via `applyIncomingTransfer`. So "Monday looks
+      // back at the sanctoral calendar to see if Sunday's own candidate
+      // needs a home" isn't a separate mechanism to build — it's the
+      // existing generic transfer-consumption check, which already runs
+      // for every day regardless of category.
       return {
         winner: temporalWinner,
         commemorations: [],
@@ -146,13 +199,22 @@ export function decideOccurrence(
       };
 
     case 'privileged-sunday':
-      if (isAtLeast(sanctoral.rank, 'duplex-majus')) {
+      // A privileged Sunday wants nothing at all, no matter how high the
-        // Never displaced, but a sufficiently high feast still gets a nod.
+      // candidate ranks — not even the bare commemoration an ordinary
-        return { winner: temporalWinner, commemorations: [sanctoralCommemoration(sanctoral)] };
+      // Sunday would allow a Simplex, and no exception for duplex-majus+ —
-      }
+      // everything transfers. Live-verified 2026-09-01, three independent
-      // Below duplex-majus, a privileged Sunday wants nothing at all —
+      // dates: the Immaculate Conception (Duplex I. classis) transfers off
-      // not even the bare commemoration an ordinary Sunday would allow a
+      // Advent II with no commemoration at all (real dates 2024/2030/2041),
-      // Simplex — so everything here transfers.
+      // and the Annunciation (also Duplex I. classis) transfers off both
+      // Palm Sunday and Easter Sunday itself the same way (2029/2035/2040/
+      // 2046) — confirmed by direct instruction as the correct behavior,
+      // correcting an earlier, never-actually-verified "duplex-majus+
+      // still gets a nod" guess. (Where a transferred candidate actually
+      // lands is a separate, still-generic `transferDirectionOf`/next-
+      // open-day mechanism — the Annunciation's own real rule of jumping
+      // *past* the whole Easter Octave rather than landing inside it is a
+      // known follow-on, blocked on the not-yet-built Easter-octave
+      // mechanism; see TODO.md.)
       return {
         winner: temporalWinner,
         commemorations: [],

src/calendar/day-label.ts

@@ -9,12 +9,78 @@
 // become a configurable choice later (the same day->id indirection
 // philosophy already used for the sanctoral calendar), not hardcoded here
 // forever — just not built yet.
-import type { LiturgicalDay } from './types';
+//
+// Bilingual: every label is built as a `Bi` (`{en, la}`) pair throughout.
+// Proper names (a saint's name, an octave's name, a named temporal feast's
+// name) carry an optional `nameLa` field alongside the required English
+// `name` — see calendar/types.ts's `SanctoralIdentity.nameLa` doc comment.
+// Authored for essentially every saint/octave/named-feast as of 2026-08-31
+// (see TODO.md); `biName` still falls back to the English string as the
+// `la` value for the rare unauthored case (same "surface real text rather
+// than block on missing" convention used elsewhere in this app), rather
+// than leaving Latin mode showing blanks. The closed, mechanism-level
+// vocabulary here (weekdays, ranks, season/ordinal phrasing) has always
+// had real Latin authored, independent of this.
+import type { FeastClass, LiturgicalDay, TemporalCategory, Weekday } from './types';
 import { easterSunday } from './easter';
 import { adventStart, firstSundayStrictlyAfter, sundayOnOrBefore } from './temporal';
 import { addDays, daysBetween, toIsoDate } from './date-math';
 import { getTemporalFeastRecord } from './temporal-feasts';
-import { resolveActiveOctave, type ActiveOctave } from './octaves';
+import { activeOctavesFor, octaveGoverningPrivilegedDay, resolveActiveOctave, type ActiveOctave } from './octaves';
+import { resolveTemporalId } from './temporal-id';
+
+interface Bi {
+  en: string;
+  la: string;
+  [lang: string]: string;
+}
+
+function bi(en: string, la: string): Bi {
+  return { en, la };
+}
+
+/** A proper name (saint, octave, named temporal feast) with an optional
+ * authored Latin form — falls back to the English string when `nameLa`
+ * hasn't been authored yet, same convention as `biFallback` above. */
+function biName(name: string, nameLa: string | undefined): Bi {
+  return { en: name, la: nameLa ?? name };
+}
+
+function joinBi(items: Bi[], sep = ' — '): Bi {
+  return { en: items.map((i) => i.en).join(sep), la: items.map((i) => i.la).join(sep) };
+}
+
+/**
+ * The 6 Ember-day ids (calendar/ember-days.ts) are deliberately *not* in
+ * temporal-feasts.ts's named-feast table — they're privileged ferias, not
+ * rank-contesting movable feasts (see that file's own doc comment), and
+ * that table's `getTemporalFeastRecord` also doubles as resolve-
+ * common.ts's `isFerialOrVigil` bareness check, so adding them there
+ * would silently turn off their own ferial Preces (their `[Rule]` block
+ * is literally "Preces Feriales"). A small standalone lookup here instead
+ * — Latin names read straight from each day's own `[Officium]` header
+ * (Tempora/093-{3,5,6}.txt, Tempora/Adv3-{3,5,6}.txt).
+ *
+ * Without this, an Ember day never named itself anywhere in the UI: not
+ * as the primary label when it wins outright (fell through to the plain
+ * "Wednesday in the Nth week after Trinity"/"In the Nth week of Advent"
+ * wording with no Ember mention at all), and not as a commemoration when
+ * demoted (collectCommemorations's temporal branch only ever matched
+ * `resolveTemporalId(day.date)`, never an Ember-relabeled id) — live-
+ * verified as a real, user-visible gap, 2026-09-03.
+ */
+const EMBER_DAY_NAMES: Record<string, Bi> = {
+  'ember-september-wednesday': bi('Ember Wednesday in September', 'Feria Quarta Quattuor Temporum Septembris'),
+  'ember-september-friday': bi('Ember Friday in September', 'Feria Sexta Quattuor Temporum Septembris'),
+  'ember-september-saturday': bi('Ember Saturday in September', 'Sabbato Quattuor Temporum Septembris'),
+  'ember-advent-wednesday': bi('Ember Wednesday in Advent', 'Feria IV Quattuor Temporum in Adventu'),
+  'ember-advent-friday': bi('Ember Friday in Advent', 'Feria VI Quattuor Temporum in Adventu'),
+  'ember-advent-saturday': bi('Ember Saturday in Advent', 'Sabbato Quattuor Temporum in Adventu'),
+};
+
+export function emberDayLabel(id: string): Bi | undefined {
+  return EMBER_DAY_NAMES[id];
+}
 
 function capitalize(text: string): string {
   return text.charAt(0).toUpperCase() + text.slice(1);
@@ -37,6 +103,56 @@ function ordinal(n: number): string {
   }
 }
 
+// Feminine Latin ordinal adjectives (agreeing with "Dominica"/"Hebdomada"/
+// "die", all feminine) — covers 1st through 24th, the full range this app
+// ever counts to (Trinitytide's fixed last week is the 23rd). Not a general
+// Latin-numerals utility, just this app's own closed display vocabulary.
+const ORDINAL_LA = [
+  '',
+  'prima',
+  'secunda',
+  'tertia',
+  'quarta',
+  'quinta',
+  'sexta',
+  'septima',
+  'octava',
+  'nona',
+  'decima',
+  'undecima',
+  'duodecima',
+  'decima tertia',
+  'decima quarta',
+  'decima quinta',
+  'decima sexta',
+  'decima septima',
+  'decima octava',
+  'decima nona',
+  'vicesima',
+  'vicesima prima',
+  'vicesima secunda',
+  'vicesima tertia',
+  'vicesima quarta',
+];
+
+function ordinalLa(n: number): string {
+  return ORDINAL_LA[n] ?? `${n}a`;
+}
+
+const WEEKDAY_LABELS: Record<Weekday, Bi> = {
+  sunday: bi('Sunday', 'Dominica'),
+  monday: bi('Monday', 'Feria Secunda'),
+  tuesday: bi('Tuesday', 'Feria Tertia'),
+  wednesday: bi('Wednesday', 'Feria Quarta'),
+  thursday: bi('Thursday', 'Feria Quinta'),
+  friday: bi('Friday', 'Feria Sexta'),
+  saturday: bi('Saturday', 'Sabbato'),
+};
+
+function weekdayLabel(day: LiturgicalDay): Bi {
+  return WEEKDAY_LABELS[day.weekday];
+}
+
 interface OrdinalSeason {
   /** ISO date of the season's own anchor day, for a given calendar year. */
   anchorDate(year: number): string;
@@ -44,48 +160,80 @@ interface OrdinalSeason {
    * Lent: the anchor is its own named day, excluded from the count — the
    * numbered weeks start the following Sunday. */
   includeAnchorWeek: boolean;
-  /** Used in "Weekday after {anchorName}" for the anchor's own partial week. */
+  /** Used in "Weekday after {anchorName}" for the anchor's own partial week,
-  anchorName: string;
+   * and as the anchor day's own standalone name. */
-  /** Used in "the Nth Sunday/week {preposition} {ordinalName}". */
+  anchorName: Bi;
-  ordinalName: string;
+  /** Used in "the Nth Sunday/week {preposition} {ordinalName}". For
+   * `preposition: 'of'`, `ordinalName.la` is already the correct genitive
+   * form (glued directly after the ordinal, no linking word — Latin
+   * idiom). For `preposition: 'after'`, `ordinalName.la` is the form used
+   * after "post" (traditionally accusative, or an idiomatic fixed phrase
+   * like "post Cineres"). */
+  ordinalName: Bi;
   preposition: 'after' | 'of';
+  /** The season's own anchor day's rank, if it sits on the closed
+   * pre-1955 duplex scale at all — Ash Wednesday (Lent's anchor) doesn't;
+   * a privileged feria has no duplex-scale rank, so it's left undefined
+   * and shows no parenthetical, same "omit rather than guess" convention
+   * `formatRank`/`status` fields use elsewhere. */
+  anchorRank?: FeastClass;
+  /** Advent and Lent only: once the header always shows the day's weekday
+   * on its own, repeating it at the front of this label is redundant — so
+   * those two seasons drop it here, in both languages. Every other season
+   * keeps the weekday prefix (explicit, narrower scope decision). */
+  dropWeekdayPrefix?: boolean;
 }
 
 const ORDINAL_SEASONS: Partial<Record<string, OrdinalSeason>> = {
   advent: {
     anchorDate: adventStart,
     includeAnchorWeek: true,
-    anchorName: 'Advent',
+    anchorName: bi('Advent', 'Adventus'),
-    ordinalName: 'Advent',
+    // Genitive of 4th-declension "adventus" is also "Adventus" — no
+    // linking word needed: "Hebdomada II Adventus".
+    ordinalName: bi('Advent', 'Adventus'),
     preposition: 'of',
+    dropWeekdayPrefix: true,
   },
   epiphanytide: {
     anchorDate: (year) => `${year}-01-06`,
     includeAnchorWeek: false,
-    anchorName: 'Epiphany',
+    anchorName: bi('Epiphany', 'Epiphania'),
-    ordinalName: 'Epiphany',
+    // Accusative, for "post Epiphaniam".
+    ordinalName: bi('Epiphany', 'Epiphaniam'),
     preposition: 'after',
+    anchorRank: 'duplex-1-classis',
   },
   lent: {
     anchorDate: (year) => addDays(toIsoDate(easterSunday(year)), -46),
     includeAnchorWeek: false,
-    anchorName: 'Ash Wednesday',
+    anchorName: bi('Ash Wednesday', 'Feria Quarta Cinerum'),
-    ordinalName: 'Lent',
+    // Genitive of 1st-declension "Quadragesima": "Hebdomada II
+    // Quadragesimae". The pre-Lent-I days use the real traditional idiom
+    // "post Cineres" instead (see temporalLabel below), not this field.
+    ordinalName: bi('Lent', 'Quadragesimae'),
     preposition: 'of',
+    dropWeekdayPrefix: true,
   },
   eastertide: {
     anchorDate: (year) => toIsoDate(easterSunday(year)),
     includeAnchorWeek: false,
-    anchorName: 'Easter',
+    anchorName: bi('Easter', 'Pascha'),
-    ordinalName: 'Easter',
+    // "Pascha" is indeclinable — same form after "post".
+    ordinalName: bi('Easter', 'Pascha'),
     preposition: 'after',
+    anchorRank: 'duplex-1-classis',
   },
   trinitytide: {
     anchorDate: (year) => addDays(toIsoDate(easterSunday(year)), 56),
     includeAnchorWeek: false,
-    anchorName: 'Trinity Sunday',
+    anchorName: bi('Trinity Sunday', 'Dominica Sanctissimae Trinitatis'),
-    ordinalName: 'Trinity',
+    // Accusative, for "post Sanctissimam Trinitatem" — this app's own
+    // Trinity-counted convention (see file header), not the historical
+    // Pentecost-counted "post Pentecosten".
+    ordinalName: bi('Trinity', 'Sanctissimam Trinitatem'),
     preposition: 'after',
+    anchorRank: 'duplex-1-classis',
   },
 };
 
@@ -97,28 +245,99 @@ const ORDINAL_SEASONS: Partial<Record<string, OrdinalSeason>> = {
  * octave, but nobody calls it that). Advent's own anchor (Advent I Sunday)
  * doesn't take this branch — it's already "the 1st Sunday of Advent" via
  * the ordinal path below. */
-function anchorDayName(day: LiturgicalDay): string | undefined {
+function anchorDayName(day: LiturgicalDay, withRank = true): Bi | undefined {
   const config = ORDINAL_SEASONS[day.season];
   if (!config || config.includeAnchorWeek) {
     return undefined;
   }
   const year = Number(day.date.slice(0, 4));
   if (day.date === config.anchorDate(year)) {
-    return config.anchorName;
+    return withRank && config.anchorRank
+      ? bi(`${config.anchorName.en} (${formatRank(config.anchorRank).en})`, `${config.anchorName.la} (${formatRank(config.anchorRank).la})`)
+      : config.anchorName;
   }
   return undefined;
 }
 
-function temporalLabel(day: LiturgicalDay): string {
+/** The fixed final Sunday of the liturgical year (temporal-id.ts's
-  const weekdayName = capitalize(day.weekday);
+ * `post-pentecost-24`) always carries "Sunday XXIV after Pentecost"'s own
+ * formulary, regardless of how many Sundays actually elapsed since
+ * Trinity — confirmed by scanning every year 1900-2100, every single one
+ * lands on this id for its own last Sunday before Advent, never a raw
+ * elapsed-week count. This app's Trinity-counted display is one week off
+ * from that Pentecost-counted id (Trinity Sunday itself = post-pentecost-
+ * 01 = the display's own uncounted anchor day), so the fixed display
+ * ordinal here is XXIV - 1 = 23, not whatever a plain "weeks since
+ * Trinity" calculation would produce. */
+const FIXED_LAST_SUNDAY_ORDINAL = 23;
+
+/**
+ * Trinitytide's ordinal display can't be pure "weeks since Trinity's own
+ * first Sunday" arithmetic once the season gets late enough — see
+ * temporal-id.ts's own post-Pentecost-XXIII-plus branch. Two cases, both
+ * driven by `resolveTemporalId` directly (the same mechanism the content
+ * layer already trusts, rather than re-deriving the wdist arithmetic here
+ * a second time, so the label can never disagree with what's actually
+ * rendered underneath):
+ *   - A resumed post-Epiphany Sunday/week (an overflow year's skipped
+ *     Epiphany Sundays, reappearing here) — reads "after Epiphany", not
+ *     the next Trinity-counted number in line.
+ *   - The fixed final Sunday/week of the year itself — always the fixed
+ *     23rd-after-Trinity ordinal (see FIXED_LAST_SUNDAY_ORDINAL above),
+ *     every year, not just overflow ones.
+ * Only ever fires within trinitytide, since that's the only season
+ * resolveTemporalId can return either of these ids for a date outside
+ * their own native season. Trinitytide isn't in the weekday-drop set, so
+ * both languages keep their weekday prefix here.
+ */
+function trinitytideOverrideLabel(day: LiturgicalDay): Bi | undefined {
+  if (day.season !== 'trinitytide') {
+    return undefined;
+  }
+  const id = resolveTemporalId(day.date);
+  const weekdayName = weekdayLabel(day);
+
+  const epiphanyMatch = id.match(/^post-epiphany-(\d)$/);
+  if (epiphanyMatch) {
+    const n = Number(epiphanyMatch[1]);
+    return day.weekday === 'sunday'
+      ? bi(`The ${ordinal(n)} Sunday after Epiphany`, `Dominica ${ordinalLa(n)} post Epiphaniam`)
+      : bi(`${weekdayName.en} in the ${ordinal(n)} week after Epiphany`, `${weekdayName.la} in hebdomada ${ordinalLa(n)} post Epiphaniam`);
+  }
+
+  if (id === 'post-pentecost-24') {
+    return day.weekday === 'sunday'
+      ? bi(
+          `The ${ordinal(FIXED_LAST_SUNDAY_ORDINAL)} Sunday after Trinity`,
+          `Dominica ${ordinalLa(FIXED_LAST_SUNDAY_ORDINAL)} post Sanctissimam Trinitatem`,
+        )
+      : bi(
+          `${weekdayName.en} in the ${ordinal(FIXED_LAST_SUNDAY_ORDINAL)} week after Trinity`,
+          `${weekdayName.la} in hebdomada ${ordinalLa(FIXED_LAST_SUNDAY_ORDINAL)} post Sanctissimam Trinitatem`,
+        );
+  }
+
+  return undefined;
+}
+
+function temporalLabel(day: LiturgicalDay): Bi {
+  const trinitytideOverride = trinitytideOverrideLabel(day);
+  if (trinitytideOverride) {
+    return trinitytideOverride;
+  }
+
+  const weekdayName = weekdayLabel(day);
   const config = ORDINAL_SEASONS[day.season];
   if (!config) {
     // No ordinal convention modeled for this season (Septuagesima-tide,
     // Passiontide, Ascensiontide, Pentecost, Christmastide, the
     // Corpus-Christi/Sacred-Heart single-day seasons) — their few days
     // mostly have their own proper names rather than ordinal counting, so
-    // this fallback is expected to be seen, not a gap to fill later.
+    // this fallback is expected to be seen, not a gap to fill later. No
-    return `${weekdayName} in ${capitalize(day.season.replace(/-/g, ' '))}`;
+    // authored Latin season name exists for these yet, so `la` falls back
+    // to the same English season word.
+    const seasonName = capitalize(day.season.replace(/-/g, ' '));
+    return bi(`${weekdayName.en} in ${seasonName}`, `${weekdayName.la} in ${seasonName}`);
   }
 
   const year = Number(day.date.slice(0, 4));
@@ -130,85 +349,372 @@ function temporalLabel(day: LiturgicalDay): string {
 
   const firstNumberedSunday = config.includeAnchorWeek ? anchor : firstSundayStrictlyAfter(anchor);
   if (day.date < firstNumberedSunday) {
-    return `${weekdayName} after ${config.anchorName}`;
+    // Lent's own pre-Lent-I days use the real traditional idiom "post
+    // Cineres" rather than the season's genitive `ordinalName` (which is
+    // built for the "of Lent" construction, not "after Ash Wednesday").
+    const afterAnchorLa = day.season === 'lent' ? 'Cineres' : config.anchorName.la;
+    return config.dropWeekdayPrefix
+      ? bi(`After ${config.anchorName.en}`, `Post ${afterAnchorLa}`)
+      : bi(`${weekdayName.en} after ${config.anchorName.en}`, `${weekdayName.la} post ${afterAnchorLa}`);
   }
 
   const weeksSince = daysBetween(firstNumberedSunday, sundayOnOrBefore(day.date)) / 7;
   const ordinalStr = ordinal(weeksSince + 1);
+  const ordinalStrLa = ordinalLa(weeksSince + 1);
   if (day.weekday === 'sunday') {
-    return `The ${ordinalStr} Sunday ${config.preposition} ${config.ordinalName}`;
+    return config.preposition === 'of'
+      ? bi(`The ${ordinalStr} Sunday of ${config.ordinalName.en}`, `Dominica ${ordinalStrLa} ${config.ordinalName.la}`)
+      : bi(`The ${ordinalStr} Sunday after ${config.ordinalName.en}`, `Dominica ${ordinalStrLa} post ${config.ordinalName.la}`);
   }
-  return `${weekdayName} in the ${ordinalStr} week ${config.preposition} ${config.ordinalName}`;
+  const weekPhraseLa =
+    config.preposition === 'of' ? `hebdomada ${ordinalStrLa} ${config.ordinalName.la}` : `hebdomada ${ordinalStrLa} post ${config.ordinalName.la}`;
+  return config.dropWeekdayPrefix
+    ? bi(`In the ${ordinalStr} week ${config.preposition} ${config.ordinalName.en}`, `In ${weekPhraseLa}`)
+    : bi(`${weekdayName.en} in the ${ordinalStr} week ${config.preposition} ${config.ordinalName.en}`, `${weekdayName.la} in ${weekPhraseLa}`);
 }
 
-/** "Third Day within the Octave of St. Lawrence" — the real DO title an
+/** "Third Day within the Octave of St. Lawrence" for an ordinary mid-octave
- * octave day carries on its own (e.g. "Tertia die infra Octavam S.
+ * day ("Tertia die infra Octavam S. Laurentii Martyris"), or plain "Octave
- * Laurentii Martyris") when nothing else has displaced it. Day 1 shouldn't
+ * of St. Lawrence" for the octave's own closing day ("In Octava S.
- * normally reach this (that day's own winner is the feast itself, handled
+ * Laurentii Martyris") — real DO Latin distinguishes "infra octavam"
- * above before this is ever called) — kept simple rather than
+ * (within the octave, days 2-7) from "in octava" (on the octave day
- * special-cased for that rare edge case (see applyOctaves's own
+ * itself, day 8), live-verified: Aug 17 (St. Lawrence's closing day)
- * `isOwnStartDay` comment in calendar/index.ts for when it can happen). */
+ * titles itself "In Octava S. Laurentii Martyris", not "Octava die infra
-function octaveLabel(octave: ActiveOctave): string {
+ * Octavam...". Day 1 shouldn't normally reach either branch (that day's
-  return `${ordinal(octave.dayNumber)} Day within the Octave of ${octave.name}`;
+ * own winner is the feast itself, handled above before this is ever
+ * called) — kept simple rather than special-cased for that rare edge case
+ * (see applyOctaves's own `isOwnStartDay` comment in calendar/index.ts for
+ * when it can happen). Falls back to the English name for `la` too when
+ * the octave's own record has no authored `nameLa` yet (see file header). */
+function octaveCoreName(octave: ActiveOctave): Bi {
+  const name = biName(octave.name, octave.nameLa);
+  return octave.isClosingDay
+    ? bi(`Octave of ${name.en}`, `In Octava ${name.la}`)
+    : bi(`${ordinal(octave.dayNumber)} Day within the Octave of ${name.en}`, `${ordinalLa(octave.dayNumber)} die infra Octavam ${name.la}`);
+}
+
+function octaveLabel(octave: ActiveOctave): Bi {
+  const core = octaveCoreName(octave);
+  const rank = formatRank(octave.wins);
+  return bi(`${core.en} (${rank.en})`, `${core.la} (${rank.la})`);
+}
+
+/** Same phrasing as `octaveLabel`, but without the parenthesized rank —
+ * the real DO commemoration line for a displaced octave day carries no
+ * rank at all (e.g. Aug 19's real Divino Afflatu 1954 commemoration reads
+ * plain "Quinta die infra Octavam S. Assumptionis Beatæ Mariæ Virginis",
+ * no "~ Semiduplex"). `octaveLabel`'s own rank parenthetical only belongs
+ * to an octave day when it's the day's own primary winner (rank is what
+ * it *won as*, not a fact worth restating once a duplex-or-higher saint
+ * has displaced it and it's just riding along as a commemoration
+ * instead). */
+function octaveCommemorationLabel(octave: ActiveOctave): Bi {
+  return octaveCoreName(octave);
+}
+
+/** Real Divino Afflatu phrasing for a commemoration that only exists
+ * because Vespers/Compline crossed a day boundary — "commemoratio de
+ * præcedenti" (today, riding along on tomorrow's anticipated First
+ * Vespers) or "commemoratio de sequenti" (tomorrow, riding along on
+ * today's kept Second Vespers), per horascommon.pl. See
+ * `Commemoration`'s `vespersNote` field (calendar/types.ts) and
+ * calendar/vespers.ts's two `commemorationOfDisplaced*` functions, the
+ * only place that sets it. */
+const CROSS_DAY_VESPERS_LABELS: Record<'today' | 'tomorrow', Bi> = {
+  today: bi('of today', 'de præcedenti'),
+  tomorrow: bi('of tomorrow', 'de sequenti'),
+};
+
+/** Every commemoration on `day`, resolved to display strings and grouped
+ * by kind — the single place that decides both "is this commemoration
+ * eligible to show at all here" and "how is it formatted", so every
+ * caller below shares the same answer instead of each hand-rolling its
+ * own filter/format pass (that duplication is exactly how Aug 19's octave
+ * phrasing, Aug 17's closing-day title, and Aug 16's missing Sunday
+ * commemoration ended up as three separate bugs instead of one). Callers
+ * still decide their own *order* — e.g. the octave-headline branch wants
+ * octaves before a commemorated saint, while a plain Sunday/feria wants a
+ * commemorated saint *before* its own temporal label — since that
+ * ordering reflects a real, deliberate liturgical convention per branch,
+ * not an accident to unify away.
+ *
+ * - `sanctoral`: every commemorated saint, plain name, no rank (multiple
+ *   real ones can coexist — e.g. two colliding saints on the same date —
+ *   this app's own "generous commemorations" design keeps every one of
+ *   them, not just the first). `la` uses the saint's own `nameLa` when
+ *   authored, else falls back to the same English name (see file header).
+ * - `temporal`: the day's own real Sunday/feria identity, if
+ *   `decideOccurrence` demoted it to a commemoration (`ordinary-sunday`/
+ *   `privileged-feria`/`privileged-feria-minor`) — matched by id against
+ *   `resolveTemporalId(day.date)` specifically, not "any temporal-kind
+ *   commemoration present", so unrelated side-notes like
+ *   `applyEpiphany6Commemoration`'s fixed `post-epiphany-6` don't get
+ *   mistaken for it. Rendered via `anchorDayName`/`temporalLabel`, the
+ *   same machinery a primary temporal label uses, minus the rank.
+ * - `octave`: every active octave other than `excludeOctaveId` (the
+ *   octave already serving as the day's own headline, if any) — only
+ *   when `showOctaves` is true. Live-verified this is *not* simply "is an
+ *   octave active": on a Sunday or privileged feria a saint won outright
+ *   against, an unrelated active octave isn't commemorated at all (Aug
+ *   16's St. Joachim names only the Sunday, not St. Lawrence's/the
+ *   Assumption's octaves, even though both are technically active) —
+ *   octaves are only shown on `ordinary-feria` (no real standing of its
+ *   own to prefer instead) or when the octave itself is governing the
+ *   headline. Rendered via `octaveCommemorationLabel` — the "Nth Day
+ *   within the Octave of X" phrasing, no rank.
+ */
+function collectCommemorations(
+  day: LiturgicalDay,
+  opts: { showOctaves: boolean; excludeOctaveId?: string },
+): { sanctoral: Bi[]; temporal: Bi[]; octaves: Bi[] } {
+  const temporalId = resolveTemporalId(day.date);
+  const activeOctaves = opts.showOctaves ? activeOctavesFor(day.date) : [];
+  const sanctoral: Bi[] = [];
+  const temporal: Bi[] = [];
+  const octaves: Bi[] = [];
+  for (const c of day.commemorations) {
+    if (c.kind === 'sanctoral') {
+      const name = biName(c.name, c.nameLa);
+      if (c.vespersNote) {
+        sanctoral.push(bi(`${name.en} (${CROSS_DAY_VESPERS_LABELS[c.vespersNote].en})`, `${name.la} (${CROSS_DAY_VESPERS_LABELS[c.vespersNote].la})`));
+      } else if (c.transferredFrom) {
+        // Same "arrived via transfer, not natively due here" signal as a
+        // transferred-in *winner* gets — a reader shouldn't need to already
+        // know this saint's real date to realize a mere commemoration here
+        // is standing in for a transfer, not this date's own natural
+        // sanctoral standing.
+        sanctoral.push(bi(`${name.en} (${TRANSFERRED_LABEL.en})`, `${name.la} (${TRANSFERRED_LABEL.la})`));
+      } else {
+        sanctoral.push(name);
+      }
+    } else if (c.kind === 'temporal') {
+      // `c.id === temporalId` (the plain governing weekday, e.g. "Saturday
+      // in the 15th week after Trinity") is deliberately never shown here:
+      // this function only ever runs to list *secondary* identities
+      // alongside an already-displayed primary winner (a plain temporal
+      // day that wins outright never reaches `day.commemorations` at all —
+      // its own name is the header itself, via a different branch of
+      // `getDayLabel`). Once something else is already being celebrated,
+      // restating "this is also just the Nth ordinary weekday" tells the
+      // reader nothing they don't already know from the winner+rank shown
+      // — unlike a *named* temporal identity (an Ember day, a vigil), which
+      // genuinely adds information. Not Ember-specific (a 2026-09-05 first
+      // pass wrongly scoped this to "only when an Ember commemoration is
+      // also present" — user, 2026-09-05: "it has nothing to do with
+      // ember-ness"); this plain generic label is dropped unconditionally
+      // whenever it shows up as a mere commemoration, Ember day or not.
+      if (c.id !== temporalId) {
+        const emberName = emberDayLabel(c.id);
+        if (emberName) {
+          temporal.push(emberName);
+        }
+      }
+    } else if (opts.showOctaves && c.id !== opts.excludeOctaveId) {
+      const octave = activeOctaves.find((a) => a.id === c.id);
+      octaves.push(octave ? octaveCommemorationLabel(octave) : biName(c.name, c.nameLa));
+    }
+  }
+  return { sanctoral, temporal, octaves };
+}
+
+const RANK_LABELS: Record<FeastClass, Bi> = {
+  simplex: bi('Simplex', 'Simplex'),
+  vigil: bi('Vigil', 'Vigilia'),
+  semiduplex: bi('Semiduplex', 'Semiduplex'),
+  duplex: bi('Duplex', 'Duplex'),
+  'duplex-majus': bi('Duplex Majus', 'Duplex Majus'),
+  'duplex-2-classis': bi('Duplex II Class', 'Duplex II. Classis'),
+  'duplex-1-classis': bi('Duplex I Class', 'Duplex I. Classis'),
+};
+
+/** The day's own winning saint's rank, parenthesized after their name —
+ * rank was previously shown nowhere in this app's UI at all, for any
+ * saint. Only the day's own *winner* gets this treatment, not every
+ * commemoration, matching the "winner is primary, commemorations are
+ * secondary" distinction this file already draws throughout. */
+function formatRank(rank: FeastClass): Bi {
+  return RANK_LABELS[rank];
+}
+
+/** Sundays/ferias aren't on the `FeastClass` duplex scale at all (that
+ * scale is for feasts), so this is a separate, plain-string lookup rather
+ * than another `formatRank` case — used for the final ordinal-temporal-
+ * label fallback (weekdays, Sundays with no named-feast/anchor-day/octave
+ * standing of their own). Pre-1955, an ordinary Sunday's own rank is
+ * Semiduplex regardless of whether it's additionally "privileged"
+ * (privilege is about resisting supersession, a property of
+ * `temporalCategory`, not a higher spot on the duplex scale) — so both
+ * Sunday categories share one label here. Both "Semiduplex" and "Feria"
+ * are already the real Latin words, so `en`/`la` coincide here too. */
+const TEMPORAL_CATEGORY_RANK_LABELS: Record<TemporalCategory, Bi> = {
+  'ordinary-sunday': bi('Semiduplex', 'Semiduplex'),
+  'privileged-sunday': bi('Semiduplex', 'Semiduplex'),
+  'ordinary-feria': bi('Feria', 'Feria'),
+  'privileged-feria-minor': bi('Feria', 'Feria'),
+  'privileged-feria': bi('Feria', 'Feria'),
+  'privileged-feria-major': bi('Feria', 'Feria'),
+};
+
+/**
+ * Explicit "which Vespers is this" status, for the Vespers hour header —
+ * distinct from `getDayLabel`'s name/rank/commemoration text, which is
+ * silent about *why* a given identity governs tonight (a reader has to
+ * already know, e.g., that St. Zephyrinus falls on tomorrow's date to
+ * realize this evening is anticipating him). Pass the result of
+ * `calendar/vespers.ts`'s `resolveEveningDay`, not a plain `resolveDay`,
+ * plus the originally-requested date — comparing the two directly (rather
+ * than checking `winner.vespersFrom`, which only ever gets set for a
+ * *sanctoral* tomorrow-winner, see `vespers.ts`'s `tagVespersFrom`) is
+ * what makes this correct even when tomorrow's winner is `temporal` (e.g.
+ * an ordinary Sunday winning outright over a merely-commemorated Simplex
+ * saint) — a case `winner.vespersFrom` can never detect since that field
+ * doesn't exist on the temporal variant of `DayWinner` at all.
+ */
+export function getVespersStatusLabel(day: LiturgicalDay, requestedDate: string): Bi {
+  if (day.date !== requestedDate) {
+    return bi('First Vespers (of tomorrow)', 'Vesperæ de sequenti');
+  }
+  return bi('Second Vespers (of today)', 'Vesperæ de hodierno');
+}
+
+/** Appended after a transferred-in winner's name/rank, before any
+ * commemorations — same shape as a rank parenthetical. Distinct wording
+ * from `TRANSFERRED_AWAY_LABEL` below on purpose: this winner's own rank
+ * parenthetical sits right next to it ("St. X (Duplex, transferred)"), so
+ * plain "transferred" already reads as "arrived via transfer" in context —
+ * but on the origin date there's no rank alongside it to anchor that
+ * reading, so the away-note spells out the direction explicitly instead of
+ * relying on that same subtlety a first-time reader wouldn't have. */
+const TRANSFERRED_LABEL = bi('transferred', 'translata');
+
+/** See `TRANSFERRED_LABEL`'s doc comment for why this is worded differently. */
+const TRANSFERRED_AWAY_LABEL = bi('transferred away', 'translata alio');
+
+/** "St. X (transferred away)" note for a date whose own native sanctoral
+ * candidate (`day.transferredAway`) couldn't be kept here — appended after
+ * everything else `getDayLabel` already found for this date's real
+ * winner/commemorations, since the departure is a footnote about a
+ * *different* saint, not part of this date's own identity. Deliberately
+ * names no landing date (see `transferredAway`'s own doc comment) — the
+ * point is just to tell a reader "not an omission, this office moved
+ * elsewhere," not to claim a specific destination that a later, unmodeled
+ * transfer chain could make wrong. */
+function transferredAwayNote(day: LiturgicalDay): Bi | undefined {
+  if (!day.transferredAway) {
+    return undefined;
+  }
+  const name = biName(day.transferredAway.candidate.name, day.transferredAway.candidate.nameLa);
+  return bi(`${name.en} (${TRANSFERRED_AWAY_LABEL.en})`, `${name.la} (${TRANSFERRED_AWAY_LABEL.la})`);
+}
+
+function withTransferNote(day: LiturgicalDay, label: Partial<Record<string, string>>): Partial<Record<string, string>> {
+  const note = transferredAwayNote(day);
+  if (!note) {
+    return label;
+  }
+  return { en: `${label.en} — ${note.en}`, la: `${label.la} — ${note.la}` };
 }
 
 /**
- * The full "day being celebrated" label: a feast name when
+ * The full "day being celebrated" label: the day's own primary identity
- * calendar/commemorations.ts says the day has one, combined with (or
+ * (a sanctoral winner, a named temporal feast, a season's own anchor day,
- * replaced by) the ordinal temporal label depending on whether the feast
+ * an octave governing the day, or the plain ordinal temporal label — in
- * won outright or was merely commemorated. See the plan discussion this
+ * that precedence order) plus whatever `collectCommemorations` finds
- * came from for the three cases.
+ * eligible to ride along with it. Each branch below only decides two
+ * things: what the primary label is, and what commemoration *groups* are
+ * eligible here and in what order — the actual filtering/formatting work
+ * is `collectCommemorations`'s alone, shared by every branch. Returns a
+ * `Partial<Record<string, string>>` keyed by language code (`en`/`la`),
+ * the same convention `hours/types.ts`'s `ResolvedText`/`ResolvedVerse`
+ * already use.
  */
-export function getDayLabel(day: LiturgicalDay): string {
+export function getDayLabel(day: LiturgicalDay): Partial<Record<string, string>> {
   if (day.winner.kind === 'sanctoral') {
-    return day.winner.name;
+    // Octaves only ride along here on `ordinary-feria` — a day with real
+    // standing of its own (a Sunday, a privileged feria) doesn't mention
+    // an unrelated active octave even though it's technically active
+    // (live-verified: Aug 16, 2026, St. Joachim wins outright on a Sunday
+    // that's also within both St. Lawrence's and the Assumption's octave
+    // windows, and Divino Afflatu 1954's own commemoration line names
+    // only the Sunday, no octave).
+    const { sanctoral, temporal, octaves } = collectCommemorations(day, {
+      showOctaves: day.temporalCategory === 'ordinary-feria',
+    });
+    const rank = formatRank(day.winner.rank);
+    const winnerName = biName(day.winner.name, day.winner.nameLa);
+    const winner = day.winner.transferredFrom
+      ? bi(`${winnerName.en} (${rank.en}, ${TRANSFERRED_LABEL.en})`, `${winnerName.la} (${rank.la}, ${TRANSFERRED_LABEL.la})`)
+      : bi(`${winnerName.en} (${rank.en})`, `${winnerName.la} (${rank.la})`);
+    return withTransferNote(day, joinBi([winner, ...temporal, ...sanctoral, ...octaves]));
   }
 
   // A named temporal feast (Christmas, Pentecost, Marian Saturday, ...)
   // shows its own name rather than the ordinal week label — same
   // "winner displaces, doesn't combine" rule a sanctoral winner gets
   // above. Most temporal ids don't have a record at all (see
-  // temporal-feasts.ts) and fall through to the ordinal label as before.
+  // temporal-feasts.ts) and fall through further down.
   const namedFeast = getTemporalFeastRecord(day.winner.id);
   if (namedFeast) {
-    return namedFeast.name;
+    const name = biName(namedFeast.name, namedFeast.nameLa);
+    const primary = namedFeast.rank
+      ? bi(`${name.en} (${formatRank(namedFeast.rank).en})`, `${name.la} (${formatRank(namedFeast.rank).la})`)
+      : name;
+    const { sanctoral } = collectCommemorations(day, { showOctaves: false });
+    return withTransferNote(day, joinBi([primary, ...sanctoral]));
   }
 
-  const commemoratedSaint = day.commemorations.find((c) => c.kind === 'sanctoral');
-
   // A season's own named anchor day (Trinity Sunday, Easter, Ash
   // Wednesday, Epiphany) outranks an active octave, same reasoning as
   // anchorDayName's own doc comment — checked before the octave case
   // below since Trinity Sunday, e.g., also happens to be day 8 of
   // Pentecost's octave, and the anchor name is what actually governs.
+  // Winner first, same as every other branch here — the anchor day is
+  // what's actually being celebrated even when a lesser saint rides along.
   const anchorName = anchorDayName(day);
   if (anchorName) {
-    return commemoratedSaint ? `${commemoratedSaint.name} — ${anchorName}` : anchorName;
+    const { sanctoral } = collectCommemorations(day, { showOctaves: false });
+    return withTransferNote(day, joinBi([anchorName, ...sanctoral]));
   }
 
   // An active octave (St. Lawrence's, ...) is this day's real primary
   // identity in the live engine, not a footnote — e.g. "Tertia die infra
   // Octavam S. Laurentii Martyris", not "Wednesday in the 11th week after
   // Trinity" — but *only* when the temporal day itself has no standing of
-  // its own (`ordinary-feria`), same gate as hours/resolve-common.ts's
+  // its own (`ordinary-feria`), or a foreign octave's own effective rank
+  // is strong enough to clear a privileged day's real threshold anyway
+  // (`octaveGoverningPrivilegedDay` — the Immaculate Conception's own
+  // octave outright winning several of its days against Advent's
+  // privileged-feria-minor ferias, live-verified: Dec 9/10/12/14 at the
+  // octave's ordinary Semiduplex, Dec 15 at its own elevated Duplex majus
+  // closing day). Same gate as hours/resolve-common.ts's
   // resolveOfficeWinner and for the same reason: live-verified
   // counterexample is the Christmas Octave's own stack (Dec 30, e.g.,
   // `privileged-feria-minor`), where the real title stays the temporal
   // Sunday's own ("De Dominica Infra Octavam Nativitatis") with no octave
-  // name in it at all — this label agreeing with resolveOfficeWinner
+  // name in it at all, regardless of rank — `octaveGoverningPrivilegedDay`
-  // about which one wins is what makes "the office is Lawrence's" and
+  // excludes `christmastide` for exactly this reason (see its own doc
-  // "the label says Lawrence" consistent instead of two independent
+  // comment) — this label agreeing with resolveOfficeWinner about which
-  // guesses that can disagree. When more than one octave is active at
+  // one wins is what makes "the office is Lawrence's" and "the label says
-  // once (resolveActiveOctave), the highest-ranked wins the headline
+  // Lawrence" consistent instead of two independent guesses that can
-  // (ties broken by whichever started more recently) — the others still
+  // disagree. When more than one octave is active at once
-  // ride along as ordinary octave commemorations, just not separately
+  // (resolveActiveOctave), the highest-ranked wins the headline (ties
-  // named here.
+  // broken by whichever started more recently) — every other active
-  const activeOctave = day.temporalCategory === 'ordinary-feria' ? resolveActiveOctave(day.date) : undefined;
+  // octave still gets named too, not dropped: live-verified real case,
+  // Aug 17 -- St. Lawrence's own elevated closing day wins the headline,
+  // but the Assumption's own day 3 (a real, distinct, simultaneously-
+  // active octave, not a duplicate of Lawrence's) still belongs in the
+  // label alongside St. Hyacinth's commemoration.
+  const activeOctave =
+    day.temporalCategory === 'ordinary-feria' ? resolveActiveOctave(day.date) : octaveGoverningPrivilegedDay(day);
   if (activeOctave) {
+    const { sanctoral, octaves } = collectCommemorations(day, { showOctaves: true, excludeOctaveId: activeOctave.id });
     const primary = octaveLabel(activeOctave);
-    return commemoratedSaint ? `${primary} — ${commemoratedSaint.name}` : primary;
+    return withTransferNote(day, joinBi([primary, ...octaves, ...sanctoral]));
   }
 
-  const temporal = temporalLabel(day);
+  const temporalRank = TEMPORAL_CATEGORY_RANK_LABELS[day.temporalCategory];
-  return commemoratedSaint ? `${commemoratedSaint.name} — ${temporal}` : temporal;
+  const label = (day.winner.kind === 'temporal' ? emberDayLabel(day.winner.id) : undefined) ?? temporalLabel(day);
+  const temporal = bi(`${label.en} (${temporalRank.en})`, `${label.la} (${temporalRank.la})`);
+  const { sanctoral } = collectCommemorations(day, { showOctaves: false });
+  return withTransferNote(day, joinBi([temporal, ...sanctoral]));
 }

src/calendar/ember-days.ts

@@ -0,0 +1,72 @@
+// Ember days (Quatuor Temporum) are privileged ferias, not named feasts —
+// structurally different from calendar/movable-feasts.ts's rank-contest
+// table. The precedence side (whether an occurring saint outranks the
+// feria) is already handled generically by resolveTemporalCategory
+// (September Ember days get their own `privileged-feria-minor` entry
+// there; Advent Ember days inherit Advent's own season default) feeding
+// the ordinary decideOccurrence contest -- this file ONLY handles content
+// identity: relabeling the day's own temporal id so an Ember day's real,
+// distinct proper content (collect, Matins readings) gets found instead
+// of inheriting whatever Sunday governs that week, the same way
+// applyMarianSaturday/applyChristmasOctaveSunday relabel a feria's own id
+// for the same reason.
+import type { Commemoration, DayWinner } from './types';
+import { septemberEmberDayOffset, adventEmberDayOffset } from './temporal';
+import { activeOctavesFor } from './octaves';
+
+const SEPTEMBER_EMBER_IDS: Record<number, string> = {
+  3: 'ember-september-wednesday',
+  5: 'ember-september-friday',
+  6: 'ember-september-saturday',
+};
+const ADVENT_EMBER_IDS: Record<number, string> = {
+  3: 'ember-advent-wednesday',
+  5: 'ember-advent-friday',
+  6: 'ember-advent-saturday',
+};
+
+function emberIdFor(isoDate: string): string | undefined {
+  const septemberOffset = septemberEmberDayOffset(isoDate);
+  if (septemberOffset !== undefined) {
+    return SEPTEMBER_EMBER_IDS[septemberOffset];
+  }
+  const adventOffset = adventEmberDayOffset(isoDate);
+  if (adventOffset !== undefined) {
+    return ADVENT_EMBER_IDS[adventOffset];
+  }
+  return undefined;
+}
+
+/**
+ * Run after applyOctaves, same gate that function's own doc comment and
+ * applyMarianSaturday both rely on: an active octave (the Nativity of the
+ * BVM's, Sep 8-15, can genuinely overlap a late-anchored September Ember
+ * week in some years) already has real standing of its own and shouldn't
+ * be silently relabeled out from under it.
+ *
+ * Two cases, mirroring how a "Commemoratio ad Laudes tantum" reads
+ * live against the reference engine: if the feria itself is what's
+ * winning (`winner.kind === 'temporal'`, i.e. resolveTemporalCategory's
+ * `privileged-feria-minor` threshold already beat whatever saint was
+ * there, or nothing was there at all), its id is swapped for the Ember
+ * day's own — real content gets found where it wouldn't otherwise be. If
+ * a saint won outright instead (strong enough to clear that threshold),
+ * the winner is left alone but the Ember day is still commemorated
+ * alongside it, so its own collect/readings still surface (this app
+ * doesn't model the "Laudes only" hour-scoping nuance — same simplification
+ * level as every other commemoration here, not a new gap).
+ */
+export function applyEmberDay(isoDate: string, winner: DayWinner, commemorations: Commemoration[]): DayWinner {
+  if (activeOctavesFor(isoDate).length > 0) {
+    return winner;
+  }
+  const emberId = emberIdFor(isoDate);
+  if (!emberId) {
+    return winner;
+  }
+  if (winner.kind === 'temporal') {
+    return { kind: 'temporal', id: emberId };
+  }
+  commemorations.push({ kind: 'temporal', id: emberId });
+  return winner;
+}

src/calendar/feasts.ts

@@ -15,6 +15,9 @@ import sanctoralCalendarData from '../data/calendar/sanctoral-calendar.yml';
 export interface SaintRecord {
   id: string;
   name: string;
+  /** Latin form of `name`, when authored — see calendar/types.ts's
+   * `SanctoralIdentity.nameLa` doc comment for the display fallback. */
+  nameLa?: string;
   rank: FeastClass;
   common: string;
   propers: string | null;
@@ -33,9 +36,95 @@ export interface SaintRecord {
    * minor-hour content (either fully proper, or not yet authored).
    */
   minorHoursCommon?: string;
+  /**
+   * Fallback id for the day collect (`getDayCollect`) when this saint has
+   * no proper collect of their own (`propers` may still be non-null —
+   * e.g. St. Agatha and St. Lucy both have a proper antiphon but a
+   * Common-sourced collect) — the *full* id of a `data/propers/common/
+   * collect-c*.yml` file (e.g. `collect-c2-1`, not `c2-1` — no suffix
+   * gets appended), a *template* with a literal `{N}` standing in for
+   * the saint's own name, substituted via `collectName` below.
+   * Deliberately more granular than `common` above: the reference
+   * source's own Commune files split e.g. "Common of a Martyr Bishop"
+   * into several differently-worded collect templates (its own `C2`,
+   * `C2-1`, `C2a-1`, `C2b`, `C2b-1` — no clean semantic label recovered
+   * for *why* each saint gets a particular one, so these ids trace
+   * straight back to the source's own naming, e.g. `collect-c2-1`,
+   * rather than inventing a name that might be wrong.
+   */
+  collectCommon?: string;
+  /** The `{N}` substitution values for `collectCommon`'s template, in
+   * whatever grammatical case that specific template's own placeholder
+   * position needs — taken directly from the reference source's own
+   * per-saint `[Name]` section (Latin/English/Sancti or SanctiM
+   * `MM-DD.txt`), not re-declined by hand. Arrays, filled in
+   * left-to-right against the template's own `{N}` occurrences in
+   * document order — most saints need exactly one name, but several
+   * Common templates (e.g. `collect-c3`, two co-named Martyr-Bishops)
+   * have two or more `{N}` placeholders for a group commemorated
+   * together, one array entry per saint in the group. */
+  collectName?: { la: string[]; en: string[] };
+  /**
+   * Fallback id for Lauds' Benedictus antiphon (`getBenedictusAntiphon`)
+   * when this saint has no proper `${propers}-antiphon` of their own —
+   * `data/propers/common/benedictus-antiphon-${id}.yml`. Unlike
+   * `collectCommon`, no name-substitution template: live-verified every
+   * Common category's Benedictus antiphon in current use is name-free
+   * text (the source's own `Commune/C4a.txt`, Doctor, is the one
+   * exception — has a `{N}`-shaped "beáte N." — but no saint on this
+   * calendar draws from it yet, so no substitution mechanism was built
+   * for this field; revisit if that changes). Often, but not always, the
+   * same category as `minorHoursCommon` below (both were live-verified
+   * independently per saint, not assumed identical).
+   */
+  benedictusCommon?: string;
+  /**
+   * The `{N}` substitution value(s) for the Matins invitatory antiphon's
+   * own Common template (`hours/matins.ts`'s `resolveMatinsInvitatoryText`,
+   * via `hours/resolve-common.ts`'s `substituteName` — the same helper
+   * `getDayCollect` already uses for `collectCommon`/`collectName`, just a
+   * separate field here since the invitatory's own `{N}` position needs
+   * its own grammatical case, not necessarily the same one `collectName`
+   * was declined for). Currently only needed for Common-of-a-Holy-Woman
+   * (`Commune/C7.txt`'s own `[Invit]`, "Laudémus Deum nostrum * In
+   * confessióne beátæ N.." — genitive singular, e.g. "Marthæ") — every
+   * other Common category in use has name-free invitatory text. Absent
+   * for saints whose Common invitatory antiphon needs no substitution. */
+  invitatoryName?: { la: string[]; en: string[] };
   /** See calendar/types.ts's OctaveConfig doc comment. Absent for the vast
    * majority of saints — only ones with a real octave declare it. */
   octave?: OctaveConfig;
+  /** For a `rank: vigil` record only — the real id of the feast this is
+   * the eve of (e.g. `st-andrew`, not derivable from this record's own id
+   * by stripping a `vigil-of-` prefix: several vigils' ids don't match
+   * their feast's id exactly — `vigil-of-the-assumption` vs `assumption`,
+   * `vigil-of-st-james` vs `st-james-the-greater`). Lets
+   * calendar/vespers.ts's evening-anticipation merge recognize "today's
+   * Vigil is being displaced by the very feast it's the eve of" precisely
+   * (rather than guessing from date adjacency alone) and skip
+   * commemorating the Vigil redundantly alongside its own feast. */
+  vigilOf?: string;
+  /** This feast, when it keeps its own Second Vespers (see
+   * calendar/vespers.ts's keepsOwnSecondVespers), refuses to commemorate
+   * whatever wins the following day there — the feast-side mirror of a
+   * privileged Sunday/major-feria refusing a weak commemoration *back*
+   * (calendar/commemorations.ts), which vu had no equivalent of at all
+   * until this field. Modeled as an explicit per-feast flag rather than
+   * porting the reference engine's fractional-rank privilege matrix
+   * (crank/rank thresholds, a "Festum Domini" distinction, an outright
+   * hardcoded pair exception for Most Precious Blood vs. the Sacred
+   * Heart on the rare late-Easter date they collide) — that matches this
+   * repo's own "explicit per-feast fact, verified against the live
+   * engine one date at a time" convention (same as `vigilOf` above)
+   * rather than a general formula applied blanket and hoped correct.
+   * Absent (the default) preserves today's status quo: any sanctoral
+   * successor gets commemorated regardless of rank. Not yet set on any
+   * saint — add only after checking a specific date against the live
+   * reference engine, not speculatively for every `duplex-1-classis`
+   * feast. NOT a fit for the Precious Blood/Sacred Heart case itself
+   * (that exclusion is specific to one neighbor, not "never commemorate
+   * anyone" — see this field's own doc comment above) — see TODO.md. */
+  forbidsSuccessorCommemoration?: true;
 }
 
 const sanctoralCalendar = sanctoralCalendarData as { days: Record<string, string[]> };
@@ -52,6 +141,7 @@ for (const mod of Object.values(saintModules)) {
 export interface SanctoralCandidate {
   id: string;
   name: string;
+  nameLa?: string;
   rank: FeastClass;
 }
 
@@ -71,6 +161,6 @@ export function getSanctoralCandidatesFor(isoDate: string): SanctoralCandidate[]
     if (!saint) {
       throw new Error(`sanctoral-calendar.yml references unknown saint id '${id}'`);
     }
-    return { id: saint.id, name: saint.name, rank: saint.rank };
+    return { id: saint.id, name: saint.name, nameLa: saint.nameLa, rank: saint.rank };
   });
 }

src/calendar/index.ts

@@ -1,19 +1,25 @@
-import type { Commemoration, DayWinner, LiturgicalDay, SanctoralIdentity, TemporalCategory } from './types';
+import type { Commemoration, DayWinner, FeastClass, LiturgicalDay, SanctoralIdentity, TemporalCategory } from './types';
 import { weekdayOf } from './weekday';
-import { resolveSeason, resolveTemporalCategory, sundayOnOrBefore } from './temporal';
+import { resolveSeason, resolveTemporalCategory, easterOffsetOf } from './temporal';
 import { resolveTemporalId } from './temporal-id';
 import { getSanctoralCandidatesFor } from './feasts';
-import { decideOccurrence, isAtLeast, type OccurrenceResult } from './commemorations';
+import { decideOccurrence, compareFeastClass, isAtLeast, type OccurrenceResult } from './commemorations';
 import { resolveCollision } from './collision';
-import { addDays } from './date-math';
+import { addDays, toIsoDate } from './date-math';
+import { easterSunday } from './easter';
 import { activeOctavesFor, strictestThreshold } from './octaves';
+import { applyMovableFeasts } from './movable-feasts';
+import { applyEmberDay } from './ember-days';
 
 /**
  * A day's occurrence considered on its own — no awareness of what an
- * adjacent day might be trying to transfer in. `resolveDay` calls this for
+ * adjacent day might be trying to transfer in. `resolveDay` calls this
- * the date itself *and* for yesterday/tomorrow (to check for an inbound
+ * for the date itself and for yesterday/tomorrow (to check for an
- * transfer) without ever recursing into their own adjacent-day checks —
+ * inbound transfer) without ever recursing into their own adjacent-day
- * that's what keeps this from being mutually recursive.
+ * checks — that's what keeps this from being mutually recursive. The one
+ * exception, `easterOctaveBacklogFor`, deliberately calls this for up to
+ * 15 fixed days (Palm Sunday through Low Sunday) regardless of `isoDate`
+ * — see its own doc comment.
  */
 function resolveNativeOccurrence(isoDate: string): { temporalCategory: TemporalCategory; result: OccurrenceResult } {
   const weekday = weekdayOf(isoDate);
@@ -34,7 +40,12 @@ function resolveNativeOccurrence(isoDate: string): { temporalCategory: TemporalC
     const collision = resolveCollision(candidate, topCandidate);
     clashCommemorations.push(...collision.commemorations);
     if (collision.winner.kind === 'sanctoral') {
-      topCandidate = { id: collision.winner.id, name: collision.winner.name, rank: collision.winner.rank };
+      topCandidate = {
+        id: collision.winner.id,
+        name: collision.winner.name,
+        nameLa: collision.winner.nameLa,
+        rank: collision.winner.rank,
+      };
     }
   }
 
@@ -48,17 +59,34 @@ function applyIncomingTransfer(
   temporalCategory: TemporalCategory,
   winner: DayWinner,
   commemorations: Commemoration[],
+  fromDate: string,
 ): DayWinner {
   if (temporalCategory === 'privileged-feria-major') {
-    // Deferred: a transfer landing on one of these (the concrete case is
+    // Never a landing spot for any rank, and never even a bare
-    // Holy Week, right after Palm Sunday) needs its own Easter-date-keyed
+    // commemoration (commemorations.ts's own case already guarantees
-    // lookup table, the same way the reference engine handles it — not
+    // this — a `winner.kind === 'sanctoral'` day never actually happens
-    // modeled yet. The transfer is simply not delivered here rather than
+    // in this category, so `decideOccurrence` alone would already
-    // guessed at. The lesser privileged-feria tier doesn't need this —
+    // produce this same no-op; kept explicit as a documented short-
-    // ordinary collision/transfer logic is fine there, same as any
+    // circuit). A candidate impeded here — Holy Week, the Easter Octave,
-    // ordinary-sunday landing.
+    // Low Sunday — doesn't chain forward day-by-day the way an ordinary
+    // transfer does; see `applyEasterOctaveBacklog` in `resolveDay` for
+    // its own dedicated mechanism instead. The lesser privileged-feria
+    // tier doesn't need any of this — ordinary collision/transfer logic
+    // is fine there, same as any ordinary-sunday landing.
     return winner;
   }
+  // Tags the returned winner with where it transferred from, but only when
+  // the candidate actually ended up winning here — a collision loss (the
+  // candidate merely commemorated, incumbent keeps the day) isn't a landing.
+  const tagIfLanded = (result: DayWinner): DayWinner =>
+    result.kind === 'sanctoral' && result.id === candidate.id ? { ...result, transferredFrom: fromDate } : result;
+  // Same tagging, but for the candidate's own *commemoration* — it still
+  // needs marking as arrived-via-transfer even when it lost the landing
+  // day outright (a collision loss, or falling below the landing day's own
+  // threshold in decideOccurrence) rather than merely being naturally due
+  // for commemoration here.
+  const tagCommemorations = (result: Commemoration[]): Commemoration[] =>
+    result.map((c) => (c.kind === 'sanctoral' && c.id === candidate.id ? { ...c, transferredFrom: fromDate } : c));
   if (winner.kind === 'temporal') {
     // Found via real data: a transferred-in Simplex saint was blindly
     // winning outright even when it landed on a privileged Sunday (Trinity
@@ -66,15 +94,84 @@ function applyIncomingTransfer(
     // the *same* precedence rules a native occurrence would have used,
     // not just take over because nothing else was assigned here.
     const decided = decideOccurrence(temporalCategory, winner.id, candidate);
-    commemorations.push(...decided.commemorations);
+    commemorations.push(...tagCommemorations(decided.commemorations));
-    // If the candidate fails here too (decided.transfer set), that's a
+    // If the candidate fails here too (decided.transfer set), it's simply
-    // transfer chain — not modeled, same "not delivered rather than
+    // not delivered — every category reaching this branch only ever
-    // guessed at" stance as the privileged-feria-major case above.
+    // needs a single hop (see `applyEasterOctaveBacklog` for the one
-    return decided.winner;
+    // multi-day case, handled separately, not through here).
+    return tagIfLanded(decided.winner);
   }
   const collision = resolveCollision(candidate, winner);
-  commemorations.push(...collision.commemorations);
+  commemorations.push(...tagCommemorations(collision.commemorations));
-  return collision.winner;
+  return tagIfLanded(collision.winner);
+}
+
+// The minimum rank worth carrying out of the Palm-Sunday-through-Low-
+// Sunday span at all (see `applyEasterOctaveBacklog` below) — anything
+// weaker than this just lapses for the year, same as it already gets no
+// trace *within* the span itself (commemorations.ts's `privileged-feria-
+// major`/`privileged-sunday` cases). Per direct instruction (2026-09-01):
+// this is the same threshold the sibling in-place-commemoration rule
+// used before it was found wrong — that number wasn't the mistake, only
+// which question it was answering.
+const EASTER_OCTAVE_BACKLOG_FLOOR: FeastClass = 'duplex-majus';
+
+/**
+ * Every candidate impeded anywhere from Palm Sunday through Low Sunday
+ * inclusive (`easterOffsetOf` -7 through +7) that clears
+ * `EASTER_OCTAVE_BACKLOG_FLOOR`, in native-date order — the backlog
+ * `applyEasterOctaveBacklog` draws from. Judged only by each day's own
+ * `resolveNativeOccurrence`, never a fully `resolveDay`-resolved one
+ * (same convention `applyIncomingTransfer` already uses).
+ */
+function easterOctaveBacklogFor(year: number): { candidate: SanctoralIdentity; fromDate: string }[] {
+  const easterIso = toIsoDate(easterSunday(year));
+  const backlog: { candidate: SanctoralIdentity; fromDate: string }[] = [];
+  for (let offset = -7; offset <= 7; offset++) {
+    const date = addDays(easterIso, offset);
+    const candidate = resolveNativeOccurrence(date).result.transfer?.candidate;
+    if (candidate && isAtLeast(candidate.rank, EASTER_OCTAVE_BACKLOG_FLOOR)) {
+      backlog.push({ candidate, fromDate: date });
+    }
+  }
+  return backlog;
+}
+
+// Generous headroom over any realistic backlog length (the whole span is
+// 15 days; vu's own calendar has never produced more than a handful of
+// duplex-majus+ candidates in it) — exists purely so a date far removed
+// from any Easter doesn't pay for an `easterOctaveBacklogFor` computation
+// it could never need.
+const MAX_EASTER_OCTAVE_BACKLOG_DAYS = 60;
+
+/**
+ * The Nth day after Low Sunday celebrates the Nth candidate in that
+ * year's backlog (native-date order) — winning outright, no rank fight
+ * against whatever would have natively been there, which is demoted to a
+ * commemoration instead — one candidate per day until the backlog is
+ * exhausted. Per direct instruction (2026-09-01): not a generic multi-day
+ * cascade/queue (this app already has real precedent for stacking
+ * commemorations, so a spread-out cascade wasn't the right shape), and
+ * not a same-day batch either (only one candidate surfaces per day, same
+ * as any other transfer landing in this app) — a fixed, deterministic
+ * position for each backlog candidate rather than a "first day not
+ * already spoken for" search.
+ */
+function applyEasterOctaveBacklog(isoDate: string, winner: DayWinner, commemorations: Commemoration[]): DayWinner {
+  const offset = easterOffsetOf(isoDate);
+  if (offset <= 7 || offset > 7 + MAX_EASTER_OCTAVE_BACKLOG_DAYS) {
+    return winner;
+  }
+  const n = offset - 7;
+  const backlog = easterOctaveBacklogFor(Number(isoDate.slice(0, 4)));
+  const entry = backlog[n - 1];
+  if (!entry) {
+    return winner;
+  }
+  if (winner.kind === 'sanctoral') {
+    commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, nameLa: winner.nameLa, rank: winner.rank });
+  }
+  return { kind: 'sanctoral', ...entry.candidate, transferredFrom: entry.fromDate };
 }
 
 /**
@@ -91,51 +188,104 @@ export function resolveDay(isoDate: string): LiturgicalDay {
   let winner = result.winner;
   const commemorations = [...result.commemorations];
 
-  const yesterday = resolveNativeOccurrence(addDays(isoDate, -1));
+  const yesterdayIso = addDays(isoDate, -1);
-  if (yesterday.result.transfer?.direction === 'forward') {
+  const yesterday = resolveNativeOccurrence(yesterdayIso);
-    winner = applyIncomingTransfer(yesterday.result.transfer.candidate, temporalCategory, winner, commemorations);
+  // A candidate impeded anywhere from Palm Sunday through Low Sunday
+  // (`easterOffsetOf` -7 through +7) is exclusively
+  // `applyEasterOctaveBacklog`'s to place — skipped here so it isn't
+  // *also* picked up by this ordinary single-hop check (real bug found
+  // 2026-09-01: Low Sunday's own transfer was leaking into the very next
+  // day's ordinary yesterday-check, landing/commemorating a candidate
+  // below the backlog's own rank floor). Scoped to that specific span,
+  // not `privileged-sunday` generally — an ordinary privileged Sunday
+  // elsewhere (Advent, Septuagesima–Passiontide) still uses this normal
+  // single-hop path same as before.
+  const yesterdayOffset = easterOffsetOf(yesterdayIso);
+  const yesterdayInEasterSpan = yesterdayOffset >= -7 && yesterdayOffset <= 7;
+  if (yesterday.result.transfer?.direction === 'forward' && !yesterdayInEasterSpan) {
+    winner = applyIncomingTransfer(yesterday.result.transfer.candidate, temporalCategory, winner, commemorations, yesterdayIso);
   }
-  const tomorrow = resolveNativeOccurrence(addDays(isoDate, 1));
+  const tomorrowIso = addDays(isoDate, 1);
+  const tomorrow = resolveNativeOccurrence(tomorrowIso);
   if (tomorrow.result.transfer?.direction === 'backward') {
-    winner = applyIncomingTransfer(tomorrow.result.transfer.candidate, temporalCategory, winner, commemorations);
+    winner = applyIncomingTransfer(tomorrow.result.transfer.candidate, temporalCategory, winner, commemorations, tomorrowIso);
   }
+  // The one case that single yesterday-check can't reach: anything
+  // impeded within Holy Week/Easter Day/the Octave/Low Sunday itself
+  // (all `privileged-feria-major`/`privileged-sunday`, which never
+  // accept a landing at all) needs its own dedicated mechanism — see
+  // `applyEasterOctaveBacklog`'s own doc comment.
+  winner = applyEasterOctaveBacklog(isoDate, winner, commemorations);
 
   winner = applyOctaves(isoDate, winner, commemorations);
+  winner = applyEmberDay(isoDate, winner, commemorations);
   winner = applyMarianSaturday(isoDate, weekday, temporalCategory, winner, commemorations);
-  winner = applyChristTheKing(isoDate, winner, commemorations);
   winner = applyChristmasOctaveSunday(isoDate, weekday, winner, commemorations);
+  winner = applyMovableFeasts(isoDate, winner, commemorations);
+  applyEpiphany6Commemoration(isoDate, commemorations);
+  applyAdventFourVigilCommemoration(isoDate, weekday, commemorations);
 
-  return { date: isoDate, weekday, season, temporalCategory, winner, commemorations };
+  // This date's own native candidate (if any) couldn't be kept here and
-}
+  // moved on instead — see calendar/types.ts's `transferredAway` doc
+  // comment for why this is tracked separately from `Commemoration`, and
+  // why no landing date is recorded.
+  const transferredAway = result.transfer ? { candidate: result.transfer.candidate } : undefined;
 
-/** The Sunday on or before Oct 31 — always lands in October since Oct 31
+  return { date: isoDate, weekday, season, temporalCategory, winner, commemorations, transferredAway };
- * is at most 6 days after the month's last Sunday. */
-function lastSundayOfOctober(year: number): string {
-  return sundayOnOrBefore(`${year}-10-31`);
 }
 
 /**
- * Per direct instruction: the last Sunday of October is always Christ the
+ * Real rubric, confirmed 2026-08: when the 6th Sunday after Epiphany is
- * King, full stop — unlike every other layer in this file, nothing here
+ * bumped by Septuagesima — i.e. only in years where the 5th Sunday after
- * loses gracefully or gets a rank check; whatever was winning (a plain
+ * Epiphany was the last one to actually occur — it's commemorated on the
- * numbered Sunday after Pentecost in every ordinary year, but modeled
+ * Saturday immediately before Septuagesima, on top of whatever else that
- * generally in case a high-ranked sanctoral candidate is ever assigned to
+ * Saturday already resolved to. Distinct from (and doesn't imply) the
- * that date too) is demoted straight to a commemoration. Confirmed live
+ * later "resumed post-Epiphany Sunday" transfer handled in
- * (see data/calendar/temporal-feasts/christ-the-king.yml): Duplex I.
+ * temporal-id.ts's post-Pentecost overflow branch — that one applies to
- * classis, well above anything that could contest it under this
+ * *every* skipped post-Epiphany Sunday, not just VI; this Saturday
- * project's own calendar.
+ * commemoration is VI's alone. Purely additive: no `Commemoration` variant
+ * needed beyond the existing `{ kind: 'temporal' }` one, since
+ * hours/resolve-common.ts's getDayCollects already resolves any temporal
+ * commemoration's own `${id}-collect` for free.
  */
-function applyChristTheKing(isoDate: string, winner: DayWinner, commemorations: Commemoration[]): DayWinner {
+function applyEpiphany6Commemoration(isoDate: string, commemorations: Commemoration[]): void {
   const year = Number(isoDate.slice(0, 4));
-  if (isoDate !== lastSundayOfOctober(year)) {
+  const septuagesimaStart = addDays(toIsoDate(easterSunday(year)), -63);
-    return winner;
+  const saturdayBeforeSeptuagesima = addDays(septuagesimaStart, -1);
+  if (isoDate !== saturdayBeforeSeptuagesima) {
+    return;
   }
-  if (winner.kind === 'temporal') {
+  const lastEpiphanySunday = addDays(septuagesimaStart, -7);
-    commemorations.push({ kind: 'temporal', id: winner.id });
+  if (resolveTemporalId(lastEpiphanySunday) !== 'post-epiphany-5') {
-  } else {
+    return;
-    commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, rank: winner.rank });
+  }
+  commemorations.push({ kind: 'temporal', id: 'post-epiphany-6' });
+}
+
+/**
+ * When Advent 4's own Sunday lands on Dec 24 (its latest possible date),
+ * `resolveTemporalId` already gives that day the Vigil of Christmas's own
+ * identity (`vigil-of-christmas` — collect, Lauds antiphons, Matins Gospel
+ * nocturn), matching the reference engine's own rule that the Vigil's rank
+ * governs. Per direct instruction (2026-08), unlike the reference engine's
+ * own `no commemoratio` for this exact day, Advent 4 itself is still
+ * commemorated here — the Sundays of Advent have real standing of their
+ * own, distinct from an ordinary saint quietly ceding to a Vigil. Purely
+ * additive, same shape as applyEpiphany6Commemoration just above: no new
+ * `Commemoration` variant needed, `getDayCollects` already resolves any
+ * `{ kind: 'temporal' }` commemoration's own `${id}-collect` for free.
+ * `advent-4` is hardcoded rather than recomputed because Dec 24 always
+ * falls at or after Advent's own 4th Sunday by construction (it's the
+ * latest date Advent's 4th Sunday can ever land on).
+ */
+function applyAdventFourVigilCommemoration(
+  isoDate: string,
+  weekday: ReturnType<typeof weekdayOf>,
+  commemorations: Commemoration[],
+): void {
+  if (isoDate.slice(5) === '12-24' && weekday === 'sunday') {
+    commemorations.push({ kind: 'temporal', id: 'advent-4' });
   }
-  return { kind: 'temporal', id: 'christ-the-king' };
 }
 
 /**
@@ -167,6 +317,23 @@ function applyChristmasOctaveSunday(
   const day = Number(dayStr);
 
   if (day >= 26 && day <= 29 && weekday === 'sunday') {
+    // The displaced saint isn't commemorated in place (per this
+    // function's own doc comment, "he reappears in full on Dec 30
+    // instead") — strip the sanctoral commemoration `decideOccurrence`
+    // already pushed for him before this override ran, the same
+    // candidate the Dec 30 branch below will look up again to revive.
+    // Only became reachable once `commemorations.ts`'s `ordinary-sunday`
+    // case started commemorating Semiduplex/Simplex in place instead of
+    // transferring them (see its own doc comment) — before that fix, a
+    // `transfer` signal carried the candidate forward instead of a
+    // commemoration, so there was nothing here to strip.
+    const displaced = getSanctoralCandidatesFor(isoDate)[0];
+    if (displaced) {
+      const idx = commemorations.findIndex((c) => c.kind === 'sanctoral' && c.id === displaced.id);
+      if (idx !== -1) {
+        commemorations.splice(idx, 1);
+      }
+    }
     return { kind: 'temporal', id: 'christmas-octave-sunday' };
   }
 
@@ -190,7 +357,7 @@ function applyChristmasOctaveSunday(
       if (idx !== -1) {
         commemorations.splice(idx, 1);
       }
-      return { kind: 'sanctoral', id: displaced.id, name: displaced.name, rank: displaced.rank };
+      return { kind: 'sanctoral', id: displaced.id, name: displaced.name, nameLa: displaced.nameLa, rank: displaced.rank };
     }
   }
 
@@ -243,7 +410,7 @@ function applyMarianSaturday(
   if (winner.rank !== 'simplex') {
     return winner;
   }
-  commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, rank: winner.rank });
+  commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, nameLa: winner.nameLa, rank: winner.rank });
   return MARIAN_SATURDAY;
 }
 
@@ -251,11 +418,36 @@ function applyMarianSaturday(
  * Layered on top of everything above, not part of it: an octave doesn't
  * change how a single day's own precedence contest is decided, it just
  * (a) adds a commemoration for every octave still active on this date, and
- * (b) occasionally overrides the winner when the occurring saint is too
+ * (b) occasionally overrides the winner when the occurring saint doesn't
- * minor to clear the strictest active octave's threshold, in which case
+ * outrank the strictest active octave's threshold, in which case the day
- * the day reverts to its own temporal identity and the saint is
+ * reverts to its own temporal identity and the saint is commemorated
- * commemorated instead — same "demoted, not dropped" shape as every other
+ * instead — same "demoted, not dropped" shape as every other
  * commemoration rule in this file.
+ *
+ * A *tie against an octave's own elevated closing day* goes to the
+ * octave, not the occurring saint — live-verified counterexample: St.
+ * Hyacinth (plain Duplex, Aug 17) against St. Lawrence's own octave
+ * closing day that same date (also Duplex, via `closingDayRank`'s
+ * default) — the reference engine's own alternate block for that date is
+ * titled "Commemoratio S. Hyacinthi Confessoris", i.e. Hyacinth is the
+ * one merely commemorated there, Lawrence's own elevated closing day
+ * keeps the office. Matches this file's own `collision.ts` precedent for
+ * the analogous sanctoral-vs-sanctoral tie ("Ties favor `native` — the
+ * incoming feast is the guest here"): the closing day is the
+ * already-running incumbent's own elevated day, an occurring saint is
+ * the guest, and a guest needs to actually outrank it to displace it,
+ * not just match it.
+ *
+ * A tie against an *ordinary* (non-closing) octave day's threshold still
+ * favors the occurring saint, unchanged from the original behavior —
+ * confirmed by two already-verified, live-sourced counterexamples this
+ * file's own tests carry: St. Thomas of Canterbury (plain Semiduplex,
+ * Dec 29) wins outright against the Christmas Octave's own ordinary
+ * `wins: semiduplex` default that day (not its closing day, Jan 1), and
+ * St. Nicholas of Tolentino (plain Semiduplex, Sep 10) likewise against
+ * the Nativity of the BVM's octave (day 3 of 8, not closing). Only a
+ * closing day's own elevated rank carries the "already the incumbent"
+ * weight that breaks a tie in the octave's favor.
  */
 function applyOctaves(isoDate: string, winner: DayWinner, commemorations: Commemoration[]): DayWinner {
   const octaves = activeOctavesFor(isoDate);
@@ -264,11 +456,16 @@ function applyOctaves(isoDate: string, winner: DayWinner, commemorations: Commem
   }
 
   let resolvedWinner = winner;
-  if (winner.kind === 'sanctoral' && !isAtLeast(winner.rank, strictestThreshold(octaves))) {
+  if (winner.kind === 'sanctoral') {
-    const isOneOfTheseOctaves = octaves.some((o) => o.id === winner.id);
+    const threshold = strictestThreshold(octaves);
-    if (!isOneOfTheseOctaves) {
+    const cmp = compareFeastClass(winner.rank, threshold);
-      commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, rank: winner.rank });
+    const tiedAgainstClosingDay = cmp === 0 && octaves.some((o) => o.isClosingDay && compareFeastClass(o.wins, threshold) === 0);
-      resolvedWinner = { kind: 'temporal', id: resolveTemporalId(isoDate) };
+    if (cmp < 0 || tiedAgainstClosingDay) {
+      const isOneOfTheseOctaves = octaves.some((o) => o.id === winner.id);
+      if (!isOneOfTheseOctaves) {
+        commemorations.push({ kind: 'sanctoral', id: winner.id, name: winner.name, nameLa: winner.nameLa, rank: winner.rank });
+        resolvedWinner = { kind: 'temporal', id: resolveTemporalId(isoDate) };
+      }
     }
   }
 
@@ -279,7 +476,7 @@ function applyOctaves(isoDate: string, winner: DayWinner, commemorations: Commem
     // again alongside itself would be redundant.
     const isOwnStartDay = octave.dayNumber === 1 && resolvedWinner.kind === 'temporal';
     if (!isSelf && !isOwnStartDay) {
-      commemorations.push({ kind: 'octave', id: octave.id, name: octave.name });
+      commemorations.push({ kind: 'octave', id: octave.id, name: octave.name, nameLa: octave.nameLa });
     }
   }
 
@@ -296,10 +493,11 @@ export function isSundayOrFeast(day: LiturgicalDay): boolean {
   return day.weekday === 'sunday' || day.winner.kind === 'sanctoral';
 }
 
-export { compareFeastClass, isAtLeast, decideOccurrence } from './commemorations';
+export { compareFeastClass, isAtLeast, decideOccurrence, minimumOutrightWinningRank } from './commemorations';
 export { resolveCollision } from './collision';
 export { resolveTemporalId } from './temporal-id';
-export { activeOctavesFor, strictestThreshold, resolveActiveOctave } from './octaves';
+export { monthWeekId } from './month-week-id';
+export { activeOctavesFor, strictestThreshold, resolveActiveOctave, octaveGoverningPrivilegedDay } from './octaves';
 export type { ActiveOctave } from './octaves';
 export type {
   LiturgicalDay,

src/calendar/month-week-id.ts

@@ -0,0 +1,74 @@
+// The reference engine's own "calendar-month/week" Matins-reading identity
+// (e.g. "081" = 1st Sunday of August) — genuinely anchored to the civil
+// calendar, NOT Easter-offset like every other id in temporal-id.ts. Real
+// Nocturn 2 patristic content for the later post-Pentecost Sundays lives
+// in the reference engine's Tempora/<MMN>-0.txt files (August-November),
+// keyed this way, not by post-pentecost-NN — which month/week id governs a
+// given date shifts every year with Easter's date, so there is no fixed
+// post-pentecost-NN <-> month-week correspondence to hard-code. See
+// hours/matins.ts's buildReadingPool, which pools this id's own authored
+// content (data/propers/nocturn-readings/month-week-<id>.yml) alongside
+// the ordinary temporalId-keyed pool, same dual-key precedent as
+// propers/bible-plan.ts's Dec25-Jan13 calendar-date stretch.
+//
+// Ported from DivinumOfficium's own Date.pm::monthday() sub, Tridentine/
+// pre-1955 rubrics (this app's baseline throughout — see
+// calendar/temporal.ts's resolveTemporalCategory and its neighbors for the
+// same choice made elsewhere). Concretely, "pre-1955" here means
+// Date.pm's own $modernstyle flag is false: no 1960-rubric October
+// week-III vanishing (that adjustment is entirely modernstyle-gated, so
+// simply never applies here), and November's backward-from-Advent
+// recount still applies for week > 0 (that part is NOT modernstyle-gated
+// in the source) but its extra "collapse week 1 into week 0" step is
+// skipped (that step *is* modernstyle-only).
+import { addDays, dayOfWeek, daysBetween } from './date-math';
+import { adventStart, sundayOnOrBefore } from './temporal';
+
+/** The Sunday that "counts as" the 1st Sunday of `month` for this
+ * reckoning: the Sunday on-or-before the 1st, unless the 1st falls
+ * Thu-Sat (in which case that partial first week has fewer than 4 days in
+ * `month`, so it's skipped in favor of the following Sunday). */
+function firstSundayOfLiturgicalMonth(year: number, month: number): string {
+  const firstOfMonth = `${year}-${String(month).padStart(2, '0')}-01`;
+  const sunday = sundayOnOrBefore(firstOfMonth);
+  return dayOfWeek(firstOfMonth) >= 4 ? addDays(sunday, 7) : sunday;
+}
+
+/**
+ * `"MMN"` (month, 2 digits; week, 1 digit — e.g. `"081"`), or `undefined`
+ * if `isoDate` falls outside the reckoning's range (before the 1st Sunday
+ * of August, or on/after Advent's start). Only ever non-undefined for
+ * August through the eve of Advent.
+ */
+export function monthWeekId(isoDate: string): string | undefined {
+  const year = Number(isoDate.slice(0, 4));
+  const month = Number(isoDate.slice(5, 7));
+  if (month < 7) return undefined;
+
+  let litMonth = 0;
+  const firstSundays: Partial<Record<number, string>> = {};
+  for (let m = 8; m <= 12; m++) {
+    const firstSunday = firstSundayOfLiturgicalMonth(year, m);
+    firstSundays[m] = firstSunday;
+    if (isoDate >= firstSunday) {
+      litMonth = m;
+    } else {
+      break;
+    }
+  }
+  if (litMonth === 0) return undefined;
+
+  const advent = adventStart(year);
+  if (litMonth > 10 && isoDate >= advent) return undefined;
+
+  let week = Math.floor(daysBetween(firstSundays[litMonth]!, isoDate) / 7);
+
+  // November: renumbered by counting backward from Advent rather than
+  // forward from November's own 1st Sunday, for every week after the
+  // first — real rubric, not modernstyle-gated (see header comment).
+  if (litMonth === 11 && week > 0) {
+    week = 4 - Math.floor((daysBetween(isoDate, advent) - 1) / 7);
+  }
+
+  return `${String(litMonth).padStart(2, '0')}${week + 1}`;
+}

src/calendar/movable-feasts.ts

@@ -0,0 +1,103 @@
+// A generic resolver for feasts whose own date isn't reachable through
+// calendar/temporal-id.ts's ordinary governing-Sunday lookup -- either
+// because the feast itself isn't a Sunday (Immaculate Heart of Mary,
+// Easter+69, always a Saturday), or because its occurrence rule (last
+// Sunday of a month, unconditional) doesn't fit the plain rank-contest
+// every other day goes through (Christ the King).
+//
+// Every entry is just a `data/calendar/temporal-feasts/<id>.yml` file with
+// `rank` and `anchor` set (temporal-feasts.ts's own `movableTemporalFeasts`
+// scans for these) -- adding the next one (an Ember/Rogation day, a
+// Sacred-Heart-family Marian feast, a Lenten Friday devotion, St. Joseph's
+// own Eastertide feast, ...) needs no new function here or in
+// calendar/index.ts, just a new anchor value on that new file.
+//
+// Deliberately doesn't try to cover every movable-date pattern in this
+// codebase: `marian-saturday` (a generic "nothing else assigned" fallback,
+// not date-anchored at all) and `christmas-octave-sunday` (whichever of
+// Dec 26-29 is a Sunday, a fixed-date-*range* search rather than a
+// Nth-Sunday-from-an-anchor one) are structurally different rules and stay
+// as their own small functions in calendar/index.ts.
+import type { Commemoration, DayWinner } from './types';
+import type { MovableAnchor } from './temporal-feasts';
+import { compareFeastClass } from './commemorations';
+import { easterSunday } from './easter';
+import { addDays, toIsoDate } from './date-math';
+import { adventStart, sundayOnOrAfter, sundayOnOrBefore } from './temporal';
+import { movableTemporalFeasts } from './temporal-feasts';
+
+function lastDayOfMonth(year: number, month: number): string {
+  const nextMonthFirst = month === 12 ? toIsoDate({ year: year + 1, month: 1, day: 1 }) : toIsoDate({ year, month: month + 1, day: 1 });
+  return addDays(nextMonthFirst, -1);
+}
+
+/** The Nth Sunday of `month` (`nth: -1` for "last"), or the Nth Sunday
+ * counting from Advent's own start (always a Sunday itself, so "1st
+ * Sunday of Advent" is exactly `adventStart`) -- the two calendar-
+ * anchored kinds share one "count Sundays from an anchor date" shape,
+ * just with a different anchor. `{ kind: 'easter' }` needs no such
+ * counting at all: Easter Sunday is already a known, fixed anchor, so any
+ * day pegged to it (Sunday or weekday alike) is just a direct offset. */
+function dateForAnchor(year: number, anchor: MovableAnchor): string {
+  switch (anchor.kind) {
+    case 'easter':
+      return addDays(toIsoDate(easterSunday(year)), anchor.offset);
+    case 'nth-sunday-of-month': {
+      if (anchor.nth === -1) {
+        return sundayOnOrBefore(lastDayOfMonth(year, anchor.month));
+      }
+      const firstSunday = sundayOnOrAfter(toIsoDate({ year, month: anchor.month, day: 1 }));
+      return addDays(firstSunday, 7 * (anchor.nth - 1));
+    }
+    case 'nth-sunday-of-advent':
+      return addDays(adventStart(year), 7 * (anchor.nth - 1));
+    case 'fixed-date':
+      return toIsoDate({ year, month: anchor.month, day: anchor.day });
+  }
+}
+
+/**
+ * Run last in resolveDay's override chain (see calendar/index.ts) so a
+ * specific named movable feast always supersedes whatever generic default
+ * (marian-saturday, a plain Sunday-of-week id) ran before it.
+ *
+ * Two occurrence rules, per feast: the ordinary one is rank-compared,
+ * commemorate-the-loser (a temporal winner, with no real standing of its
+ * own, is always superseded; a sanctoral winner keeps the day if its own
+ * rank is at least as strong, commemorating the movable feast instead;
+ * otherwise the movable feast wins and the displaced saint is
+ * commemorated) -- same shape applyMarianSaturday already uses. The
+ * `unconditional` rule (Christ the King) skips the rank contest entirely
+ * and always wins, commemorating whatever it displaces regardless of
+ * strength.
+ */
+export function applyMovableFeasts(isoDate: string, winner: DayWinner, commemorations: Commemoration[]): DayWinner {
+  const year = Number(isoDate.slice(0, 4));
+  let resolvedWinner = winner;
+  for (const feast of movableTemporalFeasts()) {
+    if (isoDate !== dateForAnchor(year, feast.anchor!)) {
+      continue;
+    }
+    const FEAST_WINNER: DayWinner = { kind: 'temporal', id: feast.id };
+    if (feast.unconditional) {
+      if (resolvedWinner.kind === 'temporal') {
+        commemorations.push({ kind: 'temporal', id: resolvedWinner.id });
+      } else {
+        commemorations.push({ kind: 'sanctoral', id: resolvedWinner.id, name: resolvedWinner.name, nameLa: resolvedWinner.nameLa, rank: resolvedWinner.rank });
+      }
+      resolvedWinner = FEAST_WINNER;
+      continue;
+    }
+    const rank = feast.rank ?? 'simplex';
+    if (resolvedWinner.kind === 'temporal') {
+      commemorations.push({ kind: 'temporal', id: resolvedWinner.id });
+      resolvedWinner = FEAST_WINNER;
+    } else if (compareFeastClass(resolvedWinner.rank, rank) >= 0) {
+      commemorations.push({ kind: 'temporal', id: feast.id });
+    } else {
+      commemorations.push({ kind: 'sanctoral', id: resolvedWinner.id, name: resolvedWinner.name, nameLa: resolvedWinner.nameLa, rank: resolvedWinner.rank });
+      resolvedWinner = FEAST_WINNER;
+    }
+  }
+  return resolvedWinner;
+}

src/calendar/octaves.ts

@@ -8,15 +8,18 @@
 // contest is decided, it just adds commemorations on top of whatever that
 // contest already produced, and occasionally overrides the winner when a
 // too-minor saint would otherwise have taken the day from it.
-import type { FeastClass, OctaveConfig } from './types';
+import type { FeastClass, LiturgicalDay, OctaveConfig } from './types';
 import { getSanctoralCandidatesFor, getSaintRecord } from './feasts';
 import { getTemporalFeastRecord, temporalFeastIdsStartingOn } from './temporal-feasts';
 import { addDays, daysBetween } from './date-math';
-import { compareFeastClass } from './commemorations';
+import { compareFeastClass, minimumOutrightWinningRank } from './commemorations';
 
 export interface ActiveOctave {
   id: string;
   name: string;
+  /** Latin form of `name`, when authored — see calendar/types.ts's
+   * `SanctoralIdentity.nameLa` doc comment for the display fallback. */
+  nameLa?: string;
   /** This octave's own effective rank *today* — the ordinary `wins`
    * threshold on every day except its own closing day, where it's
    * `closingDayRank` instead (see calendar/types.ts's OctaveConfig).
@@ -27,6 +30,11 @@ export interface ActiveOctave {
   wins: FeastClass;
   /** 1 on the feast's own day, counting up from there. */
   dayNumber: number;
+  /** Whether `dayNumber` is this octave's own final ("in Octava") day —
+   * i.e. whether `wins` above came from `closingDayRank` rather than the
+   * ordinary `wins` config. Used by calendar/index.ts's applyOctaves to
+   * decide which side a *tied* rank favors — see its own doc comment. */
+  isClosingDay: boolean;
 }
 
 const DEFAULT_DAYS = 8;
@@ -44,6 +52,7 @@ function considerCandidate(
   startDate: string,
   id: string,
   name: string,
+  nameLa: string | undefined,
   octave: OctaveConfig | undefined,
 ): void {
   if (!octave?.enabled || seen.has(id)) {
@@ -58,7 +67,7 @@ function considerCandidate(
   const dayNumber = offset + 1;
   const isClosingDay = dayNumber === days;
   const wins = isClosingDay ? (octave.closingDayRank ?? DEFAULT_CLOSING_DAY_RANK) : (octave.wins ?? DEFAULT_WINS);
-  active.push({ id, name, wins, dayNumber });
+  active.push({ id, name, nameLa, wins, dayNumber, isClosingDay });
 }
 
 /** Every octave (sanctoral or temporal) whose window covers `isoDate`,
@@ -75,14 +84,14 @@ export function activeOctavesFor(isoDate: string): ActiveOctave[] {
     for (const candidate of getSanctoralCandidatesFor(candidateDate)) {
       const record = getSaintRecord(candidate.id);
       if (record) {
-        considerCandidate(active, seen, isoDate, candidateDate, record.id, record.name, record.octave);
+        considerCandidate(active, seen, isoDate, candidateDate, record.id, record.name, record.nameLa, record.octave);
       }
     }
 
     for (const feastId of temporalFeastIdsStartingOn(candidateDate)) {
       const record = getTemporalFeastRecord(feastId);
       if (record) {
-        considerCandidate(active, seen, isoDate, candidateDate, record.id, record.name, record.octave);
+        considerCandidate(active, seen, isoDate, candidateDate, record.id, record.name, record.nameLa, record.octave);
       }
     }
   }
@@ -110,11 +119,19 @@ export function strictestThreshold(octaves: ActiveOctave[]): FeastClass {
  *
  * - Highest effective rank (`wins`, already elevated on either octave's
  *   own closing day) wins outright.
- * - Tied rank: the more recently *started* octave wins (smaller
+ * - Tied rank, one of them on its own closing day: the closing day wins
- *   `dayNumber` today) — the reasoning given was that day 1 of a newly
+ *   — its "in Octava" day is the octave's own culminating day, so it
- *   started octave needs to be fully present, which is the whole point
+ *   takes precedence over an ordinary day of an equally-ranked octave
- *   of it starting; the older octave that's already been running is
+ *   even if that other octave started more recently (2026-08 user
- *   commemorated instead, same as any octave that loses this comparison.
+ *   instruction, concrete case: Aug 17, St. Lawrence's own closing day,
+ *   vs. the Assumption's ordinary day 3, both `duplex` once Assumption's
+ *   octave was strengthened — Lawrence's closing day wins).
+ * - Tied rank, neither (or both) on their own closing day: the more
+ *   recently *started* octave wins (smaller `dayNumber` today) — the
+ *   reasoning given was that day 1 of a newly started octave needs to be
+ *   fully present, which is the whole point of it starting; the older
+ *   octave that's already been running is commemorated instead, same as
+ *   any octave that loses this comparison.
  *
  * Undefined when no octave is active at all. Every other active octave
  * still gets commemorated regardless of which one wins here — this
@@ -126,6 +143,46 @@ export function resolveActiveOctave(isoDate: string): ActiveOctave | undefined {
   return pickWinningOctave(activeOctavesFor(isoDate));
 }
 
+/**
+ * Whether an active octave's own effective rank clears the bar a real
+ * sanctoral candidate would need to win `day`'s temporal category outright
+ * — i.e. whether the octave governs the day's content/label even though
+ * no *saint* occurring there was strong enough to (a "foreign" octave
+ * superimposed on a season it doesn't belong to, e.g. the Immaculate
+ * Conception's own octave running Dec 8-15, squarely inside Advent).
+ * Live-verified against Divino Afflatu 1954: Dec 9/10/12/14 (ordinary
+ * octave days, Semiduplex) and Dec 15 (the octave's own elevated closing
+ * day, Duplex majus) all win outright over Advent's own privileged-feria-
+ * minor ferias, exactly the same threshold `decideOccurrence` already
+ * uses for a real Semiduplex+ saint there (St. Nicholas, Dec 6).
+ *
+ * Deliberately excludes `ordinary-feria` (unconditional there already —
+ * any active octave governs regardless of rank, handled separately by
+ * each caller via `resolveActiveOctave` directly) and `christmastide`
+ * (Christmas's own stacked octaves — Christmas, St. Stephen, St. John,
+ * Holy Innocents — are structurally already that season's own temporal
+ * content, not a foreign add-on contesting it the way the Immaculate
+ * Conception's octave contests Advent: live-verified, Dec 30 keeps
+ * "Dominica Infra Octavam Nativitatis" as the real DO title regardless of
+ * actual weekday or which of the four octaves is active, never an octave
+ * name — see calendar/day-label.ts's and hours/resolve-common.ts's own
+ * Dec-30 doc comments for the fuller reasoning already established
+ * there). */
+export function octaveGoverningPrivilegedDay(day: LiturgicalDay): ActiveOctave | undefined {
+  if (day.temporalCategory === 'ordinary-feria' || day.season === 'christmastide') {
+    return undefined;
+  }
+  const minRank = minimumOutrightWinningRank(day.temporalCategory);
+  if (!minRank) {
+    return undefined;
+  }
+  const octave = resolveActiveOctave(day.date);
+  if (octave && compareFeastClass(octave.wins, minRank) >= 0) {
+    return octave;
+  }
+  return undefined;
+}
+
 /** The comparison itself, factored out from resolveActiveOctave so the
  * precedence rule (rank, then recency) is directly unit-testable against
  * synthetic ActiveOctave data — no real equal-rank overlap exists yet in
@@ -142,6 +199,9 @@ export function pickWinningOctave(active: ActiveOctave[]): ActiveOctave | undefi
     if (rankCmp < 0) {
       return best;
     }
+    if (candidate.isClosingDay !== best.isClosingDay) {
+      return candidate.isClosingDay ? candidate : best;
+    }
     return candidate.dayNumber < best.dayNumber ? candidate : best;
   }, undefined);
 }

src/calendar/temporal-feasts.ts

@@ -5,13 +5,58 @@
 // don't need a record at all (they're just collect-text lookups via
 // propers/index.ts's getTemporalProper); this only exists for the ones
 // that do.
-import type { OctaveConfig } from './types';
+import type { FeastClass, OctaveConfig } from './types';
 import { easterOffsetOf } from './temporal';
 
+/** How to compute a movable feast's own date each year, for a feast that
+ * ISN'T itself a Sunday (or, for `unconditional` feasts like Christ the
+ * King, one whose occurrence rule is simpler to express as "always wins
+ * outright" than as an ordinary rank contest) -- see
+ * calendar/movable-feasts.ts, which is the only consumer of this.
+ * `resolveTemporalId`'s own Easter-offset resolution only ever finds one
+ * of the 52 canonical *Sunday* ids (it works by finding the governing
+ * Sunday on-or-before a date, then looking that Sunday's own offset up);
+ * none of these three anchor kinds are reachable through that lookup no
+ * matter what, so they need this separate mechanism instead. A feast
+ * that *is* a Sunday itself (Pentecost) doesn't need this at all -- it's
+ * already covered by the ordinary Sunday lookup, and by
+ * EASTER_OFFSET_STARTS below if it also has an octave to start. */
+export type MovableAnchor =
+  | { kind: 'easter'; offset: number }
+  | { kind: 'nth-sunday-of-month'; month: number; nth: number } // nth: 1-4, or -1 for "last"
+  | { kind: 'nth-sunday-of-advent'; nth: number } // nth: 1-4 (Advent always has exactly 4 Sundays)
+  | { kind: 'fixed-date'; month: number; day: number }; // a plain civil-calendar date, not itself Easter- or Advent-anchored (e.g. the Circumcision, Jan 1)
+
 export interface TemporalFeastRecord {
   id: string;
   name: string;
+  /** Latin form of `name`, when authored — see calendar/types.ts's
+   * `SanctoralIdentity.nameLa` doc comment for the display fallback. */
+  nameLa?: string;
   octave?: OctaveConfig;
+  rank?: FeastClass;
+  anchor?: MovableAnchor;
+  /** Christ the King's own rule: always wins the day outright, no rank
+   * contest at all (see calendar/movable-feasts.ts's applyMovableFeasts) --
+   * every other movable feast instead loses to an equal-or-higher-ranked
+   * sanctoral winner and is commemorated alongside it instead. */
+  unconditional?: boolean;
+  /** The temporal-feast sibling of calendar/feasts.ts's SaintRecord field
+   * of the same name -- see that field's own doc comment for the full
+   * rationale (a feast-side mirror of the day-side privilege
+   * calendar/commemorations.ts already models, deliberately a flag
+   * rather than a ported rank-threshold formula). Set on sacred-heart.yml
+   * specifically -- live source (horascommon.pl, github #4586): on the
+   * rare late-Easter date the movable Feast of the Sacred Heart falls the
+   * day immediately before the fixed Most Precious Blood (July 1), Sacred
+   * Heart's own kept Second Vespers explicitly does *not* commemorate
+   * Precious Blood the next evening ("Vespera de præcedenti; nihil de
+   * sequenti") -- the reverse direction (Precious Blood's own Vespers
+   * commemorating a Sacred Heart that falls *after* it, the other rare
+   * late-Easter arrangement) has no such carve-out in the reference
+   * engine, so this flag is intentionally one-directional, not mirrored
+   * onto most-precious-blood.yml. */
+  forbidsSuccessorCommemoration?: true;
 }
 
 const temporalFeastModules = import.meta.glob<{ default: TemporalFeastRecord }>(
@@ -28,13 +73,29 @@ export function getTemporalFeastRecord(id: string): TemporalFeastRecord | undefi
   return temporalFeastsById.get(id);
 }
 
+/** Every temporal feast record carrying its own `anchor` -- the table
+ * calendar/movable-feasts.ts's applyMovableFeasts scans. Adding a new
+ * movable feast (an Ember/Rogation day, a Sacred-Heart-family Marian
+ * feast, a Lenten Friday devotion, ...) is just a new
+ * `data/calendar/temporal-feasts/<id>.yml` file with `rank` and `anchor`
+ * set -- no new code. */
+export function movableTemporalFeasts(): TemporalFeastRecord[] {
+  return [...temporalFeastsById.values()].filter((f) => f.anchor !== undefined);
+}
+
 /** Fixed-calendar-date starts (MM-DD -> temporal feast id). Only Christmas
  * so far; Epiphany/Candlemas would join here if they ever needed an
  * octave modeled too. */
 const FIXED_DATE_STARTS: [string, string][] = [['12-25', 'christmas-day']];
 
 /** Easter-offset starts (offset -> temporal feast id). */
-const EASTER_OFFSET_STARTS: [number, string][] = [[49, 'pentecost-sunday']];
+const EASTER_OFFSET_STARTS: [number, string][] = [
+  [17, 'patronage-of-st-joseph'],
+  [39, 'ascension'],
+  [49, 'pentecost-sunday'],
+  [60, 'corpus-christi'],
+  [68, 'sacred-heart'],
+];
 
 /** Which temporal feast(s), if any, have their own (day-1) octave start on this date. */
 export function temporalFeastIdsStartingOn(isoDate: string): string[] {

src/calendar/temporal-id.ts

@@ -11,16 +11,23 @@
 // header and propers/index.ts's getTemporalProper for the fuller version
 // of this reasoning.
 //
-// Two known, deliberately unfixed gaps: the ferias between Christmas Day
+// One known, deliberately unfixed gap: the ferias between Christmas Day
 // and the Sunday within its octave, and between Epiphany and its own
 // first Sunday, fall back to that season's first named Sunday a few days
 // early — Christmas Day's and Epiphany's own collects aren't authored as
 // separate temporal-propers entries (only Sunday collects were pulled), so
-// this is a deliberate approximation, not an oversight. Likewise, a real
+// this is a deliberate approximation, not an oversight.
-// overflow year (early Easter, more than 24 weeks between Trinity and
+//
-// Advent) would traditionally reuse the unused post-Epiphany Sundays'
+// Overflow years (Easter early enough that fewer than 6 Sundays after
-// collects for the excess weeks — not modeled; this just clamps at
+// Epiphany occur before Septuagesima cuts in) are handled below: the
-// post-pentecost-24.
+// skipped post-Epiphany Sundays "resume" after Sunday XXIII after
+// Pentecost, in their own numeric order, right before the fixed final
+// Sunday of the year (always Sunday XXIV's own formulary, regardless of
+// how many Sundays actually elapsed since Pentecost). Ported directly
+// from the reference engine's own `getweek()`
+// (DivinumOfficium/Date.pm) — same rubric, same arithmetic (weeks-until-
+// Advent, not a separately-tracked count of skipped Epiphany Sundays);
+// confirmed against that source rather than re-derived by hand.
 import { resolveSeason, sundayOnOrBefore, firstSundayStrictlyAfter, adventStart, easterOffsetOf } from './temporal';
 import { daysBetween } from './date-math';
 
@@ -43,17 +50,52 @@ const EASTER_OFFSET_IDS: [number, string][] = [
   [42, 'sunday-after-ascension'],
   [49, 'pentecost-sunday'],
 ];
-for (let n = 1; n <= 24; n++) {
+// Sundays I-XXII after Pentecost only — XXIII and XXIV are handled by
+// resolvePostPentecost23Plus below, since (unlike I-XXII) which id a given
+// week gets can depend on distance-to-Advent, not just its own offset.
+for (let n = 1; n <= 22; n++) {
   EASTER_OFFSET_IDS.push([56 + 7 * (n - 1), `post-pentecost-${String(n).padStart(2, '0')}`]);
 }
 const EASTER_OFFSET_ID_MAP = new Map(EASTER_OFFSET_IDS);
-const MAX_EASTER_OFFSET = EASTER_OFFSET_IDS[EASTER_OFFSET_IDS.length - 1]![0];
+
-const MAX_EASTER_OFFSET_ID = EASTER_OFFSET_IDS[EASTER_OFFSET_IDS.length - 1]![1];
+/**
+ * A governing Sunday at or beyond Pentecost week XXIII. `pentecostWeek` is
+ * the reference engine's own `$n` (1 = Trinity Sunday, verified against
+ * DivinumOfficium/Date.pm and its Tempora/PentNN file naming).
+ */
+function resolvePostPentecost23Plus(governingSunday: string, year: number, pentecostWeek: number): string {
+  const wdist = Math.floor((daysBetween(governingSunday, adventStart(year)) + 6) / 7);
+  if (wdist < 2) {
+    return 'post-pentecost-24';
+  }
+  if (pentecostWeek === 23) {
+    return 'post-pentecost-23';
+  }
+  return `post-epiphany-${8 - wdist}`;
+}
 
 export function resolveTemporalId(isoDate: string): string {
   const season = resolveSeason(isoDate);
   const year = Number(isoDate.slice(0, 4));
 
+  // The Vigil of Christmas (Dec 24) has its own real proper content
+  // (collect, Lauds antiphons, Matins Gospel+homily nocturn) distinct from
+  // Advent 4's own — see data/propers/temporal/vigil-of-christmas-collect.yml
+  // and data/propers/nocturn-readings/vigil-of-christmas.yml, both
+  // transcribed directly from the reference engine's Sancti/12-24.txt.
+  // Applies even when Dec 24 itself is Advent 4's own Sunday — per direct
+  // instruction (2026-08), the Vigil's own identity (rank/collect/Lauds
+  // antiphons) governs that day too, with Advent 4 folded in as a
+  // commemoration instead (calendar/index.ts's
+  // applyAdventFourVigilCommemoration) rather than the reference engine's
+  // own `no commemoratio` rule. Matins' three-nocturn Sunday psalmody is
+  // unaffected either way — it's driven by `day.weekday`, not by this id
+  // (hours/matins.ts's own `threeNocturns` check), so Advent 4's "Psalmi
+  // Dominica" standing survives this id swap for free.
+  if (isoDate.slice(5) === '12-24') {
+    return 'vigil-of-christmas';
+  }
+
   if (season === 'advent') {
     const start = adventStart(year);
     const n = Math.round(daysBetween(start, sundayOnOrBefore(isoDate)) / 7) + 1;
@@ -78,9 +120,11 @@ export function resolveTemporalId(isoDate: string): string {
   // regardless of which `season` bucket the feria itself falls in (the
   // ferias right after Ash Wednesday genuinely reuse Quinquagesima's
   // collect, crossing what resolveSeason calls two different seasons).
-  const offset = easterOffsetOf(sundayOnOrBefore(isoDate));
+  const governingSunday = sundayOnOrBefore(isoDate);
-  if (offset > MAX_EASTER_OFFSET) {
+  const offset = easterOffsetOf(governingSunday);
-    return MAX_EASTER_OFFSET_ID;
+  const pentecostWeek = Math.round((offset - 49) / 7);
+  if (pentecostWeek >= 23) {
+    return resolvePostPentecost23Plus(governingSunday, year, pentecostWeek);
   }
   return EASTER_OFFSET_ID_MAP.get(offset) ?? 'septuagesima';
 }

src/calendar/temporal.ts

@@ -42,12 +42,21 @@ function fixedDateFor(id: string): { month: number; day: number } {
 const CHRISTMAS = fixedDateFor('christmas-day');
 const EPIPHANY = fixedDateFor('epiphany');
 
+/** The Sunday nearest `isoDate` — ties (exactly 3-4 days either way can't
+ * happen; a week has one middle point, Wednesday, which is always closer
+ * to one side or the other) resolved the usual "nearest" way: on or
+ * before if `isoDate` is Sun-Wed, the next one if Thu-Sat. Shared by
+ * `adventStart` (nearest Nov 30) and calendar/ember-days.ts's own
+ * September Ember anchor (nearest Sept 14). */
+export function nearestSunday(isoDate: string): string {
+  const dow = dayOfWeek(isoDate);
+  const delta = dow <= 3 ? -dow : 7 - dow;
+  return addDays(isoDate, delta);
+}
+
 /** The Sunday nearest Nov 30 (St. Andrew's Day) — Advent's real start rule. */
 export function adventStart(year: number): string {
-  const nov30 = `${year}-11-30`;
+  return nearestSunday(`${year}-11-30`);
-  const dow = dayOfWeek(nov30);
-  const delta = dow <= 3 ? -dow : 7 - dow;
-  return addDays(nov30, delta);
 }
 
 /**
@@ -68,6 +77,15 @@ export function firstSundayStrictlyAfter(isoDate: string): string {
   return addDays(isoDate, dow === 0 ? 7 : 7 - dow);
 }
 
+/** The Sunday on or after `isoDate` — `isoDate` itself, if it's already a
+ * Sunday. Used by calendar/movable-feasts.ts's "Nth Sunday of month"
+ * anchor (the 1st Sunday of a month counts the month's own 1st day if
+ * that's a Sunday, unlike firstSundayStrictlyAfter above). */
+export function sundayOnOrAfter(isoDate: string): string {
+  const dow = dayOfWeek(isoDate);
+  return dow === 0 ? isoDate : addDays(isoDate, 7 - dow);
+}
+
 function seasonFromEasterOffset(offset: number): Season {
   const dayOverride = easterOffsets.days?.[String(offset)];
   if (dayOverride) {
@@ -126,6 +144,53 @@ export function easterOffsetOf(isoDate: string): number {
   return daysBetween(toIsoDate(easterSunday(year)), isoDate);
 }
 
+/** The Sacred Triduum: Maundy/Holy Thursday through Holy Saturday
+ * (inclusive). Doesn't line up with `season` (which resolves this window
+ * to 'passiontide', same as the two weeks before it) — see
+ * hours/marian-antiphon.ts's isCandlemasToHolyWednesday for the same
+ * direct-date-check pattern used for another window `season` can't
+ * represent. Gloria Patri is omitted after psalms only in this narrower
+ * window, not throughout Passiontide/Holy Week generally. */
+export function isInTriduum(isoDate: string): boolean {
+  const offset = easterOffsetOf(isoDate);
+  return offset >= -3 && offset <= -1;
+}
+
+const SEPTEMBER_EMBER_OFFSETS = [3, 5, 6]; // Wed, Fri, Sat after the anchor Sunday
+const ADVENT_EMBER_OFFSETS = [3, 5, 6]; // Wed, Fri, Sat after the 3rd Sunday of Advent
+
+/** The Sunday nearest Sept 14 (Exaltation of the Holy Cross) — anchors
+ * September's Ember days, same "nearest" rule as Advent's own start.
+ * Live-verified (2026, 2019) against the reference engine: genuinely
+ * "nearest," not "3rd Sunday of the calendar month" — those two
+ * computations disagree in some years (e.g. 2025). */
+export function septemberEmberAnchor(year: number): string {
+  return nearestSunday(`${year}-09-14`);
+}
+
+/** Which of September's 3 Ember-day offsets (3/5/6 = Wed/Fri/Sat)
+ * `isoDate` is, if any — shared by resolveTemporalCategory below (the
+ * precedence side: these get `privileged-feria-minor`) and
+ * calendar/ember-days.ts (the content-id side: each gets its own proper
+ * collect/readings instead of inheriting the governing Sunday's). */
+export function septemberEmberDayOffset(isoDate: string): number | undefined {
+  const year = Number(isoDate.slice(0, 4));
+  const anchor = septemberEmberAnchor(year);
+  return SEPTEMBER_EMBER_OFFSETS.find((offset) => addDays(anchor, offset) === isoDate);
+}
+
+/** Which of Advent's 3 Ember-day offsets `isoDate` is, if any. Unlike
+ * September's, this doesn't need its own resolveTemporalCategory entry —
+ * Advent's ordinary `privileged-feria-minor` season default already
+ * covers it (no live evidence found that Advent Ember days need a
+ * stronger tier) — but it still needs its own content id, same as
+ * September's, hence still exported for calendar/ember-days.ts. */
+export function adventEmberDayOffset(isoDate: string): number | undefined {
+  const year = Number(isoDate.slice(0, 4));
+  const thirdAdventSunday = addDays(adventStart(year), 14);
+  return ADVENT_EMBER_OFFSETS.find((offset) => addDays(thirdAdventSunday, offset) === isoDate);
+}
+
 /**
  * A day's precedence category under the temporal cycle alone — see
  * calendar/types.ts's TemporalCategory doc comment and
@@ -137,12 +202,33 @@ export function easterOffsetOf(isoDate: string): number {
  * the Christmas vigil (Dec 24 can land on a Sunday) — and a Sunday's own
  * privileged/ordinary status should win in that case regardless, so
  * Sundays are resolved straight from `bySeason` without consulting the
- * overrides at all.
+ * overrides at all. The deliberate exceptions are Easter Sunday itself
+ * (offset 0) and Low Sunday (offset 7, the Octave's own closing day):
+ * `eastertide`'s own `bySeason` default is `ordinary-sunday` (live-
+ * verified for the *ordinary* Sundays from the 2nd Sunday after Easter
+ * on — see that entry's own comment), but both bookend Sundays of the
+ * Easter Octave need the stronger `privileged-sunday` tier instead.
+ * Easter Day: live-verified 2026-09-01, the Annunciation (Duplex I.
+ * classis) transfers off it in years they coincide, the same "transfers,
+ * no exception" behavior as every other privileged-sunday case. Low
+ * Sunday: not independently collision-verified (no Monastic-track saint
+ * — `SanctiM/MM-DD.txt` — ever falls there across the real range of
+ * Easter dates, so no live test case exists), but its own formal rank in
+ * the reference source ("Dominica in Albis in Octava Paschæ ~ Duplex I.
+ * classis") matches Easter Day's own exactly, and no `Transfer:` note
+ * ever shows there even for a same-named non-Monastic-track saint
+ * (St. Isidore of Seville, 2027; St. Vincent Ferrer, 2043) that a real
+ * Monastic-track day would display — treated the same as Easter Day on
+ * that basis. Both checked directly here rather than via `offsets`,
+ * since offsets are never consulted for a Sunday.
  */
 export function resolveTemporalCategory(isoDate: string, season: Season, weekday: Weekday): TemporalCategory {
   const bySeasonEntry = temporalCategories.bySeason[season];
   const base = bySeasonEntry ? (weekday === 'sunday' ? bySeasonEntry.sunday : bySeasonEntry.feria) : 'ordinary-feria';
   if (weekday === 'sunday') {
+    if (season === 'eastertide' && [0, 7].includes(easterOffsetOf(isoDate))) {
+      return 'privileged-sunday';
+    }
     return base;
   }
 
@@ -151,6 +237,15 @@ export function resolveTemporalCategory(isoDate: string, season: Season, weekday
     return fixedOverride;
   }
 
+  // September Ember days: live-verified privileged-feria-minor (Ss.
+  // Cornelius & Cyprian, Semiduplex, won outright there with the feria
+  // demoted to a commemoration) — see septemberEmberDayOffset's own doc
+  // comment for why this can't be expressed as a plain Easter offset or
+  // fixed MM-DD the way every other override in this function is.
+  if (septemberEmberDayOffset(isoDate) !== undefined) {
+    return 'privileged-feria-minor';
+  }
+
   const offset = easterOffsetOf(isoDate);
 
   const singleOverride = temporalCategories.offsets?.[String(offset)];

src/calendar/types.ts

@@ -76,12 +76,16 @@ export type FeastClass =
 // 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
+// (behaves like `privileged-sunday`: never displaced, and — corrected
-// checking St. Mark, Duplex II. classis, merely commemorated rather than
+// 2026-09-01 — never gets even a bare commemoration at any rank either;
-// winning within the Easter Octave). See data/calendar/temporal-
+// an earlier claim that a duplex-majus+ candidate is "merely commemorated"
-// categories.yml for exactly which days fall in which tier — some of that
+// there, citing St. Mark within the Easter Octave, turned out to be a
-// split (e.g. whether Pentecost's own Ember days share Lent's lesser tier
+// misreading — direct instruction confirmed nothing is ever commemorated
-// or Easter's major one) is still a reconstructed guess, not verified.
+// anywhere from Palm Sunday through Low Sunday, and live-checking Ash
+// Wednesday found the same). 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.
 // `privileged-feria-minor` is a third, weaker tier, added during the
 // December sanctoral pull after finding Advent's own ordinary (non-Ember)
 // ferias have real standing of their own in the live engine — a Simplex
@@ -103,6 +107,11 @@ export type TemporalCategory =
 export interface SanctoralIdentity {
   id: string;
   name: string;
+  /** Latin form of `name`, when authored (see `data/calendar/saints/*.yml`'s
+   * own `nameLa` field). Absent for the majority of saints still — display
+   * code falls back to `name` itself when this is missing, same "surface
+   * real text rather than block on missing" convention used elsewhere. */
+  nameLa?: string;
   rank: FeastClass;
 }
 
@@ -156,6 +165,12 @@ export type DayWinner =
       // First Vespers is being anticipated this evening (i.e. this feast
       // belongs to *tomorrow*, but is winning tonight's Vespers/Compline).
       vespersFrom?: 'firstVespersOfTomorrow';
+      // Set by calendar/index.ts's resolveDay/applyIncomingTransfer when
+      // this winner is only here because its own native date (an adjacent
+      // ISO date) couldn't hold it (calendar/commemorations.ts's
+      // `decideOccurrence` `transfer` signal) — the ISO date it transferred
+      // *from*. Absent for a feast winning on its own native date.
+      transferredFrom?: string;
     } & SanctoralIdentity);
 
 /**
@@ -168,8 +183,27 @@ export type DayWinner =
  */
 export type Commemoration =
   | { kind: 'temporal'; id: string }
-  | ({ kind: 'sanctoral' } & SanctoralIdentity)
+  | ({
-  | { kind: 'octave'; id: string; name: string };
+      kind: 'sanctoral';
+      // Set by calendar/vespers.ts's resolveEveningDay when this
+      // commemoration exists only because Vespers/Compline crossed a day
+      // boundary (First Vespers anticipation, or a kept Second Vespers
+      // still noting the displaced neighbor) — 'today' for the real
+      // Divino Afflatu "commemoratio de præcedenti" case, 'tomorrow' for
+      // "commemoratio de sequenti". Left unset for an ordinary same-day
+      // commemoration (a real collision, an octave day, etc.), which
+      // carries no such qualifier.
+      vespersNote?: 'today' | 'tomorrow';
+      // Set by calendar/index.ts's applyIncomingTransfer, same meaning as
+      // `DayWinner`'s own `transferredFrom` — this saint is only
+      // commemorated here (rather than absent) because a transfer landed
+      // on this date and lost a collision, or fell below the landing
+      // day's own outright-winning threshold, not because it's natively
+      // due for commemoration here. Absent for an ordinary same-day
+      // commemoration.
+      transferredFrom?: string;
+    } & SanctoralIdentity)
+  | { kind: 'octave'; id: string; name: string; nameLa?: string };
 
 export interface LiturgicalDay {
   /** ISO date, e.g. "2026-08-09" */
@@ -183,4 +217,20 @@ export interface LiturgicalDay {
   winner: DayWinner;
   /** Everything else commemorated alongside the winner — see the doc comment on Commemoration. */
   commemorations: Commemoration[];
+  /** Set when this date's own native sanctoral candidate couldn't be kept
+   * here at all (calendar/commemorations.ts's `decideOccurrence` `transfer`
+   * signal) and moved to a later/earlier date instead. No landing date is
+   * recorded here — this exists purely so the display can say "not an
+   * omission, this office moved elsewhere" without needing the caller to
+   * separately go find where; the actual landing date is discoverable
+   * from the landing day's own winner/commemoration, tagged with
+   * `transferredFrom`. An ordinary transfer (calendar/index.ts's
+   * `applyIncomingTransfer`, called from `resolveDay`) only ever needs
+   * the immediately adjacent day; anything impeded within Holy Week/the
+   * Easter Octave/Low Sunday goes through the separate, dedicated
+   * `applyEasterOctaveBacklog` mechanism instead, which can place a
+   * candidate many days later. Distinct from — and not implied by —
+   * `Commemoration`, since a transferred-away
+   * candidate gets no commemoration on its own native date at all. */
+  transferredAway?: { candidate: SanctoralIdentity };
 }

src/calendar/vespers.ts

@@ -8,11 +8,13 @@
 // Same reconstruction caveat as commemorations.ts/temporal-categories.yml:
 // best-effort, not sourced from a primary text for this era, expect
 // corrections.
-import type { LiturgicalDay } from './types';
+import type { Commemoration, DayWinner, LiturgicalDay } from './types';
 import { resolveDay } from './index';
 import { addDays } from './date-math';
 import { easterOffsetOf } from './temporal';
-import { isAtLeast } from './commemorations';
+import { compareFeastClass, isAtLeast } from './commemorations';
+import { getSaintRecord } from './feasts';
+import { getTemporalFeastRecord } from './temporal-feasts';
 
 /**
  * Fixed/movable "feasts of the Lord" load-bearing elsewhere in this app
@@ -37,28 +39,153 @@ function hasFirstVespers(day: LiturgicalDay): boolean {
   if (day.weekday === 'sunday' || isMajorFixedFeastOfTheLord(day.date)) {
     return true;
   }
-  return day.winner.kind === 'sanctoral' && isAtLeast(day.winner.rank, 'duplex-majus');
+  // Live-verified (2026-08): Ss. Cyriacus/Largus/Smaragdus (Aug 8, plain
+  // Semiduplex) claims First Vespers over St. Donatus's Aug 7 — "Vespera
+  // de sequenti" in the real Monastic 1617 engine. Originally thought
+  // Semiduplex was the actual cutoff, but re-verified 2026-08-25: St.
+  // Zephyrinus (Aug 26, plain Simplex) likewise claims First Vespers over
+  // St. Louis's Aug 25 (also Simplex) — "Vespera de sequenti; nihil de
+  // præcedenti" — so *any* real sanctoral winner, however low-ranked,
+  // clears this bar; there's no rank floor at all, only the separate
+  // keepsOwnSecondVespers question of whether the day *before* it
+  // outranks the claim. Every FeastClass (including `vigil`, untested
+  // directly but the same "lowest tier" logic) now qualifies.
+  return day.winner.kind === 'sanctoral';
 }
 
-/** Does this day keep its own Second Vespers regardless of what tomorrow is? */
+/** Does this day keep its own Second Vespers regardless of what tomorrow is,
+ * independent of any comparison against tomorrow's rank? Covers only the
+ * *absolute* cases — Sunday, a privileged feria, or a major fixed feast of
+ * the Lord. The ordinary sanctoral-vs-sanctoral case is decided separately,
+ * by direct rank comparison (see `resolveEveningDay`) rather than a fixed
+ * floor here: this function used to also require the winner be at least
+ * `duplex-2-classis`, but that's the wrong rule — the real "De Concurrentia
+ * Officii" rubric (divinum-officium-reference's rubrics.txt, Titulus XI)
+ * compares today's rank against tomorrow's directly, with ties going to
+ * tomorrow, not a fixed threshold on today alone. That floor produced a
+ * wrong result for 2026-08-31 -> 09-01: St. Raymond Nonnatus (Semiduplex,
+ * below the floor) lost his own Second Vespers to St. Giles (Simplex) even
+ * though Raymond outranks Giles. */
 function keepsOwnSecondVespers(day: LiturgicalDay): boolean {
-  if (
+  return (
     day.weekday === 'sunday' ||
     day.temporalCategory === 'privileged-feria-minor' ||
     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');
 }
 
-function anticipated(tomorrow: LiturgicalDay): LiturgicalDay {
+/**
-  if (tomorrow.winner.kind === 'sanctoral') {
+ * Today lost the evening to tomorrow's First Vespers — is today still
-    return { ...tomorrow, winner: { ...tomorrow.winner, vespersFrom: 'firstVespersOfTomorrow' } };
+ * commemorated there? Not if it's Simplex (or a bare temporal winner,
+ * with no standing of its own — same "no standing to defend" idea
+ * commemorations.ts's `ordinary-feria` case already uses during the
+ * day). Live-verified:
+ *   - Aug 8 -> 9 (Ss. Cyriaci/Largi/Smaragdi, Semiduplex, before an
+ *     ordinary Sunday): today loses the evening, today is still
+ *     commemorated ("commemoratio de præcedenti").
+ *   - Aug 7 -> 8 (St. Donatus, Simplex, before Ss. Cyriaci/etc.): today
+ *     loses the evening and is *not* commemorated ("nihil de
+ *     præcedenti") — pins down the Simplex exclusion specifically for
+ *     this direction.
+ */
+function commemorationOfDisplacedPredecessor(loser: DayWinner): Commemoration | undefined {
+  if (loser.kind !== 'sanctoral' || loser.rank === 'simplex') {
+    return undefined;
   }
-  return tomorrow;
+  return { kind: 'sanctoral', id: loser.id, name: loser.name, nameLa: loser.nameLa, rank: loser.rank, vespersNote: 'today' };
+}
+
+/**
+ * Today keeps its own Second Vespers regardless — is tomorrow still
+ * commemorated there? Unlike the reverse direction above, Simplex is
+ * NOT excluded here: live-verified Aug 24 -> 25 (St. Bartholomew,
+ * Duplex II. classis, keeps his own evening; St. Louis, Simplex, on
+ * Aug 25) still reads "commemoratio de sequenti" — the same asymmetry
+ * this file's earlier version only guessed at by symmetry with the
+ * other direction and flagged as unverified. Also verified with a
+ * non-Simplex loser: Jul 25 -> 26 (St. James, Duplex II. classis, kept
+ * second Vespers regardless; St. Anne, Duplex, loses the evening but is
+ * still commemorated).
+ *
+ * `winner` (today's own, the one actually keeping this evening) can
+ * refuse the commemoration outright via its own record's
+ * `forbidsSuccessorCommemoration` — the feast-side mirror of the
+ * day-side privilege calendar/commemorations.ts already models (see that
+ * field's own doc comment, on both SaintRecord and TemporalFeastRecord,
+ * for why this is a flag rather than a rank threshold). Checked on
+ * whichever kind of record `winner` actually is — set today only on
+ * `sacred-heart` (a `temporal` winner), the live-verified case that
+ * motivated this field; every sanctoral saint is still unset, a no-op
+ * until a specific date is verified and flagged.
+ */
+function commemorationOfDisplacedSuccessor(winner: DayWinner, loser: DayWinner): Commemoration | undefined {
+  if (loser.kind !== 'sanctoral') {
+    return undefined;
+  }
+  const forbids =
+    winner.kind === 'sanctoral' ? getSaintRecord(winner.id)?.forbidsSuccessorCommemoration : getTemporalFeastRecord(winner.id)?.forbidsSuccessorCommemoration;
+  if (forbids) {
+    return undefined;
+  }
+  return { kind: 'sanctoral', id: loser.id, name: loser.name, nameLa: loser.nameLa, rank: loser.rank, vespersNote: 'tomorrow' };
+}
+
+function tagVespersFrom(tomorrow: LiturgicalDay): LiturgicalDay {
+  if (tomorrow.winner.kind !== 'sanctoral') {
+    return tomorrow;
+  }
+  return { ...tomorrow, winner: { ...tomorrow.winner, vespersFrom: 'firstVespersOfTomorrow' } };
+}
+
+/** Today's own Vigil isn't commemorated alongside the very feast it's the
+ * eve of — e.g. Nov 29's Vigil of St. Andrew shouldn't also show up next
+ * to St. Andrew himself once this evening has already adopted his First
+ * Vespers, whether St. Andrew governs it outright or is merely
+ * commemorated there himself (2025-11-30: he's only commemorated under
+ * Advent I, a `privileged-sunday`, per commemorations.ts's own threshold
+ * — the Vigil would otherwise show up redundantly alongside him even
+ * though neither one is tomorrow's actual winner). Matched via each
+ * Vigil's own explicit `vigilOf` field (calendar/feasts.ts's
+ * `SaintRecord`) against tomorrow's winner *and* its commemorations, not
+ * date adjacency or name-guessing — several vigils' own ids don't map
+ * cleanly to their feast's id (`vigil-of-the-assumption` vs `assumption`,
+ * `vigil-of-st-james` vs `st-james-the-greater`), so this needs the
+ * explicit link. Scoped to this evening-anticipation merge specifically,
+ * not `commemorationOfDisplacedPredecessor` itself — the reverse direction
+ * (`keepsOwnSecondVespers`, commemorating *tomorrow's* Vigil while today
+ * keeps its own Vespers) can't hit this collision: a Vigil dated tomorrow
+ * belongs to a feast the day after tomorrow, never today. */
+function isVigilOfTomorrow(today: LiturgicalDay, tomorrow: LiturgicalDay): boolean {
+  if (today.winner.kind !== 'sanctoral' || today.winner.rank !== 'vigil') {
+    return false;
+  }
+  const feastId = getSaintRecord(today.winner.id)?.vigilOf;
+  if (!feastId) {
+    return false;
+  }
+  return (
+    (tomorrow.winner.kind === 'sanctoral' && tomorrow.winner.id === feastId) ||
+    tomorrow.commemorations.some((c) => c.kind === 'sanctoral' && c.id === feastId)
+  );
+}
+
+/** The ordinary anticipation path: tag tomorrow's identity, then layer in
+ * today's commemoration if it's eligible (see
+ * commemorationOfDisplacedPredecessor). Not used by the
+ * isMajorFixedFeastOfTheLord override below — whether Christmas/
+ * Easter/etc. commemorate the day they're displacing is a separate,
+ * unverified question (these may well suppress it the way
+ * privileged-sunday/privileged-feria-major do during the day — see
+ * commemorations.ts), so it deliberately doesn't inherit this behavior. */
+function anticipated(today: LiturgicalDay, tomorrow: LiturgicalDay): LiturgicalDay {
+  const tagged = tagVespersFrom(tomorrow);
+  const commemoration = isVigilOfTomorrow(today, tomorrow) ? undefined : commemorationOfDisplacedPredecessor(today.winner);
+  if (!commemoration) {
+    return tagged;
+  }
+  return { ...tagged, commemorations: [...tagged.commemorations, commemoration] };
 }
 
 /**
@@ -67,7 +194,12 @@ function anticipated(tomorrow: LiturgicalDay): LiturgicalDay {
  * Vespers *and* today doesn't keep its own Second Vespers regardless — in
  * which case returns tomorrow's `LiturgicalDay`, with `vespersFrom:
  * 'firstVespersOfTomorrow'` set on its winner (if sanctoral) so callers
- * can tell the difference from an ordinary day.
+ * can tell the difference from an ordinary day. Either way, whichever side
+ * doesn't govern the evening is folded into the returned day's own
+ * `commemorations` when it's eligible (see
+ * commemorationOfDisplacedPredecessor/-Successor) — except under the
+ * isMajorFixedFeastOfTheLord override just below, which doesn't apply
+ * that at all yet.
  *
  * One deliberate absolute exception, caught by a failing test: a day on
  * `isMajorFixedFeastOfTheLord`'s list always wins tomorrow's Vespers,
@@ -77,19 +209,50 @@ function anticipated(tomorrow: LiturgicalDay): LiturgicalDay {
  * would likewise displace an actual Sunday if one ever landed on Dec 24 or
  * an Ember Saturday. This is why it's a short, explicit list rather than a
  * threshold: these particular days are understood to be *absolute*.
+ *
+ * When neither side is covered by an absolute case and both today and
+ * tomorrow have a real sanctoral winner, the rubric's actual rule applies:
+ * direct rank comparison, with today keeping its own Second Vespers only if
+ * it *strictly* outranks tomorrow — an exact tie goes to tomorrow ("a
+ * Capitulo fit de sequenti cum commemoratione praecedentis"). Note this
+ * checks tomorrow's actual *winner*, not merely whether tomorrow's calendar
+ * weekday is Sunday — a plain Duplex can itself outright win an ordinary
+ * Sunday's daytime office (see commemorations.ts's header comment, e.g. St.
+ * Anne beating an ordinary Sunday on 2026-07-26), in which case it's that
+ * Duplex's own rank being compared, not some notion of "Sunday's rank".
+ * When tomorrow's winner is genuinely the Sunday itself (`kind !==
+ * 'sanctoral'`), today's sufficiently high sanctoral rank
+ * (`duplex-2-classis`+) still claims the evening outright per the rubric's
+ * "Duplex always keeps both Vespers" rule — handled by the
+ * `isAtLeast`-style fallback below, same floor as before, just no longer
+ * applied when tomorrow also has a real (comparable) sanctoral winner.
  */
 export function resolveEveningDay(isoDate: string): LiturgicalDay {
   const today = resolveDay(isoDate);
   const tomorrow = resolveDay(addDays(isoDate, 1));
 
   if (isMajorFixedFeastOfTheLord(tomorrow.date)) {
-    return anticipated(tomorrow);
+    return tagVespersFrom(tomorrow);
   }
+
+  let todayWins: boolean;
   if (keepsOwnSecondVespers(today)) {
-    return today;
+    todayWins = true;
+  } else if (today.winner.kind === 'sanctoral' && tomorrow.winner.kind === 'sanctoral') {
+    todayWins = compareFeastClass(today.winner.rank, tomorrow.winner.rank) > 0;
+  } else if (today.winner.kind === 'sanctoral' && isAtLeast(today.winner.rank, 'duplex-2-classis')) {
+    todayWins = true;
+  } else {
+    todayWins = !hasFirstVespers(tomorrow);
   }
-  if (!hasFirstVespers(tomorrow)) {
+
-    return today;
+  if (todayWins) {
+    // Today wins outright, but tomorrow is still commemorated here as
+    // long as it's a real sanctoral winner — see
+    // commemorationOfDisplacedSuccessor's own doc comment for why this
+    // direction doesn't exclude Simplex the way the reverse one does.
+    const commemoration = commemorationOfDisplacedSuccessor(today.winner, tomorrow.winner);
+    return commemoration ? { ...today, commemorations: [...today.commemorations, commemoration] } : today;
   }
-  return anticipated(tomorrow);
+  return anticipated(today, tomorrow);
 }

src/data/calendar/saints/all-saints-of-the-benedictine-order.yml

@@ -11,6 +11,7 @@
 # is correct.
 id: all-saints-of-the-benedictine-order
 name: "All Saints of the Order of St. Benedict"
+nameLa: "Omnes Sancti Ordinis Sancti Benedicti"
 rank: duplex-2-classis
 common: proper-to-all-saints
-propers: null
+propers: "all-saints-of-the-benedictine-order"

src/data/calendar/saints/all-saints.yml

@@ -5,6 +5,7 @@
 # was sourced).
 id: all-saints
 name: "All Saints"
+nameLa: "Omnes Sancti"
 rank: duplex-1-classis
 common: proper-to-all-saints
 propers: "all-saints"

src/data/calendar/saints/annunciation.yml

@@ -0,0 +1,15 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/03-25.txt` -- "In Annuntiatione
+# Beatæ Mariæ Virginis;;Duplex I classis;;6.92;;ex C11". Own proper
+# [Oratio]/[Ant 1]/Nocturn 2-3 content of her own (real, unique text
+# throughout), not a bare Common fallback -- same pattern as
+# our-lady-of-the-snows.yml's siblings (assumption, immaculate-
+# conception, nativity-bvm). One of the four "fixed BVM feast, excluded
+# per the usual convention" items literally named alongside Purification
+# in this app's original stale exclusion note.
+id: annunciation
+name: "The Annunciation of the Blessed Virgin Mary"
+nameLa: "Annuntiatio Beatæ Mariæ Virginis"
+rank: duplex-1-classis
+common: common-of-the-bvm
+propers: "annunciation"

src/data/calendar/saints/apparition-of-st-michael.yml

@@ -6,6 +6,7 @@
 # collect and antiphon.
 id: apparition-of-st-michael
 name: "The Apparition of St. Michael the Archangel"
+nameLa: "Apparitio Sancti Michaelis Archangeli"
 rank: duplex-majus
 common: common-of-an-angel
 propers: "apparition-of-st-michael"

src/data/calendar/saints/apparition-of-the-immaculate-bvm.yml

@@ -0,0 +1,14 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/02-11.txt` -- "In Apparitione
+# Beatæ Mariæ Virginis Immaculatæ;;Duplex majus;;4;;ex C11" (Our Lady of
+# Lourdes). Own proper [Oratio]/[Ant 1]/Nocturn 2 vita (the Bernadette
+# apparition narrative); her Nocturn 3 is a direct `@Sancti/12-10bmv`
+# cross-reference -- shares content with the 3rd day within the Octave
+# of the Immaculate Conception (a different reading than
+# immaculate-conception.yml's own Dec 8 Nocturn 2 content).
+id: apparition-of-the-immaculate-bvm
+name: "The Apparition of the Immaculate Blessed Virgin Mary (Our Lady of Lourdes)"
+nameLa: "Apparitio Immaculatæ Beatæ Mariæ Virginis"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: "apparition-of-the-immaculate-bvm"

src/data/calendar/saints/assumption.yml

@@ -6,9 +6,21 @@
 # specific block) rather than plain text, so left unpulled this pass.
 id: assumption
 name: "The Assumption of the Blessed Virgin Mary"
+nameLa: "Assumptio Beatæ Mariæ Virginis"
 rank: duplex-1-classis
 common: common-of-the-bvm
 propers: "assumption"
 # Has a real octave (Aug 15-22) -- see calendar/types.ts's OctaveConfig.
+# Strengthened to `wins: duplex` (2026-08 user decision), same pattern
+# as pentecost-sunday.yml's own override -- a Semiduplex saint no
+# longer just ties (and, by the ordinary-day tie rule, wins) an
+# ordinary octave day here; it loses outright to the octave instead.
+# Concrete motivation: st-john-eudes.yml's demotion to Semiduplex only
+# actually cedes Aug 19 to the octave because of this. Side effect
+# accepted by the user: st-damasus.yml (Dec 11, Immaculate Conception's
+# octave) and st-nicholas-of-tolentino.yml (Sep 10, Nativity of the
+# BVM's octave) are unrelated octaves not touched by this change, so
+# they're unaffected -- this only strengthens Assumption's own octave.
 octave:
   enabled: true
+  wins: duplex

src/data/calendar/saints/chair-of-st-peter-at-antioch.yml

@@ -5,6 +5,7 @@
 # identical text to Rome's, both intentionally duplicated rather than shared.
 id: chair-of-st-peter-at-antioch
 name: "The Chair of St. Peter at Antioch"
+nameLa: "Cathedra Sancti Petri Antiochiæ"
 rank: duplex-majus
 common: common-of-an-apostle
 propers: "chair-of-st-peter-at-antioch"

src/data/calendar/saints/chair-of-st-peter-at-rome.yml

@@ -8,6 +8,7 @@
 # since both Chair feasts share it).
 id: chair-of-st-peter-at-rome
 name: "The Chair of St. Peter at Rome"
+nameLa: "Cathedra Sancti Petri Romæ"
 rank: duplex-majus
 common: common-of-an-apostle
 propers: "chair-of-st-peter-at-rome"

src/data/calendar/saints/commemoration-of-st-paul.yml

@@ -5,6 +5,12 @@
 # as its own record. Own proper collect and antiphon.
 id: commemoration-of-st-paul
 name: "Commemoration of St. Paul, Apostle"
+nameLa: "Commemoratio Sancti Pauli Apostoli"
 rank: duplex
 common: common-of-an-apostle
 propers: "commemoration-of-st-paul"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-30.txt) --
+# [Rule]/[Rank] point to Commune/C1 instead, the same C-number family already
+# live-query-verified for common-of-apostles.yml (see TODO.md's 'minor hour
+# content gaps' section).
+minorHoursCommon: common-of-apostles

src/data/calendar/saints/conversion-of-st-paul.yml

@@ -3,6 +3,7 @@
 # proper collect and antiphon.
 id: conversion-of-st-paul
 name: "The Conversion of St. Paul, Apostle"
+nameLa: "Conversio Sancti Pauli Apostoli"
 rank: duplex-majus
 common: common-of-an-apostle
 propers: "conversion-of-st-paul"

src/data/calendar/saints/decollation-of-st-john-baptist.yml

@@ -2,12 +2,15 @@
 # kalendar check (2025-08-29) -- winner outright, Duplex, over the stub
 # St. Sabina (see st-sabina.yml). About St. John the Baptist's beheading,
 # not a feast of the Lord/BVM, so kept in scope like his Nativity in June.
-# "common-of-an-apostle" is a loose fit (he isn't one) but the closest
-# existing category to "a major male saint honored with his own high
-# feast" -- same judgment call as nativity-of-st-john-the-baptist.yml.
 # Own proper collect and antiphon.
 id: decollation-of-st-john-baptist
 name: "The Beheading of St. John the Baptist"
+nameLa: "Decollatio Sancti Joannis Baptistæ"
 rank: duplex
-common: common-of-an-apostle
+common: common-of-a-martyr
 propers: "decollation-of-st-john-baptist"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (08-29.txt) --
+# [Rule]/[Rank] point to Commune/C2a instead, the same C-number family
+# already live-query-verified for common-of-a-martyr.yml (see TODO.md's
+# 'minor hour content gaps' section).
+minorHoursCommon: common-of-a-martyr

src/data/calendar/saints/dedication-of-the-basilica-of-the-most-holy-savior.yml

@@ -0,0 +1,30 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/11-09.txt` -- "In
+# Dedicatione Archibasilicæ Ss. Salvatoris;;Duplex II. classis;;5;;ex C8".
+# Previously excluded entirely under a stale "fixed feast of the Lord,
+# not modeled" note in sanctoral-calendar.yml's own November comment --
+# wrong, same class of error as our-lady-of-the-snows.yml: she has real,
+# unique Lectio1-6(+6a) content of her own (the history of the Lateran
+# basilica's dedication under Pope St. Sylvester, through its later
+# restorations), and her `ex C8` Rule just means her collect/antiphon/
+# Nocturn-3-Gospel-and-homily come from the existing Common of a
+# Dedication (`collect-c8.yml`, `benedictus-antiphon-common-of-a-
+# dedication.yml` -- already authored, reused directly here, not
+# duplicated) -- the same Common already used by
+# dedication-of-the-basilicas-of-ss-peter-and-paul.yml.
+id: dedication-of-the-basilica-of-the-most-holy-savior
+name: "Dedication of the Basilica of the Most Holy Savior (the Lateran)"
+nameLa: "Dedicatio Basilicæ Sanctissimi Salvatoris"
+rank: duplex-2-classis
+common: common-of-a-dedication
+propers: null
+collectCommon: collect-c8
+# collect-c8's own text has no {N} placeholder to substitute (it's about
+# the building, not a saint) -- collectName is still required by
+# getDayCollect's own lookup, but its value is never actually used.
+collectName:
+  la: []
+  en: []
+minorHoursCommon: common-of-a-dedication
+benedictusCommon: common-of-a-dedication

src/data/calendar/saints/dedication-of-the-basilicas-of-ss-peter-and-paul.yml

@@ -8,6 +8,13 @@
 # file at this MM-DD slot (Sancti/11-18.txt) is empty.
 id: dedication-of-the-basilicas-of-ss-peter-and-paul
 name: "Dedication of the Basilicas of Ss. Peter and Paul"
+nameLa: "Dedicatio Basilicarum Sanctorum Petri et Pauli Apostolorum"
 rank: duplex
 common: common-of-an-apostle
 propers: null
+collectCommon: collect-c8
+collectName:
+  la: []
+  en: []
+minorHoursCommon: common-of-a-dedication
+benedictusCommon: common-of-a-dedication

src/data/calendar/saints/exaltation-of-the-holy-cross.yml

@@ -0,0 +1,21 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/09-14.txt` -- "In
+# Exaltatione Sanctæ Crucis;;Duplex majus;;4;;ex Sancti/05-03". Previously
+# excluded entirely under a stale "fixed feast of the Lord, same
+# convention as the Finding of the Holy Cross" note in
+# sanctoral-calendar.yml's own September comment -- wrong, same class of
+# error, now fixed alongside it (see finding-of-the-holy-cross.yml). Her
+# own [Rule] is `ex Sancti/05-03` -- she reuses the Finding of the Holy
+# Cross's content wholesale, so `propers` points at that saint's own
+# collect/antiphon files directly rather than duplicating them (same
+# cross-id-reuse pattern as st-michael.yml's `apparition-of-st-michael`).
+# The Matins nocturn-readings mechanism has no equivalent cross-id
+# lookup, so exaltation-of-the-holy-cross.yml duplicates
+# finding-of-the-holy-cross.yml's own reading content instead.
+id: exaltation-of-the-holy-cross
+name: "The Exaltation of the Holy Cross"
+nameLa: "Exaltatio Sanctæ Crucis"
+rank: duplex-majus
+common: proper-to-the-finding-of-the-holy-cross
+propers: "finding-of-the-holy-cross"

src/data/calendar/saints/finding-of-st-stephen.yml

@@ -13,6 +13,11 @@
 # Dec 26 antiphon reused verbatim, no substitution this time.
 id: finding-of-st-stephen
 name: "The Finding of St. Stephen, Protomartyr"
+nameLa: "Inventio Sancti Stephani Protomartyris"
 rank: semiduplex
 common: common-of-a-martyr
 propers: "finding-of-st-stephen"
+# P/T/S/N: [Rule] points directly at st-stephen-protomartyr's own file
+# (Sancti/12-26), not a Commune category -- reuses his own already-authored
+# proper P/T/S/N wholesale (see TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: st-stephen-protomartyr

src/data/calendar/saints/finding-of-the-holy-cross.yml

@@ -0,0 +1,19 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/05-03.txt` --
+# "Inventione Sanctæ Crucis;;Duplex II classis;;5.2;;". Previously
+# excluded entirely under a stale "fixed feast of the Lord, not modeled"
+# note in sanctoral-calendar.yml's own May comment -- wrong, same class
+# of error as our-lady-of-the-snows.yml: her [Rule] says `proprium` -- a
+# fully proper feast with real, complete unique text throughout
+# (collect, antiphon, 8 Matins lessons -- the file itself has no
+# Lectio9 at all, an unusual but genuine structural feature, not an
+# omission on this app's part). `Sancti/09-14.txt`'s Exaltation of the
+# Holy Cross reuses this same content wholesale (`ex Sancti/05-03`) --
+# see exaltation-of-the-holy-cross.yml.
+id: finding-of-the-holy-cross
+name: "The Finding of the Holy Cross"
+nameLa: "Inventio Sanctæ Crucis"
+rank: duplex-2-classis
+common: proper-to-the-finding-of-the-holy-cross
+propers: "finding-of-the-holy-cross"

src/data/calendar/saints/forty-holy-martyrs.yml

@@ -3,6 +3,12 @@
 # Own proper collect, no unique antiphon of their own.
 id: forty-holy-martyrs
 name: "The Forty Holy Martyrs"
+nameLa: "Quadraginta Sancti Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: "forty-holy-martyrs"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (03-10.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/guardian-angels.yml

@@ -0,0 +1,14 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/10-02.txt` -- "Duplex majus;;4;;
+# vide C4" (Common of a Confessor Bishop -- structural category only;
+# the feast's own content is fully proper throughout). Own real
+# [Oratio] and own [Ant 1]. Own Nocturn 2-3 content (Nocturn 2: St.
+# Bernard's own homily on Psalm 90 "Qui habitat"; Nocturn 3: St.
+# Hilary's own homily, Gospel bare incipit). Nocturn 1 (Lectio1-3,
+# scripture) not modeled per this app's established convention.
+id: guardian-angels
+name: "The Guardian Angels"
+nameLa: "Sancti Angeli Custodes"
+rank: duplex-majus
+common: common-of-an-angel
+propers: "guardian-angels"

src/data/calendar/saints/holy-innocents.yml

@@ -6,6 +6,7 @@
 # this pull has found. Own proper collect and antiphon.
 id: holy-innocents
 name: "The Holy Innocents, Martyrs"
+nameLa: "Sancti Innocentes, Martyres"
 rank: duplex-2-classis
 common: common-of-several-martyrs
 propers: "holy-innocents"

src/data/calendar/saints/holy-name-of-mary.yml

@@ -0,0 +1,16 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/09-12.txt` -- "S. Nominis
+# Beatæ Mariæ Virginis;;Duplex majus;;4;;ex C11". Own real [Oratio]
+# and own untagged [Ant 1] (shared verbatim with our-lady-of-mount-
+# carmel-antiphon.yml -- a coincidental reuse of the same formulaic
+# BVM-commemoration text already present in the reference source
+# itself, not a copy-paste error introduced here). Own Nocturn 2-3
+# content (Nocturn 3 is St. Peter Chrysologus's own homily on the
+# Annunciation, not a cross-reference). Instituted 1683 by Innocent XI
+# after the relief of Vienna.
+id: holy-name-of-mary
+name: "The Holy Name of the Blessed Virgin Mary"
+nameLa: "Sanctissimum Nomen Mariæ"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: "holy-name-of-mary"

src/data/calendar/saints/immaculate-conception.yml

@@ -4,10 +4,17 @@
 # collect and antiphon.
 id: immaculate-conception
 name: "The Immaculate Conception of the Blessed Virgin Mary"
+nameLa: "Immaculata Conceptio Beatæ Mariæ Virginis"
 rank: duplex-1-classis
 common: common-of-the-bvm
 propers: "immaculate-conception"
 minorHoursCommon: common-of-the-bvm
 # Has a real octave (Dec 8-15) -- see calendar/types.ts's OctaveConfig.
+# Strengthened to `wins: duplex` (2026-08 user decision), same pattern
+# as pentecost-sunday.yml's and assumption.yml's own overrides. Side
+# effect accepted by the user: St. Damasus (Dec 11, semiduplex) no
+# longer ties and wins an ordinary octave day here -- he now loses
+# outright to the octave instead (see st-damasus.yml).
 octave:
   enabled: true
+  wins: duplex

src/data/calendar/saints/maternity-of-the-bvm.yml

@@ -0,0 +1,14 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/10-11.txt` -- "Maternitatis
+# Beatæ Mariæ Virginis;;Duplex 2 classis;;5.1;;ex C11". Own real
+# [Oratio] and own [Ant 1]. Own Nocturn 2-3 content (Nocturn 2: two
+# excerpts from Pope St. Leo the Great's own Nativity sermons; Nocturn
+# 3: St. Bernard's own homily, Gospel bare incipit). Instituted 1931 by
+# Pius XI for the 1500th anniversary of the Council of Ephesus (see the
+# feast's own Lectio6, quoted in nocturn-readings).
+id: maternity-of-the-bvm
+name: "The Maternity of the Blessed Virgin Mary"
+nameLa: "Maternitas Beatæ Mariæ Virginis"
+rank: duplex-2-classis
+common: common-of-the-bvm
+propers: "maternity-of-the-bvm"

src/data/calendar/saints/most-precious-blood.yml

@@ -0,0 +1,15 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/07-01.txt` -- "Duplex I
+# classis;;6;;" (`[Rule]` says `proprium` -- "Festum Domini"). A fully
+# proper feast of the Lord with real, complete unique text throughout
+# (own Oratio, own Ant 1, full 9-lesson Matins), same pattern as
+# transfiguration.yml/finding-of-the-holy-cross.yml. Instituted by Pius
+# IX in 1849, raised to Duplex I Classis by Pius XI for the 1933
+# nineteen-century jubilee of the Redemption (see the feast's own
+# Lectio6, quoted in nocturn-readings).
+id: most-precious-blood
+name: "The Most Precious Blood of Our Lord Jesus Christ"
+nameLa: "Pretiosissimus Sanguis Domini Nostri Jesu Christi"
+rank: duplex-1-classis
+common: proper-to-the-most-precious-blood
+propers: "most-precious-blood"

src/data/calendar/saints/nativity-bvm.yml

@@ -5,10 +5,18 @@
 # wins outright over the stub St. Hadrian (see st-hadrian.yml).
 id: nativity-bvm
 name: "The Nativity of the Blessed Virgin Mary"
+nameLa: "Nativitas Beatæ Mariæ Virginis"
 rank: duplex-2-classis
 common: common-of-the-bvm
 propers: "nativity-bvm"
 minorHoursCommon: common-of-the-bvm
 # Has a real octave (Sep 8-15) -- see calendar/types.ts's OctaveConfig.
+# Strengthened to `wins: duplex` (2026-08 user decision), same pattern
+# as pentecost-sunday.yml's and assumption.yml's own overrides. Side
+# effect accepted by the user: St. Nicholas of Tolentino (Sep 10,
+# semiduplex) no longer ties and wins an ordinary octave day here -- he
+# now loses outright to the octave instead (see
+# st-nicholas-of-tolentino.yml).
 octave:
   enabled: true
+  wins: duplex

src/data/calendar/saints/nativity-of-st-john-the-baptist.yml

@@ -3,12 +3,22 @@
 # classis, the highest rank pulled in this set. About St. John the
 # Baptist's own nativity, not a feast of the Lord/BVM, so kept in the
 # sanctoral store like the Conversion of St. Paul/Chair-of-Peter feasts
-# despite the very high rank. Own proper collect and antiphon. "common-
+# despite the very high rank. Own proper collect and antiphon.
-# of-an-apostle" is a loose fit (he isn't one) but the closest existing
+#
-# category to "a major male saint honored with his own high feast" --
+# `common: common-of-an-apostle` is a placeholder, not a liturgical
-# worth reconsidering if a more precise category becomes worth adding.
+# claim -- the reference engine assigns this feast no Commune at all
+# (every [Rule] line in Sancti/06-24.txt and SanctiM/06-24.txt points to
+# proper text, never a Commune category), so no better-fitting id exists
+# either. Now verified-inert: every part this field could ever be
+# consulted for (Matins invitatory/hymn/Nocturn psalmody, Vespers
+# psalmody, the Lauds/Vespers bundle, Benedictus antiphon, collect, all
+# four minor hours) has its own real proper text authored, so this field
+# is never actually reached by any resolver (see
+# data/hours/matins-psalmody-overrides/saints/nativity-of-st-john-the-baptist.yml's
+# own comment).
 id: nativity-of-st-john-the-baptist
 name: "The Nativity of St. John the Baptist"
+nameLa: "Nativitas Sancti Joannis Baptistæ"
 rank: duplex-1-classis
 common: common-of-an-apostle
 propers: "nativity-of-st-john-the-baptist"

src/data/calendar/saints/octave-of-all-saints.yml

@@ -0,0 +1,19 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/11-08.txt` -- "In Octava Omnium
+# Sanctorum;;Duplex majus;;4.1;;vide Sancti/11-01" (cross-references
+# All Saints' own file for Rank/Rule). No [Oratio] at all in this
+# file, unlike octave-of-ss-peter-and-paul.yml -- collect reuses All
+# Saints' own real proper collect via the cross-id `propers` pointer
+# (same reasoning as the Finding/Exaltation of the Holy Cross and
+# Gabriel/Raphael Archangel pattern). But this day does have genuine
+# own Nocturn 2-3 content (St. Cyprian's "De mortalitate", St.
+# Augustine's homily on the Beatitudes) -- see
+# nocturn-readings/octave-of-all-saints.yml, since the Matins
+# nocturn-readings mechanism has no cross-id lookup the way
+# collect/antiphon do.
+id: octave-of-all-saints
+name: "The Octave Day of All Saints"
+nameLa: "Octava Omnium Sanctorum"
+rank: duplex-majus
+common: proper-to-all-saints
+propers: "all-saints"

src/data/calendar/saints/octave-of-ss-peter-and-paul.yml

@@ -0,0 +1,24 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/07-06.txt` -- "In Octava Ss.
+# Apostolorum Petri et Pauli;;Duplex majus;;4.1;;vide C1" (Common of
+# Apostles). The Octave Day itself of Ss. Peter and Paul (June 29 + 7),
+# with its own real proper [Oratio] and own Nocturn 2-3 content
+# (Chrysostom's sermon on both Apostles; Jerome's homily on Christ
+# walking on the water). Its [Ant 1]/[Ant 2]/[Ant 3] are all a
+# cross-reference (`@Sancti/07-03oct`) to the file for the Octave's
+# 5th day, which has its own real proper antiphon text -- authored
+# here directly since it is the actual text this day uses, not a
+# private duplicate (the Matins nocturn-readings mechanism has no
+# cross-id lookup the way collect/antiphon do via `propers`, so this
+# mirrors the same reasoning as exaltation-of-the-holy-cross.yml's
+# collect/antiphon pointer, just inlined since there's no saint id to
+# point at here). Rest of the Octave's own continuation days (July 4,
+# 7-8 minus named saints) aren't modeled -- pure octave-continuation
+# content remains a separate, not-yet-built mechanism (see
+# vu-sanctoral-sweep-progress memory).
+id: octave-of-ss-peter-and-paul
+name: "The Octave Day of Ss. Peter and Paul, Apostles"
+nameLa: "Octava Sanctorum Petri et Pauli, Apostolorum"
+rank: duplex-majus
+common: common-of-apostles
+propers: "octave-of-ss-peter-and-paul"

src/data/calendar/saints/our-lady-of-guadalupe.yml

@@ -0,0 +1,16 @@
+# Read directly from the reference engine: Sancti/12-12n.txt --
+# "Beatæ Mariæ Virginis de Guadalupe;;Duplex;;3;;vide C11" (Common of
+# the BVM), the same rank family and `n` (national-calendar) sourcing as
+# apparition-of-the-immaculate-bvm.yml (Our Lady of Lourdes, Feb 11) --
+# not a canonization so the late-canonization deflation rule doesn't
+# apply; the cultus itself is old enough for the project's period
+# (Benedict XIV confirmed it 1754, Pius X named her Patroness of Latin
+# America). Own proper Oratio and [Ant 1], same scope as the Lourdes
+# feast -- no separate Vespers/Lauds antiphon set transcribed, Common of
+# the BVM (C11) carries the rest when she wins outright.
+id: our-lady-of-guadalupe
+name: "Our Lady of Guadalupe"
+nameLa: "Beata Maria Virgo de Guadalupe"
+rank: duplex
+common: common-of-the-bvm
+propers: "our-lady-of-guadalupe"

src/data/calendar/saints/our-lady-of-mount-carmel.yml

@@ -0,0 +1,16 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/07-16.txt` -- "In
+# Commemoratione Beatæ Mariæ Virgine de Monte Carmelo;;Duplex majus;;
+# 4;;ex C11". Own real [Oratio] and own untagged [Ant 1] ("Sancta
+# María, succúrre míseris..." -- a separate `(rubrica cisterciensis)`
+# variant cross-references `@CommuneCist/C11` instead, ignored per the
+# untagged-block convention). Own Nocturn 2 vita content. No Lectio7-9
+# in her own file (only a `Responsory7` cross-ref) -- defers to the
+# Common of the BVM's own Nocturn 3, not transcribed here, same pattern
+# as our-lady-of-the-snows.yml/presentation-of-the-bvm.yml.
+id: our-lady-of-mount-carmel
+name: "Our Lady of Mount Carmel"
+nameLa: "Beata Maria Virgo de Monte Carmelo"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: "our-lady-of-mount-carmel"

src/data/calendar/saints/our-lady-of-ransom.yml

@@ -0,0 +1,13 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/09-24.txt` -- "Beatæ Mariæ
+# Virginis de Mercede;;Duplex majus;;4;;ex C11". Own real [Oratio].
+# No [Ant 1] of her own in this file -- benedictusCommon falls back to
+# the plain Common of the BVM. No Lectio7-9 -- defers to the Common's
+# own Nocturn 3, not transcribed here.
+id: our-lady-of-ransom
+name: "Our Lady of Ransom"
+nameLa: "Beata Maria Virgo de Mercede"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: "our-lady-of-ransom"
+benedictusCommon: common-of-the-bvm

src/data/calendar/saints/our-lady-of-the-snows.yml

@@ -0,0 +1,32 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/08-05.txt` --
+# "Sanctæ Mariæ Virginis ad Nives;;Duplex majus;;4;;ex C11". Previously
+# excluded from this app's calendar entirely under a stale "fixed BVM
+# feasts aren't modeled" note in sanctoral-calendar.yml's own August
+# comment -- wrong: this app already models three other fixed BVM feasts
+# the same way (assumption, immaculate-conception, nativity-bvm), and
+# this one has real, complete content too (Matins readings, sourced
+# directly; collect/antiphon via the Common-of-the-BVM fallback her own
+# `[Rule]` already points to, `ex C11` -- see collect-c11.yml and
+# benedictus-antiphon-common-of-the-bvm.yml). No `propers` of her own:
+# unlike the other three BVM feasts (each of which has real unique
+# collect/antiphon text), her file has none, so `collectCommon`/
+# `benedictusCommon` is the correct mechanism here, same as any other
+# `propers: null` saint falling back to a shared Common.
+id: our-lady-of-the-snows
+name: "Our Lady of the Snows (Dedication of St. Mary Major)"
+nameLa: "Dedicatio Sanctæ Mariæ ad Nives"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: null
+collectCommon: collect-c11
+# collect-c11's own text has no {N} placeholder to substitute (it
+# addresses "fámulis tuis" generically, not the saint by name) --
+# collectName is still required by getDayCollect's own lookup, but its
+# value is never actually used for this particular Common.
+collectName:
+  la: []
+  en: []
+minorHoursCommon: common-of-the-bvm
+benedictusCommon: common-of-the-bvm

src/data/calendar/saints/presentation-of-the-bvm.yml

@@ -0,0 +1,25 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/11-21.txt` -- "In
+# Præsentatione Beatæ Mariæ Virginis;;Duplex majus;;4;;ex C11". Previously
+# excluded entirely under a stale "fixed BVM feast, excluded per the
+# usual convention" note in sanctoral-calendar.yml's own November comment
+# -- wrong, same class of error as our-lady-of-the-snows.yml. Unlike her,
+# this feast DOES have a real, unique [Oratio] of its own (see
+# presentation-of-the-bvm-collect.yml) and Nocturn 2 vita content
+# (Lectio4-6, St. John Damascene + St. Ambrose on the Blessed Virgin).
+# Her [Ant 1] is a substituted Common text (`@Commune/C10:Ant 2_`, with a
+# truncate-and-add-alleluia edit specific to this feast -- see
+# presentation-of-the-bvm-antiphon.yml), effectively proper by the same
+# "own [Name]/edit makes shared-formula text proper" reasoning as
+# st-lucy-collect.yml, so authored via `propers` rather than a Common
+# fallback. No Lectio7-9 override in her own file (defers to Commune/
+# C11's own Nocturn 3, same as our-lady-of-the-snows.yml's — see that
+# file's own Nocturn 3 comment for why it's duplicated rather than
+# cross-referenced).
+id: presentation-of-the-bvm
+name: "The Presentation of the Blessed Virgin Mary"
+nameLa: "Præsentatio Beatæ Mariæ Virginis"
+rank: duplex-majus
+common: common-of-the-bvm
+propers: "presentation-of-the-bvm"

src/data/calendar/saints/purification.yml

@@ -0,0 +1,16 @@
+# Read directly from the reference engine (`../divinum-officium-reference`,
+# per memory vu-reference-engine-file-layout, not a live query): untagged/
+# default [Rank] block of `web/www/horas/Latin/Sancti/02-02.txt` -- "In
+# Purificatione Beatæ Mariæ Virginis;;Duplex 2 class;;5.1;;ex C11". Real
+# unique [Oratio]/[Ant 1]/Nocturn 2-3 content of her own (not a bare
+# Common fallback the way our-lady-of-the-snows.yml was) -- same
+# fixed-BVM-feast pattern as that pass, previously excluded under the
+# same stale "not modeled" convention this app has now dropped
+# per direct instruction (2026-08): import available content regardless
+# of rubric-era markers.
+id: purification
+name: "The Purification of the Blessed Virgin Mary (Candlemas)"
+nameLa: "Purificatio Beatæ Mariæ Virginis"
+rank: duplex-2-classis
+common: common-of-the-bvm
+propers: "purification"

src/data/calendar/saints/queenship-of-the-bvm.yml

@@ -0,0 +1,24 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/05-31.txt` -- "Beatæ Mariæ
+# Virginis Reginæ;;Duplex II classis;;5.1;;ex C11" (Common of Feasts
+# of the BVM). Instituted 1954 by Pius XII's encyclical "Ad cæli
+# Reginam" -- her own file has full, real, proper content throughout:
+# own [Oratio], own [Ant 1] (not a Common substitution, unlike
+# presentation-of-the-bvm.yml), and a full nine-lesson Matins office of
+# her own. Nocturn 1 (Sir 24, plain scripture) isn't modeled, per this
+# app's established convention (getNocturnReadings only ever carries
+# Nocturn 2/3 across the whole calendar). Nocturn 2 (Lectio4-6): a
+# three-part patristic/magisterial anthology (Peter Canisius,
+# Athanasius via Canisius, Pius XII's "Ad cæli Reginam" itself) rather
+# than one continuous narrative -- still combined into a single
+# reading, matching how this app already treats other multi-source
+# Nocturn 2 content. Nocturn 3: her own Gospel citation ends "Et
+# réliqua"/"And so on" with no full pericope given -- per the
+# bare-incipit convention, only the homily (Lectio7-9, St. Bonaventure)
+# is authored, isGospel: false, no citation field.
+id: queenship-of-the-bvm
+name: "The Queenship of the Blessed Virgin Mary"
+nameLa: "Beata Maria Virgo Regina"
+rank: duplex-2-classis
+common: common-of-the-bvm
+propers: "queenship-of-the-bvm"

src/data/calendar/saints/seven-sorrows-of-the-bvm.yml

@@ -0,0 +1,15 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/09-15.txt` -- "Septem Dolorum
+# Beatæ Mariæ Virginis;;Duplex 2nd class;;5.1;;ex C11". Own real
+# [Oratio] and own [Ant 1]. Nocturn 2 (Lectio4-6) is a direct
+# `@Tempora/Quad5-5` cross-reference (Friday of Passion Week's own
+# temporal content, reused wholesale here) -- not this feast's own
+# content, not transcribed, per the bare-cross-reference convention.
+# Nocturn 3 (Lectio7-9) is her own real content (St. Ambrose's homily
+# on John 19:25-27 and his own Epistle 25).
+id: seven-sorrows-of-the-bvm
+name: "The Seven Sorrows of the Blessed Virgin Mary"
+nameLa: "Septem Dolores Beatæ Mariæ Virginis"
+rank: duplex-2-classis
+common: common-of-the-bvm
+propers: "seven-sorrows-of-the-bvm"

src/data/calendar/saints/ss-abdon-and-sennen.yml

@@ -3,6 +3,12 @@
 # Simplex. Own proper collect, no unique antiphon of their own.
 id: ss-abdon-and-sennen
 name: "Ss. Abdon and Sennen, Martyrs"
+nameLa: "Sancti Abdon et Sennes, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-abdon-and-sennen"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (07-30.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-alexander-eventius-theodulus-and-juvenal.yml

@@ -9,6 +9,12 @@
 # caveat as every other stub. No text pulled at all yet.
 id: ss-alexander-eventius-theodulus-and-juvenal
 name: "Ss. Alexander I, Eventius, and Theodulus, Martyrs, and Juvenal, Bishop and Confessor"
+nameLa: "Sancti Alexander, Eventius et Theodulus, Martyres, et Sanctus Juvenalis, Episcopus et Confessor"
 rank: simplex
 common: common-of-several-martyrs
-propers: null
+propers: "ss-alexander-eventius-theodulus-and-juvenal"
+# No [Ant 1] of its own in the source (05-03r.txt) -- [Rule]/[Rank] point to
+# Commune/C3 instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-basilides-cyrinus-nabor-and-nazarius.yml

@@ -3,6 +3,12 @@
 # proper collect and antiphon.
 id: ss-basilides-cyrinus-nabor-and-nazarius
 name: "Ss. Basilides, Cyrinus, Nabor, and Nazarius, Martyrs"
+nameLa: "Sancti Basilides, Cyrinus, Nabor et Nazarius, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-basilides-cyrinus-nabor-and-nazarius"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-12o.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-chrysanthus-and-daria.yml

@@ -7,6 +7,12 @@
 # proper collect, no unique antiphon of their own.
 id: ss-chrysanthus-and-daria
 name: "Ss. Chrysanthus and Daria, Martyrs"
+nameLa: "Sancti Chrysanthus et Daria, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-chrysanthus-and-daria"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (10-25.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-cletus-and-marcellinus.yml

@@ -3,6 +3,13 @@
 # No unique Oratio/Antiphon -- Common of Several Martyrs only.
 id: ss-cletus-and-marcellinus
 name: "Ss. Cletus and Marcellinus, Popes and Martyrs"
+nameLa: "Sancti Cletus et Marcellinus, Papæ et Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: null
+collectCommon: collect-c3b
+collectName:
+  la: ["Cletum", "Marcellínum"]
+  en: ["Cletus", "Marcellinus"]
+minorHoursCommon: common-of-pope-martyrs
+benedictusCommon: common-of-pope-martyrs

src/data/calendar/saints/ss-cornelius-and-cyprian.yml

@@ -8,6 +8,13 @@
 # raw file at this MM-DD slot (Sancti/09-16.txt) is empty.
 id: ss-cornelius-and-cyprian
 name: "Ss. Cornelius, Pope, and Cyprian, Bishop, Martyrs"
+nameLa: "Sanctus Cornelius, Papa, et Sanctus Cyprianus, Episcopus, Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: null
+collectCommon: collect-c3
+collectName:
+  la: ["Cornélii", "Cypriáni"]
+  en: ["Cornelius", "Cyprian"]
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-cosmas-and-damian.yml

@@ -3,6 +3,12 @@
 # proper collect, no unique antiphon of their own.
 id: ss-cosmas-and-damian
 name: "Ss. Cosmas and Damian, Martyrs"
+nameLa: "Sancti Cosmas et Damianus, Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: "ss-cosmas-and-damian"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (09-27.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-cyprian-and-justina.yml

@@ -6,6 +6,12 @@
 # Justina instead, a distinct legend.
 id: ss-cyprian-and-justina
 name: "Ss. Cyprian and Justina, Martyrs"
+nameLa: "Sanctus Cyprianus et Sancta Justina, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-cyprian-and-justina"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (09-26.txt) --
+# [Rule]/[Rank] point to Commune/C3a-1 instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-cyriacus-largus-and-smaragdus.yml

@@ -3,6 +3,12 @@
 # proper collect, no unique antiphon of their own.
 id: ss-cyriacus-largus-and-smaragdus
 name: "Ss. Cyriacus, Largus, and Smaragdus, Martyrs"
+nameLa: "Sancti Cyriacus, Largus et Smaragdus, Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: "ss-cyriacus-largus-and-smaragdus"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (08-08.txt) --
+# [Rule]/[Rank] point to Commune/C3a-1 instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-cyril-and-methodius.yml

@@ -0,0 +1,18 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/07-07.txt` -- "Duplex;;3;;vide
+# C4-1" (a variant Oratio of the Common of a Confessor Bishop, C4 --
+# same non-distinct-category reasoning as st-augustine-of-canterbury.yml).
+# Own real proper [Oratio] and own Nocturn 2 content (Leo XIII's own
+# encyclical letter). No [Ant 1] of its own -- benedictusCommon/
+# minorHoursCommon fall back to the plain Common of a Confessor
+# Bishop. Nocturn 3 is a direct `@Commune/C1a:LectioN` cross-reference
+# (Common of Apostles variant), not this saint's own content -- not
+# transcribed, per the bare-cross-reference convention.
+id: ss-cyril-and-methodius
+name: "Ss. Cyril and Methodius, Bishops and Confessors"
+nameLa: "Sancti Cyrillus et Methodius, Episcopi et Confessores"
+rank: duplex
+common: common-of-a-confessor-bishop
+propers: "ss-cyril-and-methodius"
+benedictusCommon: common-of-a-confessor-bishop
+minorHoursCommon: common-of-a-confessor-bishop

src/data/calendar/saints/ss-dionysius-and-companions.yml

@@ -7,6 +7,19 @@
 # is correct.
 id: ss-dionysius-and-companions
 name: "St. Dionysius, Bishop, and Companions, Martyrs"
+nameLa: "Sanctus Dionysius, Episcopus, et Socii, Martyres"
 rank: semiduplex
 common: common-of-a-martyr-bishop
-propers: null
+propers: "ss-dionysius-and-companions"
+# Benedictus antiphon live-verified (2026-08, Lauds query, 2025-10-09,
+# winner outright) as byte-identical to common-of-several-martyrs's own
+# ("Vestri capílli cápitis...") -- despite `common` above saying
+# martyr-*bishop*, not several-martyrs; the two fields aren't always the
+# same category (see calendar/feasts.ts's SaintRecord.benedictusCommon
+# doc comment).
+benedictusCommon: common-of-several-martyrs
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (10-09t.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-euphemia-lucia-and-geminianus.yml

@@ -10,6 +10,12 @@
 # placeholders.
 id: ss-euphemia-lucia-and-geminianus
 name: "Ss. Euphemia, Lucy, and Geminianus, Martyrs"
+nameLa: "Sanctæ Euphemia et Lucia, et Sanctus Geminianus, Martyres"
 rank: simplex
 common: common-of-several-martyrs
-propers: null
+propers: "ss-euphemia-lucia-and-geminianus"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (09-16.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-fabian-and-sebastian.yml

@@ -3,6 +3,12 @@
 # shared by two martyrs. Own proper collect, no unique antiphon of their own.
 id: ss-fabian-and-sebastian
 name: "Ss. Fabian and Sebastian, Martyrs"
+nameLa: "Sancti Fabianus et Sebastianus, Martyres"
 rank: duplex
 common: common-of-several-martyrs
 propers: "ss-fabian-and-sebastian"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (01-20.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-faustinus-and-jovita.yml

@@ -4,6 +4,13 @@
 # Oratio/Antiphon in the source -- Common of Several Martyrs only.
 id: ss-faustinus-and-jovita
 name: "Ss. Faustinus and Jovita, Martyrs"
+nameLa: "Sancti Faustinus et Jovita, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: null
+collectCommon: collect-c3a-1
+collectName:
+  la: ["Faustíni", "Jovítæ"]
+  en: ["Faustinus", "Jovita"]
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-felix-and-adauctus.yml

@@ -1,16 +1,30 @@
 # Verified against Divinum Officium (Monastic Tridentinum 1617), live
 # kalendar check on a clean weekday (2027-08-30, a Monday) -- wins outright
-# at Simplex. On a Saturday this date is instead outranked by the generic
+# at Simplex against a bare weekday. On a Saturday this date is instead
-# "Sanctae Mariae Sabbato" votive (confirmed re-checking 2025-08-30, a
+# outranked by the generic "Sanctae Mariae Sabbato" votive (confirmed
-# Saturday, where the votive won instead) -- an artifact of the tested
+# re-checking 2025-08-30, a Saturday, where the votive won instead) -- an
-# weekday, same pattern as St. Stephen I (Aug 2) this month and Ss.
+# artifact of the tested weekday, same pattern as St. Stephen I (Aug 2)
-# Marcellinus/Peter/Erasmus in June. No unique collect: the raw file at
+# this month and Ss. Marcellinus/Peter/Erasmus in June. No unique collect
-# this MM-DD slot (Sancti/08-30.txt) is actually St. Rose of Lima's (a
+# of its own here on the Monastic 1617 track (a live prayTertia query for
-# much later, 17th-century addition to this filename slot) -- a live
+# that track returns no Oratio at all): the raw file at this MM-DD slot
-# prayTertia query for the Monastic 1617 track returns no Oratio at all,
+# (Sancti/08-30.txt) actually belongs to St. Rose of Lima, a much later
-# confirming propers: null is correct.
+# (17th-century) addition to this filename slot on the general
+# Tridentine/Divino Afflatu calendar -- see st-rose-of-lima.yml, now
+# authored and the day's outright winner (semiduplex > simplex) per
+# sanctoral-calendar.yml. Felix and Adauctus's own real content survives
+# at the suffixed sibling file (Sancti/08-30o.txt) and is kept here as a
+# full commemoration, not suppressed, per collision.ts.
 id: ss-felix-and-adauctus
 name: "Ss. Felix and Adauctus, Martyrs"
+nameLa: "Sancti Felix et Adauctus, Martyres"
 rank: simplex
 common: common-of-several-martyrs
-propers: null
+propers: "ss-felix-and-adauctus"
+# Benedictus antiphon live-verified (2026-08, Lauds query, 2025-08-30, winner
+# outright) as byte-identical to common-of-several-martyrs.yml's own.
+benedictusCommon: common-of-several-martyrs
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (08-30o.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-felix-simplicius-faustinus-and-beatrix.yml

@@ -9,6 +9,12 @@
 # text pulled at all yet.
 id: ss-felix-simplicius-faustinus-and-beatrix
 name: "Ss. Felix, Simplicius, Faustinus, and Beatrix, Martyrs"
+nameLa: "Sancti Felix, Simplicius, Faustinus et Beatrix, Martyres"
 rank: simplex
 common: common-of-several-martyrs
-propers: null
+propers: "ss-felix-simplicius-faustinus-and-beatrix"
+# No [Ant 1] of its own in the source (07-29cc.txt) -- [Rule]/[Rank] point to
+# Commune/C3a instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-gervase-and-protase.yml

@@ -3,6 +3,12 @@
 # proper collect, no unique antiphon of their own.
 id: ss-gervase-and-protase
 name: "Ss. Gervase and Protase, Martyrs"
+nameLa: "Sancti Gervasius et Protasius, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-gervase-and-protase"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-19o.txt) --
+# [Rule]/[Rank] point to Commune/C3a-1 instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-hippolytus-and-cassian.yml

@@ -0,0 +1,13 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/08-13.txt` -- "Simplex;;1.1;;
+# vide C3a-1" (Common of Several Martyrs). Own real proper [Oratio].
+# Single simplex-feast lesson (Lectio93), one continuous account
+# covering both martyrs, same pattern as
+# ss-marcellinus-peter-and-erasmus.yml.
+id: ss-hippolytus-and-cassian
+name: "Ss. Hippolytus and Cassian, Martyrs"
+nameLa: "Sancti Hippolytus et Cassianus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-hippolytus-and-cassian"
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-john-and-paul.yml

@@ -5,6 +5,12 @@
 # antiphon.
 id: ss-john-and-paul
 name: "Ss. John and Paul, Martyrs"
+nameLa: "Sancti Joannes et Paulus, Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: "ss-john-and-paul"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-26.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-machabees.yml

@@ -4,6 +4,12 @@
 # an artifact of the tested year. rank/propers unverified placeholders.
 id: ss-machabees
 name: "Ss. Machabees, Martyrs"
+nameLa: "Sancti Machabæi, Martyres"
 rank: simplex
 common: common-of-several-martyrs
-propers: null
+propers: "ss-machabees"
+# No [Ant 1] of its own in the source (08-01r.txt) -- [Rule]/[Rank] point to
+# Commune/C3 instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-marcellinus-peter-and-erasmus.yml

@@ -5,6 +5,12 @@
 # their own.
 id: ss-marcellinus-peter-and-erasmus
 name: "Ss. Marcellinus, Peter, and Erasmus, Bishop, Martyrs"
+nameLa: "Sancti Marcellinus et Petrus, et Sanctus Erasmus, Episcopus, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-marcellinus-peter-and-erasmus"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-02.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-marius-martha-audifax-and-abachum.yml

@@ -7,6 +7,12 @@
 # author" scope for merely-commemorated saints.
 id: ss-marius-martha-audifax-and-abachum
 name: "Ss. Marius, Martha, Audifax, and Abachum, Martyrs"
+nameLa: "Sancti Marius, Martha, Audifax et Abachum, Martyres"
 rank: simplex
 common: common-of-several-martyrs
-propers: null
+propers: "ss-marius-martha-audifax-and-abachum"
+# No [Ant 1] of its own in the source (01-19.txt) -- [Rule]/[Rank] point to
+# Commune/C3a instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-mark-and-marcellian.yml

@@ -3,6 +3,12 @@
 # proper collect, no unique antiphon of their own.
 id: ss-mark-and-marcellian
 name: "Ss. Mark and Marcellian, Martyrs"
+nameLa: "Sancti Marcus et Marcellianus, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-mark-and-marcellian"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-18t.txt) --
+# [Rule]/[Rank] point to Commune/C3a-1 instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-maurice-and-companions.yml

@@ -8,6 +8,15 @@
 # August's entries.
 id: ss-maurice-and-companions
 name: "Ss. Maurice and Companions, Martyrs"
+nameLa: "Sanctus Mauritius et Socii, Martyres"
 rank: simplex
 common: common-of-several-martyrs
-propers: null
+propers: "ss-maurice-and-companions"
+# Benedictus antiphon live-verified (2026-08, Lauds query, 2025-09-22, winner
+# outright) as byte-identical to common-of-several-martyrs.yml's own.
+benedictusCommon: common-of-several-martyrs
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (09-22o.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-nabor-and-felix.yml

@@ -9,6 +9,12 @@
 # text pulled at all yet.
 id: ss-nabor-and-felix
 name: "Ss. Nabor and Felix, Martyrs"
+nameLa: "Sancti Nabor et Felix, Martyres"
 rank: simplex
 common: common-of-several-martyrs
-propers: null
+propers: "ss-nabor-and-felix"
+# No [Ant 1] of its own in the source (07-12o.txt) -- [Rule]/[Rank] point to
+# Commune/C3a-1 instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-nazarius-celsus-victor-and-innocent.yml

@@ -6,6 +6,12 @@
 # antiphon of their own.
 id: ss-nazarius-celsus-victor-and-innocent
 name: "Ss. Nazarius and Celsus, Martyrs, St. Victor I, Pope and Martyr, and St. Innocent I, Pope and Confessor"
+nameLa: "Sancti Nazarius et Celsus, Martyres, Sanctus Victor I, Papa et Martyr, et Sanctus Innocentius I, Papa et Confessor"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: "ss-nazarius-celsus-victor-and-innocent"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (07-28.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-nereus-achilleus-domitilla-and-pancras.yml

@@ -3,6 +3,12 @@
 # Own proper collect, no unique antiphon of their own.
 id: ss-nereus-achilleus-domitilla-and-pancras
 name: "Ss. Nereus, Achilleus, Domitilla, and Pancras, Martyrs"
+nameLa: "Sancti Nereus, Achilleus et Pancratius, et Sancta Domitilla, Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: "ss-nereus-achilleus-domitilla-and-pancras"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (05-12.txt) --
+# [Rule]/[Rank] point to Commune/C3a-1 instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-perpetua-and-felicity.yml

@@ -0,0 +1,16 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/03-06.txt` -- "vide C7b;;Duplex;;3;;".
+# No [Oratio]/[Ant 1] of her own -- both fall back to Common of several
+# women Martyrs (C7b), newly authored here (collect-c7b.yml,
+# benedictus-antiphon-common-of-several-women-martyrs.yml).
+id: ss-perpetua-and-felicity
+name: "Ss. Perpetua and Felicity, Martyrs"
+nameLa: "Sanctæ Perpetua et Felicitas, Martyres"
+rank: duplex
+common: common-of-several-women-martyrs
+propers: null
+collectCommon: collect-c7b
+collectName:
+  la: ["Perpétuæ", "Felicitátis"]
+  en: ["Perpetua", "Felicitas"]
+benedictusCommon: common-of-several-women-martyrs

src/data/calendar/saints/ss-peter-and-paul.yml

@@ -5,6 +5,7 @@
 # duplicated here rather than shared, see ss-peter-and-paul-antiphon.yml.
 id: ss-peter-and-paul
 name: "Ss. Peter and Paul, Apostles"
+nameLa: "Sancti Petrus et Paulus, Apostoli"
 rank: duplex-1-classis
 common: common-of-an-apostle
 propers: "ss-peter-and-paul"

src/data/calendar/saints/ss-philip-and-james.yml

@@ -3,6 +3,8 @@
 # classis. Own proper collect and antiphon.
 id: ss-philip-and-james
 name: "Ss. Philip and James, Apostles"
+nameLa: "Sancti Philippus et Jacobus, Apostoli"
 rank: duplex-2-classis
 common: common-of-an-apostle
 propers: "ss-philip-and-james"
+minorHoursCommon: common-of-apostles

src/data/calendar/saints/ss-placid-and-companions.yml

@@ -10,6 +10,13 @@
 # treatment as any other saint whose own file just points at the Common.
 id: ss-placid-and-companions
 name: "Ss. Placid and Companions, Martyrs"
+nameLa: "Sanctus Placidus et Socii, Martyres"
 rank: duplex-2-classis
 common: common-of-several-martyrs
 propers: null
+collectCommon: collect-c3a
+collectName:
+  la: ["Plácidi", "Sociórum ejus"]
+  en: ["Placidus", "his companions"]
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-primus-and-felicianus.yml

@@ -5,6 +5,12 @@
 # antiphon of their own.
 id: ss-primus-and-felicianus
 name: "Ss. Primus and Felicianus, Martyrs"
+nameLa: "Sancti Primus et Felicianus, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-primus-and-felicianus"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-09.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-protus-and-hyacinth.yml

@@ -0,0 +1,13 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/09-11.txt` -- "Simplex;;1.1;;
+# vide C3a-1" (Common of Several Martyrs). Own real proper [Oratio].
+# Single simplex-feast lesson (Lectio93), one continuous account
+# covering both martyrs, same pattern as
+# ss-marcellinus-peter-and-erasmus.yml.
+id: ss-protus-and-hyacinth
+name: "Ss. Protus and Hyacinth, Martyrs"
+nameLa: "Sancti Protus et Hyacinthus, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-protus-and-hyacinth"
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-seven-brothers-rufina-and-secunda.yml

@@ -3,6 +3,12 @@
 # Own proper collect, no unique antiphon of their own.
 id: ss-seven-brothers-rufina-and-secunda
 name: "Ss. Seven Brothers, Martyrs, and Ss. Rufina and Secunda, Virgins and Martyrs"
+nameLa: "Septem Fratres, Martyres, et Sanctæ Rufina et Secunda, Virgines et Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: "ss-seven-brothers-rufina-and-secunda"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (07-10.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-seven-founders-of-the-servite-order.yml

@@ -0,0 +1,12 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/02-12.txt` -- "vide C5c;;Duplex;;3;;".
+# Own proper [Oratio]/[Ant 1]/Nocturn 2 vita; Nocturn 3 is a direct
+# `@Commune/C1:LectioN` cross-reference to the Common of Apostles' own
+# Gospel-and-homily (Matt 19:27-29, "we have forsaken all"), fitting for
+# a group of founders, not the saints' own text.
+id: ss-seven-founders-of-the-servite-order
+name: "Ss. Seven Holy Founders of the Order of the Servants of the Blessed Virgin Mary"
+nameLa: "Septem Sancti Fundatores Ordinis Servorum Beatæ Mariæ Virginis"
+rank: duplex
+common: common-of-several-confessors
+propers: "ss-seven-founders-of-the-servite-order"

src/data/calendar/saints/ss-simon-and-jude.yml

@@ -3,6 +3,7 @@
 # alone. Own proper collect, no unique antiphon of their own.
 id: ss-simon-and-jude
 name: "Ss. Simon and Jude, Apostles"
+nameLa: "Sancti Simon et Judas, Apostoli"
 rank: duplex-2-classis
 common: common-of-an-apostle
 propers: "ss-simon-and-jude"

src/data/calendar/saints/ss-soter-and-caius.yml

@@ -6,6 +6,13 @@
 # this set. No unique Oratio/Antiphon -- Common of Several Martyrs only.
 id: ss-soter-and-caius
 name: "Ss. Soter and Caius, Popes and Martyrs"
+nameLa: "Sancti Soter et Cajus, Papæ et Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: null
+collectCommon: collect-c3b
+collectName:
+  la: ["Sotérem", "Cajum"]
+  en: ["Soter", "Caius"]
+minorHoursCommon: common-of-pope-martyrs
+benedictusCommon: common-of-pope-martyrs

src/data/calendar/saints/ss-symphorosa-and-seven-sons.yml

@@ -3,6 +3,12 @@
 # proper collect, no unique antiphon of their own.
 id: ss-symphorosa-and-seven-sons
 name: "Ss. Symphorosa and Her Seven Sons, Martyrs"
+nameLa: "Sancta Symphorosa et Septem Filii Ejus, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-symphorosa-and-seven-sons"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (07-18o.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-tiburtius-and-susanna.yml

@@ -0,0 +1,13 @@
+# Read directly from the reference engine: untagged/default [Rank]
+# block of `web/www/horas/Latin/Sancti/08-11.txt` -- "Simplex;;1.1;;
+# vide C3a-1" (Common of Several Martyrs). Own real proper [Oratio].
+# Single simplex-feast lesson (Lectio93), one continuous account
+# covering both martyrs, same pattern as
+# ss-marcellinus-peter-and-erasmus.yml.
+id: ss-tiburtius-and-susanna
+name: "Ss. Tiburtius and Susanna, Martyrs"
+nameLa: "Sanctus Tiburtius et Sancta Susanna, Martyres"
+rank: simplex
+common: common-of-several-martyrs
+propers: "ss-tiburtius-and-susanna"
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-tiburtius-valerian-and-maximus.yml

@@ -4,6 +4,12 @@
 # their own.
 id: ss-tiburtius-valerian-and-maximus
 name: "Ss. Tiburtius, Valerian, and Maximus, Martyrs"
+nameLa: "Sancti Tiburtius, Valerianus et Maximus, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-tiburtius-valerian-and-maximus"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (04-14t.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-tryphon-and-companions.yml

@@ -6,6 +6,15 @@
 # confirming propers: null is correct.
 id: ss-tryphon-and-companions
 name: "Ss. Tryphon, Respicius, and Nympha, Martyrs"
+nameLa: "Sancti Tryphon, Respicius et Nympha, Martyres"
 rank: simplex
 common: common-of-several-martyrs
-propers: null
+propers: "ss-tryphon-and-companions"
+# Benedictus antiphon live-verified (2026-08, Lauds query, 2025-11-10, winner
+# outright) as byte-identical to common-of-several-martyrs.yml's own.
+benedictusCommon: common-of-several-martyrs
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (11-10o.txt) --
+# [Rule]/[Rank] point to Commune/C3a instead, the same C-number family
+# already live-query-verified for common-of-several-martyrs.yml (see
+# TODO.md's 'minor hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-twelve-brothers.yml

@@ -4,6 +4,12 @@
 # tested year. rank/propers unverified placeholders.
 id: ss-twelve-brothers
 name: "Ss. Twelve Brothers, Martyrs"
+nameLa: "Duodecim Fratres, Martyres"
 rank: simplex
 common: common-of-several-martyrs
-propers: null
+propers: "ss-twelve-brothers"
+# No [Ant 1] of its own in the source (09-01cc.txt) -- [Rule]/[Rank] point to
+# Commune/C3 instead, the same C-number family already live-query-verified
+# for common-of-several-martyrs.yml (see that section of TODO.md).
+minorHoursCommon: common-of-several-martyrs
+benedictusCommon: common-of-several-martyrs

src/data/calendar/saints/ss-ursula-and-companions.yml

@@ -2,8 +2,24 @@
 # commemorated under St. Hilarion (see st-hilarion.yml), never wins
 # outright; both are fixed, non-movable dates, so this isn't an artifact
 # of the tested year. rank/propers unverified placeholders.
+#
+# No minorHoursCommon/benedictusCommon: her collect template (collect-c6b,
+# plural Virgins and Martyrs) has no other member on this app's calendar
+# to cross-verify a shared P/T/S/N/Benedictus text against, and she can
+# never be queried directly herself (never the day's own winner) -- rather
+# than guess she shares common-of-a-virgin's singular text (2026-08's
+# live-verified category, built from St. Justina/St. Emerentiana/
+# St. Praxedes/St. Martha, all singular), left unset, same "honestly
+# missing" convention as every other unauthored fallback in this codebase.
+# Moot in practice: a commemoration's minor hours are never rendered
+# anyway (resolveOfficeWinner only ever returns the day's actual winner).
 id: ss-ursula-and-companions
 name: "Ss. Ursula and Companions, Virgins and Martyrs"
+nameLa: "Sancta Ursula et Sociæ, Virgines et Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: null
+collectCommon: collect-c6b
+collectName:
+  la: ["Ursulæ", "Sociárum"]
+  en: ["Ursula", "her companions"]

src/data/calendar/saints/ss-vincent-and-anastasius.yml

@@ -3,6 +3,12 @@
 # proper collect, no unique antiphon of their own.
 id: ss-vincent-and-anastasius
 name: "Ss. Vincent and Anastasius, Martyrs"
+nameLa: "Sancti Vincentius et Anastasius, Martyres"
 rank: semiduplex
 common: common-of-several-martyrs
 propers: "ss-vincent-and-anastasius"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (01-22.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/ss-vitus-modestus-and-crescentia.yml

@@ -3,6 +3,12 @@
 # proper collect, no unique antiphon of their own.
 id: ss-vitus-modestus-and-crescentia
 name: "Ss. Vitus, Modestus, and Crescentia, Martyrs"
+nameLa: "Sancti Vitus, Modestus et Crescentia, Martyres"
 rank: simplex
 common: common-of-several-martyrs
 propers: "ss-vitus-modestus-and-crescentia"
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (06-15.txt) --
+# [Rule]/[Rank] point to Commune/C3 instead, the same C-number family already
+# live-query-verified for common-of-several-martyrs.yml (see TODO.md's 'minor
+# hour content gaps' section).
+minorHoursCommon: common-of-several-martyrs

src/data/calendar/saints/st-agatha.yml

@@ -1,10 +1,23 @@
 # Verified against Divinum Officium (Monastic Tridentinum 1617), live kalendar
 # check (2029-02-05, no Sunday collision) -- winner outright, Semiduplex. Own
-# proper antiphon (see propers/common/st-agatha-antiphon.yml) but no unique
+# proper antiphon (see propers/common/st-agatha-antiphon.yml). No unique
-# collect of her own -- Common of a Virgin Martyr supplies that instead, so
+# collect of her own -- Common of a Virgin Martyr supplies that instead
-# getDayCollect resolves honestly missing for her despite propers being set.
+# (her own [Oratio] is @Commune/C6::s/N\./Agathæ/, a plain name-substituted
+# reference, confirmed identical to collect-c6.yml's own template) -- 2026-08,
+# wired via collectCommon now that mechanism exists (it postdates this
+# saint's own original authoring, hence the gap).
 id: st-agatha
 name: "St. Agatha, Virgin and Martyr"
+nameLa: "Sancta Agatha, Virgo et Martyr"
 rank: semiduplex
 common: common-of-a-virgin-martyr
 propers: "st-agatha"
+collectCommon: collect-c6
+collectName:
+  la: ["Agathæ"]
+  en: ["Agatha"]
+# P/T/S/N: no [Ant Prima]/etc of its own in the source (02-05.txt) --
+# [Rule]/[Rank] point to Commune/C6 instead, the same C-number family already
+# live-query-verified for common-of-a-virgin.yml (see TODO.md's 'minor hour
+# content gaps' section).
+minorHoursCommon: common-of-a-virgin