feat(agenda): spell out multi-day time line instead of arrows

The "→" arrow convention read as unclear. Spell each day out instead:
the first day names the start ("Starts 14:00"), the last day the end
("Ends 10:00"), and whole days in between read as "All day". All-day
multi-day events stay "All day" on every day. Single-day rows unchanged.

Adds agenda_span_starts / agenda_span_ends (owes Weblate backfill).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [2.16.0] — 2026-07-17
+
+### Changed
+- Dates in the Month, Week and Day title bars now follow your language and
+  region instead of one hardcoded layout. Every date was rendered in a fixed
+  German-style order with a trailing dot on the day number, whatever your
+  settings: US English showed "Fri, 17. Jul 2026" where it should read
+  "Fri, Jul 17". The Agenda view already formatted correctly, so the two
+  disagreed about the same date. All four views now share one formatter, and the
+  day/month order, the separators and the ordinal all come from your locale —
+  so English-in-Germany reads "Fri, 17 Jul" and English-in-the-US "Fri, Jul 17",
+  each correct for where you are ([#60]).
+- The title bar drops the year while you're in the current one — "July" rather
+  than "July 2026". The year reappears the moment you page out of the current
+  year, which is when it tells you something you didn't already know.
+- The Week view's title now names the month instead of spelling out the day range.
+  "24. Jun – 31. Jun" restated the day numbers already printed in the column
+  headers right below it, in the widest string in the bar. A week that straddles
+  two months keeps the outgoing month until it is fully gone ([#60]).
+
 ## [2.15.0] — 2026-07-15
 
 ### Added
@@ -997,3 +1019,4 @@ automatically, with zero telemetry and no internet permission.
 [#48]: https://codeberg.org/jlmakiola/calendula/issues/48
 [#49]: https://codeberg.org/jlmakiola/calendula/issues/49
 [#52]: https://codeberg.org/jlmakiola/calendula/issues/52
+[#60]: https://codeberg.org/jlmakiola/calendula/issues/60

app/build.gradle.kts

@@ -28,8 +28,8 @@ android {
         // which builds this version and then creates the matching vX.Y.Z tag +
         // release itself (versionCode is pinned to MAJOR*10000 + MINOR*100 +
         // PATCH from versionName, e.g. 2.7.2 -> 20702). See docs/RELEASING.md.
-        versionCode = 21500
+        versionCode = 21600
-        versionName = "2.15.0"
+        versionName = "2.16.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaRange.kt

@@ -1,6 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.agenda
 
-import de.jeanlucmakiola.calendula.ui.common.localizedDateFormatter
+import de.jeanlucmakiola.floret.locale.localizedDateFormatter
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import java.time.YearMonth

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaScreen.kt

@@ -68,7 +68,7 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
-import de.jeanlucmakiola.calendula.ui.common.localizedDateFormatter
+import de.jeanlucmakiola.floret.locale.localizedDateFormatter
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
@@ -76,7 +76,7 @@ import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
-import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
 import kotlinx.coroutines.launch
@@ -367,10 +367,14 @@ private fun AgendaList(
             } else {
                 itemsIndexed(
                     items = day.events,
-                    key = { _, event -> event.instanceId },
+                    // Scope the key by day: a multi-day event appears under every
+                    // day it spans, so its instanceId alone is not unique across
+                    // the list (LazyColumn requires unique keys).
+                    key = { _, event -> "${day.date}-${event.instanceId}" },
                 ) { index, event ->
                     AgendaEventRow(
                         event = event,
+                        day = day.date,
                         position = positionOf(index, day.events.size),
                         dimmed = dimPast && event.hasEnded(now),
                         modifier = animateItemMotion(),
@@ -449,6 +453,7 @@ private fun AgendaEmptyDayRow(onClick: () -> Unit) {
 @Composable
 private fun AgendaEventRow(
     event: EventInstance,
+    day: LocalDate,
     position: Position,
     dimmed: Boolean,
     modifier: Modifier = Modifier,
@@ -460,7 +465,7 @@ private fun AgendaEventRow(
     GroupedRow(
         modifier = if (dimmed) modifier.alpha(EventDimAlpha) else modifier,
         title = title,
-        summary = agendaTimeSummary(event),
+        summary = agendaTimeSummary(event, day),
         position = position,
         minHeight = 64.dp,
         leading = {
@@ -554,16 +559,35 @@ private fun agendaDayLabel(date: LocalDate, today: LocalDate): String {
     return if (relative != null) "$relative · $formatted" else formatted
 }
 
-/** Time line under the title: "09:00 – 10:00 · Location", "All day", etc. */
+/**
+ * Time line under the title: "09:00 – 10:00 · Location", "All day", etc.
+ *
+ * A multi-day event shows only the part relevant to [day], spelled out so each
+ * day reads on its own: its first day names the start ("Starts 14:00"), its last
+ * day the end ("Ends 10:00"), and any whole day in between reads as "All day".
+ * An all-day multi-day event is simply "All day" on every day it covers.
+ */
 @Composable
-private fun agendaTimeSummary(event: EventInstance): String {
+private fun agendaTimeSummary(event: EventInstance, day: LocalDate): String {
-    val time = if (event.isAllDay) {
+    val allDayLabel = stringResource(R.string.event_detail_all_day)
-        stringResource(R.string.event_detail_all_day)
+    val is24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
+
+    val time = if (event.spansMultipleDays(zone)) {
+        val isFirstDay = day <= event.spanFirstDay(zone)
+        val isLastDay = day >= event.spanLastDay(zone)
+        when {
+            event.isAllDay -> allDayLabel
+            isFirstDay -> stringResource(R.string.agenda_span_starts, formatTime(event.start, is24Hour, locale))
+            isLastDay -> stringResource(R.string.agenda_span_ends, formatTime(event.end, is24Hour, locale))
+            else -> allDayLabel // a full middle day
+        }
+    } else if (event.isAllDay) {
+        allDayLabel
     } else {
-        val is24Hour = LocalUse24HourFormat.current
-        val locale = currentLocale()
         "${formatTime(event.start, is24Hour, locale)} – ${formatTime(event.end, is24Hour, locale)}"
     }
+
     val location = event.location?.takeIf { it.isNotBlank() }
     return if (location != null) "$time · $location" else time
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaUiState.kt

@@ -2,9 +2,30 @@ package de.jeanlucmakiola.calendula.ui.agenda
 
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
+import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.plus
 import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Duration.Companion.milliseconds
+
+/** The first calendar day this event occupies, in [zone]. */
+fun EventInstance.spanFirstDay(zone: TimeZone): LocalDate =
+    start.toLocalDateTime(zone).date
+
+/**
+ * The last calendar day this event actually occupies, in [zone]. An event ending
+ * exactly at midnight (all-day events end at the exclusive next-midnight) does
+ * not reach into that boundary day, so resolve the instant just before [end].
+ */
+fun EventInstance.spanLastDay(zone: TimeZone): LocalDate {
+    val lastInstant = if (end > start) end - 1.milliseconds else start
+    return lastInstant.toLocalDateTime(zone).date
+}
+
+/** Whether this event occupies more than one calendar day in [zone]. */
+fun EventInstance.spansMultipleDays(zone: TimeZone): Boolean =
+    spanFirstDay(zone) != spanLastDay(zone)
 
 /** One calendar day with at least one event, for the agenda list. */
 data class AgendaDay(
@@ -15,31 +36,42 @@ data class AgendaDay(
 
 /**
  * Group flat [instances] into forward-looking [AgendaDay]s (only days that
- * actually carry events). An event that began before [anchor] (ongoing or
+ * actually carry events). A multi-day event surfaces on *every* day it spans,
- * multi-day) is clamped to the anchor day so it still surfaces on top. Within a
+ * not just its first — clamped to [[anchor], [windowEnd]] so an event that began
- * day, all-day events sort first, then ascending by start time, then title.
+ * before the window (ongoing) still lists from the anchor day, and one running
+ * past the window stops at the last visible day. Within a day, all-day events
+ * sort first, then ascending by start time, then title.
  *
  * Shared by the Agenda screen and the agenda home-screen widget so both group
  * and order identically.
  */
 fun groupAgendaDays(
     anchor: LocalDate,
+    windowEnd: LocalDate,
     instances: List<EventInstance>,
     zone: TimeZone,
-): List<AgendaDay> =
+): List<AgendaDay> {
-    instances
+    val byDay = sortedMapOf<LocalDate, MutableList<EventInstance>>()
-        .groupBy { it.start.toLocalDateTime(zone).date.coerceAtLeast(anchor) }
+    for (instance in instances) {
-        .toSortedMap()
+        val firstDay = instance.spanFirstDay(zone).coerceAtLeast(anchor)
-        .map { (date, dayEvents) ->
+        val lastDay = instance.spanLastDay(zone).coerceAtMost(windowEnd)
-            AgendaDay(
+        var day = firstDay
-                date = date,
+        while (day <= lastDay) {
-                events = dayEvents.sortedWith(
+            byDay.getOrPut(day) { mutableListOf() }.add(instance)
-                    compareByDescending<EventInstance> { it.isAllDay }
+            day = day.plus(1, DateTimeUnit.DAY)
-                        .thenBy { it.start }
-                        .thenBy { it.title },
-                ),
-            )
         }
+    }
+    return byDay.map { (date, dayEvents) ->
+        AgendaDay(
+            date = date,
+            events = dayEvents.sortedWith(
+                compareByDescending<EventInstance> { it.isAllDay }
+                    .thenBy { it.start }
+                    .thenBy { it.title },
+            ),
+        )
+    }
+}
 
 /**
  * Ensure [today] surfaces as the first agenda day even when it carries no

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaViewModel.kt

@@ -159,11 +159,11 @@ class AgendaViewModel @Inject constructor(
             return AgendaUiState.Failure(FailureReason.NoCalendarsConfigured)
         }
         val anchor = params.anchor
-        val days = groupAgendaDays(anchor, instances, zone)
         val rangeEnd = anchor.plus(
             params.range.dayCount(anchor, params.weekStart) - 1,
             DateTimeUnit.DAY,
         )
+        val days = groupAgendaDays(anchor, rangeEnd, instances, zone)
         return AgendaUiState.Success(
             anchor = anchor,
             today = todayDate,

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarTitle.kt

@@ -0,0 +1,28 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import de.jeanlucmakiola.floret.locale.localizedDateFormatter
+import java.util.Locale
+
+/**
+ * Formats a calendar title (top bar or widget header): [skeleton]'s fields laid
+ * out in [locale]'s own order, with the year shown only when [date] falls outside
+ * [currentYear].
+ *
+ * Pass [skeleton] *without* a year field — "LLLL" for a month, "EEEdMMM" for a
+ * day. A skeleton is a field list, so wanting the year is just asking for one
+ * more field; the locale still decides where it lands ("July 2026" vs "2026年7月").
+ *
+ * Dropping the year in the current year is the one bit of policy here: the title
+ * sits directly above a grid that already says which year it is, and the year's
+ * *absence* is itself the signal that you're in the current one — it appears the
+ * moment you page out of it, which is when it starts carrying information.
+ */
+fun formatCalendarTitle(
+    date: java.time.LocalDate,
+    locale: Locale,
+    currentYear: Int,
+    skeleton: String,
+): String {
+    val fields = if (date.year == currentYear) skeleton else skeleton + "y"
+    return localizedDateFormatter(locale, fields).format(date)
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/LocaleSupport.kt

@@ -1,33 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.platform.LocalConfiguration
-import androidx.core.os.ConfigurationCompat
-import java.time.format.DateTimeFormatter
-import java.util.Locale
-
-/**
- * Current display [Locale], read observably from [LocalConfiguration] so the UI
- * recomposes after a locale change (lint: NonObservableLocale). Used for
- * weekday/month name formatting.
- */
-@Composable
-fun currentLocale(): Locale {
-    val configuration = LocalConfiguration.current
-    return remember(configuration) {
-        ConfigurationCompat.getLocales(configuration).get(0) ?: Locale.getDefault()
-    }
-}
-
-/**
- * A [DateTimeFormatter] for [skeleton]'s fields laid out in [locale]'s own order
- * (via Android's best-pattern matching), so dates read naturally per locale
- * instead of a hardcoded day-month-year order. [skeleton] lists the wanted
- * fields, e.g. "dMMMy" (day, abbreviated month, year) or "EEEdMMM" (weekday too).
- */
-fun localizedDateFormatter(locale: Locale, skeleton: String): DateTimeFormatter =
-    DateTimeFormatter.ofPattern(
-        android.text.format.DateFormat.getBestDateTimePattern(locale, skeleton),
-        locale,
-    )

app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayScreen.kt

@@ -68,6 +68,7 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
@@ -83,7 +84,7 @@ import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.eventInk
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
-import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
 import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
@@ -93,7 +94,9 @@ import de.jeanlucmakiola.calendula.ui.week.TimedBlock
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.datetime.LocalDate
-import java.time.format.TextStyle as JavaTextStyle
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
 import java.util.Locale
 import kotlin.math.roundToInt
 
@@ -157,6 +160,13 @@ fun DayScreen(
         else -> true
     }
 
+    // Drives whether the title carries the year. Falls back to the clock only
+    // while the first load is in flight, when there is no state to read today from.
+    val currentYear = when (val s = state) {
+        is DayUiState.Success -> s.today.year
+        else -> Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date.year
+    }
+
     // Slide direction for the day transition: +1 = next, -1 = prev, 0 = jump.
     var slideDir by remember { mutableIntStateOf(0) }
     val goNext = { slideDir = 1; viewModel.goToNext() }
@@ -205,6 +215,7 @@ fun DayScreen(
             topBar = {
                 DayTopBar(
                     date = date,
+                    currentYear = currentYear,
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
@@ -360,16 +371,18 @@ private fun DaySuccess(
 @Composable
 private fun DayTopBar(
     date: LocalDate,
+    currentYear: Int,
     selectedView: CalendarView,
     onCycleView: () -> Unit,
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
     scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
+    val locale = currentLocale()
     TopAppBar(
         title = {
             Text(
-                text = formatDayTitle(date),
+                text = formatDayTitle(date, locale, currentYear),
                 style = MaterialTheme.typography.titleLarge,
             )
         },
@@ -669,10 +682,10 @@ private fun DayLoading() {
 private fun minToHm(min: Int, is24Hour: Boolean, locale: Locale): String =
     formatMinuteOfDay(min, is24Hour, locale)
 
-private fun formatDayTitle(date: LocalDate): String {
+private fun formatDayTitle(date: LocalDate, locale: Locale, currentYear: Int): String =
-    val locale = Locale.getDefault()
+    formatCalendarTitle(
-    val java = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day)
+        date = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day),
-    val weekday = java.dayOfWeek.getDisplayName(JavaTextStyle.SHORT, locale)
+        locale = locale,
-    val monthName = java.month.getDisplayName(JavaTextStyle.SHORT, locale)
+        currentYear = currentYear,
-    return "$weekday, ${date.day}. $monthName ${date.year}"
+        skeleton = "EEEdMMM",
-}
+    )

app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailScreen.kt

@@ -98,7 +98,7 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.floret.components.OptionCard
-import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.calendula.ui.common.recurrenceText

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt

@@ -143,7 +143,7 @@ import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.calendula.ui.common.REMINDER_PRESETS
 import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.floret.reminders.ReminderUnit
-import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel

app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthScreen.kt

@@ -64,6 +64,7 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.hasEnded
+import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
@@ -79,7 +80,7 @@ import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
-import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.floret.time.isoWeekNumber
@@ -130,6 +131,13 @@ fun MonthScreen(
         else -> true
     }
 
+    // Drives whether the title carries the year. Falls back to the clock only
+    // while the first load is in flight, when there is no state to read today from.
+    val currentYear = when (val s = state) {
+        is MonthUiState.Success -> s.today.year
+        else -> Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date.year
+    }
+
     // Slide direction for the grid transition: +1 = next, -1 = prev, 0 = jump (no slide).
     var slideDir by remember { mutableIntStateOf(0) }
 
@@ -186,6 +194,7 @@ fun MonthScreen(
             topBar = {
                 MonthTopBar(
                     month = month,
+                    currentYear = currentYear,
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
@@ -294,16 +303,18 @@ private fun MonthContent(
 @Composable
 private fun MonthTopBar(
     month: YearMonth,
+    currentYear: Int,
     selectedView: CalendarView,
     onCycleView: () -> Unit,
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
     scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
+    val locale = currentLocale()
     TopAppBar(
         title = {
             Text(
-                text = formatMonthYear(month),
+                text = formatMonthTitle(month, locale, currentYear),
                 style = MaterialTheme.typography.titleLarge,
             )
         },
@@ -732,9 +743,10 @@ private fun MonthGridLoading() {
     }
 }
 
-private fun formatMonthYear(ym: YearMonth): String {
+private fun formatMonthTitle(ym: YearMonth, locale: Locale, currentYear: Int): String =
-    val locale = Locale.getDefault()
+    formatCalendarTitle(
-    val name = java.time.Month.of(ym.month.ordinal + 1)
+        date = java.time.LocalDate.of(ym.year, ym.month.ordinal + 1, 1),
-        .getDisplayName(JavaTextStyle.FULL, locale)
+        locale = locale,
-    return "$name ${ym.year}"
+        currentYear = currentYear,
-}
+        skeleton = "LLLL",
+    )

app/src/main/java/de/jeanlucmakiola/calendula/ui/search/SearchScreen.kt

@@ -54,7 +54,7 @@ import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.Position
-import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt

@@ -135,7 +135,7 @@ import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
 import de.jeanlucmakiola.calendula.ui.common.SnoozeDurationPicker
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
-import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.eventFormFieldIcon
 import de.jeanlucmakiola.calendula.ui.common.eventFormFieldLabel
 import de.jeanlucmakiola.calendula.ui.theme.BundledFont

app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekScreen.kt

@@ -77,6 +77,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.hasEnded
+import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
@@ -93,7 +94,7 @@ import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
-import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
 import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
@@ -180,6 +181,13 @@ fun WeekScreen(
         else -> true
     }
 
+    // Drives whether the title carries the year. Falls back to the clock only
+    // while the first load is in flight, when there is no state to read today from.
+    val currentYear = when (val s = state) {
+        is WeekUiState.Success -> s.today.year
+        else -> Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date.year
+    }
+
     // Slide direction for the week transition: +1 = next, -1 = prev, 0 = jump.
     var slideDir by remember { mutableIntStateOf(0) }
     val goNext = { slideDir = 1; viewModel.goToNext() }
@@ -228,6 +236,7 @@ fun WeekScreen(
             topBar = {
                 WeekTopBar(
                     weekStart = weekStart,
+                    currentYear = currentYear,
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
@@ -395,16 +404,18 @@ private fun WeekSuccess(
 @Composable
 private fun WeekTopBar(
     weekStart: LocalDate,
+    currentYear: Int,
     selectedView: CalendarView,
     onCycleView: () -> Unit,
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
     scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
+    val locale = currentLocale()
     TopAppBar(
         title = {
             Text(
-                text = formatWeekRange(weekStart),
+                text = formatWeekTitle(weekStart, locale, currentYear),
                 style = MaterialTheme.typography.titleLarge,
             )
         },
@@ -854,18 +865,21 @@ private fun WeekLoading() {
 private fun minToHm(min: Int, is24Hour: Boolean, locale: java.util.Locale): String =
     formatMinuteOfDay(min, is24Hour, locale)
 
-private fun formatWeekRange(weekStart: LocalDate): String {
+/**
-    val locale = Locale.getDefault()
+ * The week's title: just the month [weekStart] falls in.
-    val end = weekStart.plus(6, kotlinx.datetime.DateTimeUnit.DAY)
+ *
-    val monthName = { d: LocalDate ->
+ * The day numbers are already in the column headers directly below, so spelling
-        java.time.Month.of(d.month.ordinal + 1).getDisplayName(JavaTextStyle.SHORT, locale)
+ * out "13.–19. Jul" restates them in the widest string in the bar. Naming the
-    }
+ * month of [weekStart] means a week straddling a boundary keeps the outgoing
-    return if (weekStart.month == end.month && weekStart.year == end.year) {
+ * month until it is fully gone — a week is seven contiguous days, so the earlier
-        "${weekStart.day}.–${end.day}. ${monthName(weekStart)} ${weekStart.year}"
+ * month has a day in it exactly while [weekStart] is still inside it. That also
-    } else if (weekStart.year == end.year) {
+ * makes the title depend on nothing but [weekStart], so it cannot drift with the
-        "${weekStart.day}. ${monthName(weekStart)} – ${end.day}. ${monthName(end)} ${end.year}"
+ * direction you paged in from.
-    } else {
+ */
-        "${weekStart.day}. ${monthName(weekStart)} ${weekStart.year} – " +
+private fun formatWeekTitle(weekStart: LocalDate, locale: Locale, currentYear: Int): String =
-            "${end.day}. ${monthName(end)} ${end.year}"
+    formatCalendarTitle(
-    }
+        date = java.time.LocalDate.of(weekStart.year, weekStart.month.ordinal + 1, 1),
-}
+        locale = locale,
+        currentYear = currentYear,
+        skeleton = "LLLL",
+    )

app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetData.kt

@@ -131,13 +131,14 @@ internal suspend fun Context.loadAgendaWidgetData(): AgendaWidgetData {
     // the composition from Glance state, so changing the range is a plain
     // recomposition and never depends on the widget session restarting.
     val window = agendaRange(anchor, AgendaRange.MAX_CUSTOM_DAYS - 1, zone)
+    val windowEnd = anchor.plus(AgendaRange.MAX_CUSTOM_DAYS - 1, DateTimeUnit.DAY)
     val instances = ep.calendarRepository().instances(window).first()
     val is24Hour = prefs.timeFormat.first()
         .is24Hour(android.text.format.DateFormat.is24HourFormat(this))
     val soften = prefs.softenCalendarColors.first()
     return AgendaWidgetData.Ready(
         today = anchor,
-        days = groupAgendaDays(anchor, instances, zone),
+        days = groupAgendaDays(anchor, windowEnd, instances, zone),
         is24Hour = is24Hour,
         soften = soften,
         weekStart = weekStart,

app/src/main/java/de/jeanlucmakiola/calendula/widget/agenda/AgendaWidget.kt

@@ -55,7 +55,7 @@ import de.jeanlucmakiola.calendula.ui.agenda.parseAgendaRange
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
-import de.jeanlucmakiola.calendula.ui.common.localizedDateFormatter
+import de.jeanlucmakiola.floret.locale.localizedDateFormatter
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.widget.AgendaWidgetData
 import de.jeanlucmakiola.calendula.widget.CalendulaGlanceTheme

app/src/main/java/de/jeanlucmakiola/calendula/widget/month/MonthWidget.kt

@@ -49,6 +49,7 @@ import de.jeanlucmakiola.calendula.MainActivity
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.calendula.ui.month.MonthWeek
 import de.jeanlucmakiola.calendula.ui.month.layoutMonthWeeks
 import de.jeanlucmakiola.calendula.ui.common.eventFill
@@ -162,7 +163,7 @@ private fun MonthWidgetBody(source: MonthWidgetSource, dark: Boolean, soften: Bo
                 val colW = (LocalSize.current.width - GRID_HPADDING * 2) / 7
                 val weeks = layoutMonthWeeks(ym, source.weekStart, source.instances, zone)
 
-                MonthHeader(label = monthLabel(ym))
+                MonthHeader(label = monthLabel(ym, source.today.year))
                 Spacer(GlanceModifier.height(2.dp))
                 WeekdayHeader(weekStart = source.weekStart, colW = colW)
                 weeks.forEach { week ->
@@ -480,9 +481,13 @@ private fun PermissionMessage() {
     }
 }
 
-private fun monthLabel(month: YearMonth): String {
+// Locale.getDefault() rather than currentLocale(): Glance has no
-    val locale = Locale.getDefault()
+// LocalConfiguration, and the widget is re-rendered on a configuration change
-    val name = java.time.Month.of(month.month.ordinal + 1)
+// anyway (same convention as AgendaWidget).
-        .getDisplayName(JavaTextStyle.FULL, locale)
+private fun monthLabel(month: YearMonth, currentYear: Int): String =
-    return "$name ${month.year}"
+    formatCalendarTitle(
-}
+        date = java.time.LocalDate.of(month.year, month.month.ordinal + 1, 1),
+        locale = Locale.getDefault(),
+        currentYear = currentYear,
+        skeleton = "LLLL",
+    )

app/src/main/res/values/strings.xml

@@ -257,6 +257,9 @@
     <string name="agenda_header_tomorrow">Tomorrow</string>
     <string name="agenda_empty_title">You\'re all caught up</string>
     <string name="agenda_no_more_today">No more events today</string>
+    <!-- Time line for a multi-day event, on its first / last day (%1$s is a time, e.g. "14:00"). -->
+    <string name="agenda_span_starts">Starts %1$s</string>
+    <string name="agenda_span_ends">Ends %1$s</string>
 
     <!-- Event search -->
     <string name="search_action">Search</string>

app/src/test/java/de/jeanlucmakiola/calendula/ui/agenda/GroupAgendaDaysTest.kt

@@ -0,0 +1,119 @@
+package de.jeanlucmakiola.calendula.ui.agenda
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
+import kotlin.time.Instant
+import org.junit.jupiter.api.Test
+
+class GroupAgendaDaysTest {
+
+    private val zone = TimeZone.UTC
+    private val anchor = LocalDate(2026, 7, 1)
+    // A wide window so clamping to the window end is out of the way unless tested.
+    private val windowEnd = LocalDate(2026, 7, 31)
+
+    private fun at(y: Int, mo: Int, d: Int, h: Int = 0, min: Int = 0): Instant =
+        LocalDateTime(y, mo, d, h, min).toInstant(zone)
+
+    private fun event(
+        id: Long,
+        title: String,
+        start: Instant,
+        end: Instant,
+        isAllDay: Boolean = false,
+    ) = EventInstance(
+        instanceId = id,
+        eventId = id,
+        calendarId = 1,
+        title = title,
+        start = start,
+        end = end,
+        isAllDay = isAllDay,
+        color = 0,
+        location = null,
+    )
+
+    private fun days(instances: List<EventInstance>) =
+        groupAgendaDays(anchor, windowEnd, instances, zone)
+
+    @Test
+    fun `a timed multi-day event lists on every day it spans`() {
+        val e = event(1, "trip", at(2026, 7, 1, 14, 0), at(2026, 7, 3, 10, 0))
+
+        val result = days(listOf(e))
+
+        assertThat(result.map { it.date }).containsExactly(
+            LocalDate(2026, 7, 1),
+            LocalDate(2026, 7, 2),
+            LocalDate(2026, 7, 3),
+        ).inOrder()
+        result.forEach { assertThat(it.events).containsExactly(e) }
+    }
+
+    @Test
+    fun `an all-day multi-day event stops before its exclusive next-midnight end`() {
+        // 1–3 July inclusive: end is the exclusive midnight opening 4 July.
+        val e = event(1, "holiday", at(2026, 7, 1), at(2026, 7, 4), isAllDay = true)
+
+        val result = days(listOf(e))
+
+        assertThat(result.map { it.date }).containsExactly(
+            LocalDate(2026, 7, 1),
+            LocalDate(2026, 7, 2),
+            LocalDate(2026, 7, 3),
+        ).inOrder()
+    }
+
+    @Test
+    fun `a single-day event lists exactly once`() {
+        val e = event(1, "lunch", at(2026, 7, 2, 12, 0), at(2026, 7, 2, 13, 0))
+
+        assertThat(days(listOf(e)).map { it.date })
+            .containsExactly(LocalDate(2026, 7, 2))
+    }
+
+    @Test
+    fun `an event ending exactly at midnight does not reach the next day`() {
+        val e = event(1, "late", at(2026, 7, 1, 22, 0), at(2026, 7, 2, 0, 0))
+
+        assertThat(days(listOf(e)).map { it.date })
+            .containsExactly(LocalDate(2026, 7, 1))
+    }
+
+    @Test
+    fun `an event begun before the anchor is clamped to the anchor day`() {
+        val e = event(1, "ongoing", at(2026, 6, 29, 9, 0), at(2026, 7, 2, 9, 0))
+
+        assertThat(days(listOf(e)).map { it.date }).containsExactly(
+            LocalDate(2026, 7, 1),
+            LocalDate(2026, 7, 2),
+        ).inOrder()
+    }
+
+    @Test
+    fun `an event running past the window is clamped to the last visible day`() {
+        val narrowEnd = LocalDate(2026, 7, 2)
+        val e = event(1, "long", at(2026, 7, 1, 9, 0), at(2026, 7, 5, 9, 0))
+
+        val result = groupAgendaDays(anchor, narrowEnd, listOf(e), zone)
+
+        assertThat(result.map { it.date }).containsExactly(
+            LocalDate(2026, 7, 1),
+            LocalDate(2026, 7, 2),
+        ).inOrder()
+    }
+
+    @Test
+    fun `within a day all-day events sort before timed ones`() {
+        val allDay = event(1, "birthday", at(2026, 7, 1), at(2026, 7, 2), isAllDay = true)
+        val timed = event(2, "call", at(2026, 7, 1, 9, 0), at(2026, 7, 1, 10, 0))
+
+        val dayOne = days(listOf(timed, allDay)).first { it.date == anchor }
+
+        assertThat(dayOne.events).containsExactly(allDay, timed).inOrder()
+    }
+}

fastlane/metadata/android/en-US/changelogs/21600.txt

@@ -0,0 +1,18 @@
+### Changed
+- Dates in the Month, Week and Day title bars now follow your language and
+  region instead of one hardcoded layout. Every date was rendered in a fixed
+  German-style order with a trailing dot on the day number, whatever your
+  settings: US English showed "Fri, 17. Jul 2026" where it should read
+  "Fri, Jul 17". The Agenda view already formatted correctly, so the two
+  disagreed about the same date. All four views now share one formatter, and the
+  day/month order, the separators and the ordinal all come from your locale —
+  so English-in-Germany reads "Fri, 17 Jul" and English-in-the-US "Fri, Jul 17",
+  each correct for where you are ([#60]).
+- The title bar drops the year while you're in the current one — "July" rather
+  than "July 2026". The year reappears the moment you page out of the current
+  year, which is when it tells you something you didn't already know.
+- The Week view's title now names the month instead of spelling out the day range.
+  "24. Jun – 31. Jun" restated the day numbers already printed in the column
+  headers right below it, in the widest string in the bar. A week that straddles
+  two months keeps the outgoing month until it is fully gone ([#60]).
+