test(reminders): cover disabled-calendar alert filtering

Extract the disabled-calendar filtering from EventReminderReceiver into a
pure postableAlerts() function and unit-test it, since the receiver flow
itself is not reachable from a plain JUnit test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

CHANGELOG.md

@@ -5,6 +5,49 @@ 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]
+
+### Added
+- Set more than one default reminder per calendar. A calendar's default
+  reminders — and the global defaults under Settings → Notifications — can now
+  hold several lead times instead of just one, so new events can start with, say,
+  a reminder a week before *and* one on the day. The reminder pickers are now
+  multi-select; per-calendar overrides can still inherit the global default or
+  turn reminders off entirely. Thanks to @moonj for the suggestion ([#14]).
+
+### Fixed
+- Disabled calendars no longer notify. Reminders for events in a calendar you
+  have disabled (Settings → Calendars) are now suppressed instead of still
+  popping up — matching how a disabled calendar's events already stay hidden
+  everywhere else in the app ([#17]).
+- Editing a single occurrence of a recurring event works again. Choosing **Only
+  this event** and saving a change to one event in a repeating series silently
+  did nothing — the change was rejected and the edit form simply reappeared with
+  nothing applied. The edited occurrence is now stored correctly, so the change
+  lands on just that one event and leaves the rest of the series untouched
+  ([#16]).
+
+## [2.12.0] — 2026-06-28
+
+### Added
+- See past events your way. Two new settings change how events that have already
+  ended are shown. **Past events** (Settings → Appearance → Agenda) lets the
+  agenda — both in the app and the home-screen "Upcoming" widget — keep them as
+  usual, dim them, or hide them from the list entirely. **Dim completed events**
+  (Settings → Appearance) separately fades finished events in the month and week
+  views. Both are off by default, an event only counts as finished once it has
+  actually ended (events still in progress are never dimmed), and the lists
+  update on their own as the day goes on. Thanks to @ptab for the suggestion
+  ([#12]).
+
+### Changed
+- Readable titles on overlapping events. In the week and day views, events that
+  overlap split a day into slim columns where the title used to be clipped to a
+  character or two. The title now wraps across as many lines as the block can
+  fit, and the time is hidden on those narrow blocks so the name can fill the
+  space — so you can tell events apart without opening each one. Thanks to @ptab
+  for the suggestion ([#13]).
+
 ## [2.11.2] — 2026-06-28
 
 ### Added
@@ -706,3 +749,8 @@ automatically, with zero telemetry and no internet permission.
 [#8]: https://codeberg.org/jlmakiola/calendula/issues/8
 [#9]: https://codeberg.org/jlmakiola/calendula/issues/9
 [#10]: https://codeberg.org/jlmakiola/calendula/issues/10
+[#12]: https://codeberg.org/jlmakiola/calendula/issues/12
+[#13]: https://codeberg.org/jlmakiola/calendula/issues/13
+[#14]: https://codeberg.org/jlmakiola/calendula/issues/14
+[#16]: https://codeberg.org/jlmakiola/calendula/issues/16
+[#17]: https://codeberg.org/jlmakiola/calendula/issues/17

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 = 21102
+        versionCode = 21200
-        versionName = "2.11.2"
+        versionName = "2.12.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -90,6 +90,8 @@ android {
 
     buildFeatures {
         compose = true
+        // BuildConfig.DEBUG gates the in-app debug ribbon (see DebugRibbon).
+        buildConfig = true
     }
 
     // Don't embed AGP's dependency-metadata block in the APK signing block. It's

app/src/debug/res/values/colors.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Debug-only launcher-icon background. Production is slate (#5C6B7A); the
+    debug build paints the adaptive-icon background burnt orange instead, so the
+    debug icon reads at a glance as "not the real app" on the home screen. The
+    off-white foreground mark contrasts on both. See drawable/ic_launcher_background.
+-->
+<resources>
+    <color name="ic_launcher_background">#FFB23B00</color>
+</resources>

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

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Debug-build resource overrides. Merged on top of src/main for the `debug`
+    build type only (release/releaseTest keep the production values), so the
+    debug app is unmistakable on the launcher: its own label, alongside the
+    real app thanks to the `.debug` applicationId suffix.
+-->
+<resources>
+    <string name="app_name">Calendula Debug</string>
+</resources>

app/src/main/java/de/jeanlucmakiola/calendula/MainActivity.kt

@@ -8,6 +8,7 @@ import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.getValue
@@ -29,6 +30,7 @@ import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.WidgetNavRequest
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.DebugRibbon
 import de.jeanlucmakiola.calendula.ui.crash.CrashReportActivity
 import de.jeanlucmakiola.calendula.ui.crash.CrashReportDialog
 import de.jeanlucmakiola.calendula.ui.crash.submitCrashReport
@@ -101,19 +103,24 @@ class MainActivity : AppCompatActivity() {
                 darkTheme = darkTheme,
                 dynamicColor = settings.dynamicColor,
             ) {
-                CompositionLocalProvider(
+                Box(modifier = Modifier.fillMaxSize()) {
-                    LocalUse24HourFormat provides use24Hour,
+                    CompositionLocalProvider(
-                    LocalShowHourLines provides settings.showHourLines,
+                        LocalUse24HourFormat provides use24Hour,
-                ) {
+                        LocalShowHourLines provides settings.showHourLines,
-                    RootScreen(
+                    ) {
-                        modifier = Modifier.fillMaxSize(),
+                        RootScreen(
-                        requestedDetailKey = requestedDetailKey,
+                            modifier = Modifier.fillMaxSize(),
-                        onDetailKeyConsumed = { requestedDetailKey = null },
+                            requestedDetailKey = requestedDetailKey,
-                        widgetNavRequest = requestedNav,
+                            onDetailKeyConsumed = { requestedDetailKey = null },
-                        onWidgetNavConsumed = { requestedNav = null },
+                            widgetNavRequest = requestedNav,
-                        requestedImportUri = requestedImportUri,
+                            onWidgetNavConsumed = { requestedNav = null },
-                        onImportConsumed = { requestedImportUri = null },
+                            requestedImportUri = requestedImportUri,
-                    )
+                            onImportConsumed = { requestedImportUri = null },
+                        )
+                    }
+                    // A persistent corner marker so a debug build is never
+                    // mistaken for the production app; compiled out of release.
+                    if (BuildConfig.DEBUG) DebugRibbon()
                 }
                 pendingCrashReport?.let { report ->
                     CrashReportDialog(

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt

@@ -118,8 +118,14 @@ internal fun buildEventUpdateValues(
  * provider clone the series row and apply these on top. Unlike the series
  * update there is no dirty check — the exception is a fresh row, so every
  * form-backed column is written (empty optionals as explicit NULLs, since the
- * clone starts from the parent's values). An exception is a single event:
+ * clone starts from the parent's values).
- * DTEND, never RRULE/DURATION.
+ *
+ * The occurrence's length travels as DURATION, never DTEND: the provider
+ * rejects DTEND on an exception outright (`CalendarProvider2`:
+ * "Exceptions can't overwrite dtend") and derives the instance end from
+ * DTSTART + DURATION itself, clearing the inherited RRULE in the process. This
+ * matches how AOSP Calendar/Etar write exceptions; sending DTEND is what made
+ * "only this event" fail on-device (Codeberg #16).
  */
 internal fun buildOccurrenceExceptionValues(
     form: EventForm,
@@ -131,7 +137,7 @@ internal fun buildOccurrenceExceptionValues(
     put(CalendarContract.Events.TITLE, form.title.trim())
     put(CalendarContract.Events.ALL_DAY, if (form.isAllDay) 1 else 0)
     put(CalendarContract.Events.DTSTART, times.dtStartMillis)
-    put(CalendarContract.Events.DTEND, times.dtEndMillis)
+    put(CalendarContract.Events.DURATION, times.toRfc2445Duration(form.isAllDay))
     put(CalendarContract.Events.EVENT_TIMEZONE, times.timezone)
     put(CalendarContract.Events.AVAILABILITY, form.availability.toProviderValue())
     put(CalendarContract.Events.ACCESS_LEVEL, form.accessLevel.toProviderValue())

app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt

@@ -38,6 +38,19 @@ sealed interface WeekStartPref {
  */
 enum class TimeFormatPref { AUTO, TWELVE_HOUR, TWENTY_FOUR_HOUR }
 
+/**
+ * How the Agenda screen treats events that have already finished today: [SHOW]
+ * leaves them as-is (the historical behaviour), [DIM] fades them, [HIDE] drops
+ * them from the list entirely.
+ */
+enum class PastEventDisplay { SHOW, DIM, HIDE }
+
+/** Parse a stored [PastEventDisplay.name]; unknown/null falls back to [default]. */
+fun parsePastEventDisplay(
+    stored: String?,
+    default: PastEventDisplay = PastEventDisplay.SHOW,
+): PastEventDisplay = PastEventDisplay.entries.firstOrNull { it.name == stored } ?: default
+
 /**
  * Resolve to a concrete 24-hour flag. AUTO defers to [systemIs24Hour] (the
  * device's `DateFormat.is24HourFormat` value).
@@ -116,6 +129,31 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[SHOW_HOUR_LINES_KEY] = enabled }
     }
 
+    /**
+     * How the Agenda screen treats events that already ended today. Defaults to
+     * [PastEventDisplay.SHOW] — the historical behaviour; users opt into dimming
+     * or hiding.
+     */
+    val pastEventDisplay: Flow<PastEventDisplay> = store.data.map { prefs ->
+        prefs[PAST_EVENT_DISPLAY_KEY].toEnum(PastEventDisplay.SHOW)
+    }
+
+    suspend fun setPastEventDisplay(mode: PastEventDisplay) {
+        store.edit { it[PAST_EVENT_DISPLAY_KEY] = mode.name }
+    }
+
+    /**
+     * Whether the month/week grids fade events that have already finished.
+     * Defaults to OFF — independent of the Agenda's [pastEventDisplay].
+     */
+    val dimCompletedEvents: Flow<Boolean> = store.data.map { prefs ->
+        prefs[DIM_COMPLETED_EVENTS_KEY] ?: false
+    }
+
+    suspend fun setDimCompletedEvents(enabled: Boolean) {
+        store.edit { it[DIM_COMPLETED_EVENTS_KEY] = enabled }
+    }
+
     /**
      * How far ahead the in-app Agenda screen shows events (v2.11). Defaults to
      * [AgendaRange.Month] — a month of upcoming events. Independent of the
@@ -238,35 +276,36 @@ class SettingsPrefs @Inject constructor(
     }
 
     /**
-     * The default reminder lead time (minutes before start) prefilled on new
+     * The default reminder lead times (minutes before start) prefilled on new
-     * **timed** events. `null` = no default reminder — the prior behaviour, kept
+     * **timed** events. The empty list = no default reminder — the prior
-     * as the factory default so existing users aren't surprised by reminders they
+     * behaviour, kept as the factory default so existing users aren't surprised by
-     * never asked for. Stored as a string so "none" is distinct from a numeric
+     * reminders they never asked for. Stored as a comma-joined list of minutes, or
-     * value (and from an unset key, which is also "none"). Per-calendar overrides
+     * "none"/empty for no reminder (also the unset state). A legacy single value
-     * in [perCalendarReminderOverride] take precedence; all-day events instead use
+     * ("30") parses transparently to a one-element list. Per-calendar overrides in
+     * [perCalendarReminderOverride] take precedence; all-day events instead use
      * [defaultAllDayReminderMinutes]. Resolve with [resolveDefaultReminder].
      */
-    val defaultReminderMinutes: Flow<Int?> = store.data.map { prefs ->
+    val defaultReminderMinutes: Flow<List<Int>> = store.data.map { prefs ->
-        prefs[DEFAULT_REMINDER_KEY].toReminderMinutes()
+        prefs[DEFAULT_REMINDER_KEY].toReminderList()
     }
 
-    suspend fun setDefaultReminderMinutes(minutes: Int?) {
+    suspend fun setDefaultReminderMinutes(minutes: List<Int>) {
-        store.edit { it[DEFAULT_REMINDER_KEY] = minutes?.toString() ?: NONE }
+        store.edit { it[DEFAULT_REMINDER_KEY] = minutes.toStoredReminders() }
     }
 
     /**
-     * The default reminder lead time prefilled on new **all-day** events, in
+     * The default reminder lead times prefilled on new **all-day** events, in
      * minutes before the start of the day. All-day events want day-scale lead
      * times ("1 day before"), so they have their own default rather than reusing
-     * the timed one. `null` = no default. Per-calendar overrides do **not** apply
+     * the timed one. Empty list = no default. Per-calendar overrides do **not**
-     * to all-day events — they always use this global value.
+     * apply to all-day events — they always use this global value.
      */
-    val defaultAllDayReminderMinutes: Flow<Int?> = store.data.map { prefs ->
+    val defaultAllDayReminderMinutes: Flow<List<Int>> = store.data.map { prefs ->
-        prefs[DEFAULT_ALLDAY_REMINDER_KEY].toReminderMinutes()
+        prefs[DEFAULT_ALLDAY_REMINDER_KEY].toReminderList()
     }
 
-    suspend fun setDefaultAllDayReminderMinutes(minutes: Int?) {
+    suspend fun setDefaultAllDayReminderMinutes(minutes: List<Int>) {
-        store.edit { it[DEFAULT_ALLDAY_REMINDER_KEY] = minutes?.toString() ?: NONE }
+        store.edit { it[DEFAULT_ALLDAY_REMINDER_KEY] = minutes.toStoredReminders() }
     }
 
     /**
@@ -303,13 +342,13 @@ class SettingsPrefs @Inject constructor(
     /**
      * Per-calendar overrides of [defaultReminderMinutes] for **timed** events,
      * keyed by calendar id. A calendar **present** in the map overrides the global
-     * timed default for its new events: a `null` value means "no reminder", an int
+     * timed default for its new events: an **empty** list means "no reminder", a
-     * means that lead time. A calendar **absent** from the map inherits the global
+     * non-empty list means those lead times. A calendar **absent** from the map
-     * default. Serialised as `id=value;id=value`, with `none` for an explicit
+     * inherits the global default. Serialised as `id=value;id=value`, where a value
-     * no-reminder override. (All-day events ignore this and use
+     * is a comma-joined minute list or `none` for an explicit no-reminder override.
-     * [defaultAllDayReminderMinutes].)
+     * (All-day events ignore this and use [defaultAllDayReminderMinutes].)
      */
-    val perCalendarReminderOverride: Flow<Map<Long, Int?>> = store.data.map { prefs ->
+    val perCalendarReminderOverride: Flow<Map<Long, List<Int>>> = store.data.map { prefs ->
         parseReminderOverrides(prefs[CALENDAR_REMINDER_OVERRIDE_KEY])
     }
 
@@ -326,7 +365,7 @@ class SettingsPrefs @Inject constructor(
      * events, with the same semantics as [perCalendarReminderOverride] (absent =
      * inherit the global all-day default; present null = no reminder).
      */
-    val perCalendarAllDayReminderOverride: Flow<Map<Long, Int?>> = store.data.map { prefs ->
+    val perCalendarAllDayReminderOverride: Flow<Map<Long, List<Int>>> = store.data.map { prefs ->
         parseReminderOverrides(prefs[CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY])
     }
 
@@ -404,6 +443,8 @@ class SettingsPrefs @Inject constructor(
         internal val AGENDA_SHOW_RANGE_BAR_KEY = booleanPreferencesKey("agenda_show_range_bar")
         internal val TIME_FORMAT_KEY = stringPreferencesKey("time_format")
         internal val SHOW_HOUR_LINES_KEY = booleanPreferencesKey("show_hour_lines")
+        internal val PAST_EVENT_DISPLAY_KEY = stringPreferencesKey("agenda_past_event_display")
+        internal val DIM_COMPLETED_EVENTS_KEY = booleanPreferencesKey("dim_completed_events")
         internal val DEFAULT_VIEW_KEY = stringPreferencesKey("default_view")
         internal val FORM_FIELDS_KEY = stringPreferencesKey("event_form_default_fields")
         internal val AUTOFOCUS_EVENT_TITLE_KEY = booleanPreferencesKey("autofocus_event_title")
@@ -455,43 +496,46 @@ sealed interface CalendarReminderOverride {
     data object Inherit : CalendarReminderOverride
     /** Explicit "no reminder" for this calendar, regardless of the global default. */
     data object None : CalendarReminderOverride
-    /** A specific lead time in minutes before the event start. */
+    /** Specific lead times in minutes before the event start (non-empty). */
-    data class Minutes(val minutes: Int) : CalendarReminderOverride
+    data class Minutes(val minutes: List<Int>) : CalendarReminderOverride
 }
 
 /**
- * The lead time to prefill on a new event: the matching per-calendar override
+ * The lead times to prefill on a new event: the matching per-calendar override
  * if [calendarId] has one for this event kind, otherwise the global default for
  * that kind. All-day events consult [allDayOverrides] / [allDayGlobal]; timed
- * events consult [timedOverrides] / [timedGlobal]. `null` = no reminder. Pure so
+ * events consult [timedOverrides] / [timedGlobal]. The empty list = no reminder.
- * it can be unit-tested.
+ * Pure so it can be unit-tested.
  */
 fun resolveDefaultReminder(
-    timedGlobal: Int?,
+    timedGlobal: List<Int>,
-    allDayGlobal: Int?,
+    allDayGlobal: List<Int>,
-    timedOverrides: Map<Long, Int?>,
+    timedOverrides: Map<Long, List<Int>>,
-    allDayOverrides: Map<Long, Int?>,
+    allDayOverrides: Map<Long, List<Int>>,
     calendarId: Long?,
     isAllDay: Boolean,
-): Int? {
+): List<Int> {
     val overrides = if (isAllDay) allDayOverrides else timedOverrides
     val global = if (isAllDay) allDayGlobal else timedGlobal
     return if (calendarId != null && overrides.containsKey(calendarId)) {
-        overrides[calendarId]
+        overrides.getValue(calendarId)
     } else {
         global
     }
 }
 
-/** Apply a [CalendarReminderOverride] to an override map ([Inherit] removes the key). */
+/**
-private fun MutableMap<Long, Int?>.applyOverride(
+ * Apply a [CalendarReminderOverride] to an override map ([Inherit] removes the
+ * key; [None] and an empty [Minutes] both store the empty list).
+ */
+private fun MutableMap<Long, List<Int>>.applyOverride(
     calendarId: Long,
     override: CalendarReminderOverride,
 ) {
     when (override) {
         CalendarReminderOverride.Inherit -> remove(calendarId)
-        CalendarReminderOverride.None -> put(calendarId, null)
+        CalendarReminderOverride.None -> put(calendarId, emptyList())
-        is CalendarReminderOverride.Minutes -> put(calendarId, override.minutes)
+        is CalendarReminderOverride.Minutes -> put(calendarId, override.minutes.normalizeReminders())
     }
 }
 
@@ -517,24 +561,36 @@ private fun parseWeekStart(stored: String?): WeekStartPref = when (stored) {
 private const val NONE = "none"
 private const val ENTRY_SEP = ";"
 private const val KEY_VALUE_SEP = "="
+private const val LIST_SEP = ","
 
-private fun String?.toReminderMinutes(): Int? = when (this) {
+/** Distinct, ascending lead times — the canonical form stored and resolved. */
-    null, "", NONE -> null
+private fun List<Int>.normalizeReminders(): List<Int> = distinct().sorted()
-    else -> toIntOrNull()
+
+/**
+ * Parse a stored reminder value into lead times. `null`/empty/"none" → empty
+ * list; a comma-joined list → its minutes; a legacy single value ("30") → a
+ * one-element list. Non-numeric parts are dropped defensively.
+ */
+private fun String?.toReminderList(): List<Int> = when {
+    this == null || isEmpty() || this == NONE -> emptyList()
+    else -> split(LIST_SEP).mapNotNull { it.trim().toIntOrNull() }.normalizeReminders()
 }
 
-private fun parseReminderOverrides(stored: String?): Map<Long, Int?> {
+/** Serialise lead times for storage: "none" when empty, else comma-joined. */
+private fun List<Int>.toStoredReminders(): String =
+    if (isEmpty()) NONE else normalizeReminders().joinToString(LIST_SEP) { it.toString() }
+
+private fun parseReminderOverrides(stored: String?): Map<Long, List<Int>> {
     if (stored.isNullOrBlank()) return emptyMap()
     return stored.split(ENTRY_SEP).mapNotNull { entry ->
         val parts = entry.split(KEY_VALUE_SEP).takeIf { it.size == 2 } ?: return@mapNotNull null
         val id = parts[0].toLongOrNull() ?: return@mapNotNull null
-        val value = if (parts[1] == NONE) null else parts[1].toIntOrNull() ?: return@mapNotNull null
+        id to parts[1].toReminderList()
-        id to value
     }.toMap()
 }
 
-private fun serializeReminderOverrides(map: Map<Long, Int?>): String =
+private fun serializeReminderOverrides(map: Map<Long, List<Int>>): String =
-    map.entries.joinToString(ENTRY_SEP) { (id, minutes) -> "$id$KEY_VALUE_SEP${minutes ?: NONE}" }
+    map.entries.joinToString(ENTRY_SEP) { (id, minutes) -> "$id$KEY_VALUE_SEP${minutes.toStoredReminders()}" }
 
 private inline fun <reified E : Enum<E>> String?.toEnum(default: E): E =
     this?.let { stored -> enumValues<E>().firstOrNull { it.name == stored } } ?: default

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/EventReminderReceiver.kt

@@ -8,6 +8,7 @@ import android.content.pm.PackageManager
 import android.provider.CalendarContract
 import androidx.core.content.ContextCompat
 import dagger.hilt.android.AndroidEntryPoint
+import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -16,6 +17,17 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
+/**
+ * The due alerts that should actually surface as notifications: everything
+ * except alerts whose calendar the user has disabled in-app (mirroring the
+ * event filtering in CalendarRepositoryImpl). The caller still marks the full
+ * due set fired, so suppressed alerts are not re-broadcast by the provider.
+ */
+internal fun postableAlerts(
+    due: List<ReminderAlert>,
+    disabledCalendarIds: Set<Long>,
+): List<ReminderAlert> = due.filterNot { it.calendarId in disabledCalendarIds }
+
 /**
  * Becomes the app that turns the calendar provider's reminder alarms into
  * visible notifications (the Etar model — the provider broadcasts
@@ -32,6 +44,7 @@ class EventReminderReceiver : BroadcastReceiver() {
     @Inject lateinit var alertStore: ReminderAlertStore
     @Inject lateinit var notifier: ReminderNotifier
     @Inject lateinit var settingsPrefs: SettingsPrefs
+    @Inject lateinit var calendarPrefs: CalendarPrefs
 
     override fun onReceive(context: Context, intent: Intent) {
         if (intent.action != CalendarContract.ACTION_EVENT_REMINDER) return
@@ -46,7 +59,11 @@ class EventReminderReceiver : BroadcastReceiver() {
                 if (settingsPrefs.remindersEnabled.first()) {
                     val now = System.currentTimeMillis()
                     val due = alertStore.dueAlerts(now)
-                    due.forEach { notifier.post(it) }
+                    val disabled = calendarPrefs.disabledCalendarIds.first()
+                    // Suppress reminders for disabled calendars, but still mark
+                    // every due alert fired so the provider stops re-broadcasting
+                    // the suppressed ones.
+                    postableAlerts(due, disabled).forEach { notifier.post(it) }
                     alertStore.markFired(due.map { it.alertId }, now)
                 }
             } finally {

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderActionReceiver.kt

@@ -75,6 +75,7 @@ class ReminderActionReceiver : BroadcastReceiver() {
 
         private const val EXTRA_ALERT_ID = "alert_id"
         private const val EXTRA_EVENT_ID = "event_id"
+        private const val EXTRA_CALENDAR_ID = "calendar_id"
         private const val EXTRA_BEGIN = "begin"
         private const val EXTRA_END = "end"
         private const val EXTRA_TITLE = "title"
@@ -87,6 +88,7 @@ class ReminderActionReceiver : BroadcastReceiver() {
                 this.action = action
                 putExtra(EXTRA_ALERT_ID, alert.alertId)
                 putExtra(EXTRA_EVENT_ID, alert.eventId)
+                putExtra(EXTRA_CALENDAR_ID, alert.calendarId)
                 putExtra(EXTRA_BEGIN, alert.beginMillis)
                 putExtra(EXTRA_END, alert.endMillis)
                 putExtra(EXTRA_TITLE, alert.title)
@@ -113,6 +115,7 @@ class ReminderActionReceiver : BroadcastReceiver() {
             return ReminderAlert(
                 alertId = intent.getLongExtra(EXTRA_ALERT_ID, 0L),
                 eventId = intent.getLongExtra(EXTRA_EVENT_ID, 0L),
+                calendarId = intent.getLongExtra(EXTRA_CALENDAR_ID, 0L),
                 beginMillis = intent.getLongExtra(EXTRA_BEGIN, 0L),
                 endMillis = intent.getLongExtra(EXTRA_END, 0L),
                 title = intent.getStringExtra(EXTRA_TITLE).orEmpty(),

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderAlertStore.kt

@@ -16,6 +16,7 @@ import javax.inject.Singleton
 data class ReminderAlert(
     val alertId: Long,
     val eventId: Long,
+    val calendarId: Long,
     val beginMillis: Long,
     val endMillis: Long,
     /** Raw event title; may be blank — the notifier substitutes "(no title)". */
@@ -66,11 +67,12 @@ class AndroidReminderAlertStore @Inject constructor(
                     ReminderAlert(
                         alertId = c.getLong(0),
                         eventId = c.getLong(1),
-                        beginMillis = c.getLong(2),
+                        calendarId = c.getLong(2),
-                        endMillis = c.getLong(3),
+                        beginMillis = c.getLong(3),
-                        title = c.getString(4).orEmpty(),
+                        endMillis = c.getLong(4),
-                        location = c.getString(5)?.takeIf { it.isNotBlank() },
+                        title = c.getString(5).orEmpty(),
-                        isAllDay = c.getInt(6) == 1,
+                        location = c.getString(6)?.takeIf { it.isNotBlank() },
+                        isAllDay = c.getInt(7) == 1,
                     ),
                 )
             }
@@ -102,6 +104,7 @@ class AndroidReminderAlertStore @Inject constructor(
         val PROJECTION = arrayOf(
             CalendarContract.CalendarAlerts._ID,
             CalendarContract.CalendarAlerts.EVENT_ID,
+            CalendarContract.CalendarAlerts.CALENDAR_ID,
             CalendarContract.CalendarAlerts.BEGIN,
             CalendarContract.CalendarAlerts.END,
             CalendarContract.CalendarAlerts.TITLE,

app/src/main/java/de/jeanlucmakiola/calendula/domain/Models.kt

@@ -40,6 +40,14 @@ data class EventInstance(
     val location: String?,
 )
 
+/**
+ * Whether this event has finished relative to [now] — its end is at or before
+ * the current instant. An in-progress event (already started but not yet ended)
+ * is *not* considered ended. All-day events end at the exclusive next-midnight,
+ * so they only count as ended once their day is fully over.
+ */
+fun EventInstance.hasEnded(now: Instant): Boolean = end <= now
+
 data class EventDetail(
     val instance: EventInstance,
     val description: String?,

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

@@ -45,6 +45,7 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.res.stringResource
@@ -53,7 +54,9 @@ import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.hasEnded
 import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
 import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
 import de.jeanlucmakiola.calendula.ui.common.calendarAnimateItem
@@ -61,12 +64,14 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 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.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.GroupedRow
 import de.jeanlucmakiola.calendula.ui.common.Position
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.positionOf
+import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
@@ -96,6 +101,7 @@ fun AgendaScreen(
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
     val anchor by viewModel.anchor.collectAsStateWithLifecycle()
+    val pastDisplay by viewModel.pastEventDisplay.collectAsStateWithLifecycle()
 
     val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
     val drawerState = rememberDrawerState(DrawerValue.Closed)
@@ -178,6 +184,7 @@ fun AgendaScreen(
                 }
                 AgendaContent(
                     state = state,
+                    pastDisplay = pastDisplay,
                     onRetry = viewModel::goToToday,
                     onEventClick = onEventClick,
                     modifier = Modifier
@@ -275,6 +282,7 @@ private fun AgendaRangeBanner(
 @Composable
 private fun AgendaContent(
     state: AgendaUiState,
+    pastDisplay: PastEventDisplay,
     onRetry: () -> Unit,
     onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
@@ -284,19 +292,42 @@ private fun AgendaContent(
         is AgendaUiState.Failure -> Box(modifier) {
             CalendarFailure(reason = state.reason, onRetry = onRetry)
         }
-        is AgendaUiState.Success ->
+        is AgendaUiState.Success -> {
-            if (state.days.isEmpty()) {
+            val now by rememberCurrentMinute()
+            // Hiding drops finished events — and any day they leave empty; dimming
+            // keeps them but fades the row. Recomputed each minute so events fall
+            // away (or fade) as they end while the screen stays open.
+            val days = if (pastDisplay == PastEventDisplay.HIDE) {
+                state.days.mapNotNull { day ->
+                    val remaining = day.events.filterNot { it.hasEnded(now) }
+                    if (remaining.isEmpty()) null else day.copy(events = remaining)
+                }
+            } else {
+                state.days
+            }
+            if (days.isEmpty()) {
                 AgendaEmpty(modifier)
             } else {
-                AgendaList(state = state, onEventClick = onEventClick, modifier = modifier)
+                AgendaList(
+                    days = days,
+                    today = state.today,
+                    dimPast = pastDisplay == PastEventDisplay.DIM,
+                    now = now,
+                    onEventClick = onEventClick,
+                    modifier = modifier,
+                )
             }
+        }
     }
 }
 
 @OptIn(ExperimentalFoundationApi::class)
 @Composable
 private fun AgendaList(
-    state: AgendaUiState.Success,
+    days: List<AgendaDay>,
+    today: LocalDate,
+    dimPast: Boolean,
+    now: Instant,
     onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
 ) {
@@ -305,9 +336,9 @@ private fun AgendaList(
         // Bottom inset clears the FAB stack so the last row stays tappable.
         contentPadding = PaddingValues(top = 8.dp, bottom = 96.dp),
     ) {
-        state.days.forEach { day ->
+        days.forEach { day ->
             stickyHeader(key = "header-${day.date}") {
-                AgendaDayHeader(date = day.date, today = state.today)
+                AgendaDayHeader(date = day.date, today = today)
             }
             itemsIndexed(
                 items = day.events,
@@ -316,6 +347,7 @@ private fun AgendaList(
                 AgendaEventRow(
                     event = event,
                     position = positionOf(index, day.events.size),
+                    dimmed = dimPast && event.hasEnded(now),
                     modifier = calendarAnimateItem(),
                     onClick = { onEventClick(event) },
                 )
@@ -348,13 +380,14 @@ private fun AgendaDayHeader(date: LocalDate, today: LocalDate) {
 private fun AgendaEventRow(
     event: EventInstance,
     position: Position,
+    dimmed: Boolean,
     modifier: Modifier = Modifier,
     onClick: () -> Unit,
 ) {
     val dark = isSystemInDarkTheme()
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     GroupedRow(
-        modifier = modifier,
+        modifier = if (dimmed) modifier.alpha(EventDimAlpha) else modifier,
         title = title,
         summary = agendaTimeSummary(event),
         position = position,

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

@@ -5,6 +5,7 @@ import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.CalendarSource
@@ -53,6 +54,18 @@ class AgendaViewModel @Inject constructor(
     private val weekStartDay = settingsPrefs.weekStart
         .map { it.resolveFirstDay(Locale.getDefault()) }
 
+    /**
+     * How to treat events that already ended today (show / dim / hide). A display
+     * concern only, so it rides alongside the data state rather than re-querying;
+     * the screen combines it with a per-minute "now" to fade or drop past rows.
+     */
+    val pastEventDisplay: StateFlow<PastEventDisplay> = settingsPrefs.pastEventDisplay
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = PastEventDisplay.SHOW,
+        )
+
     private val zone = TimeZone.currentSystemDefault()
 
     private val todayDate: LocalDate

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

@@ -0,0 +1,50 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.zIndex
+
+/**
+ * A Flutter-style "DEBUG" corner ribbon, drawn across the top-right corner of
+ * the app. Deliberately a stark, un-themed marker (not a product component) so a
+ * debug build is unmistakable at a glance — gate it on `BuildConfig.DEBUG` at the
+ * call site so it never reaches a release build. Non-interactive: it's a plain
+ * label with no pointer handler, so taps fall through to whatever is beneath it.
+ *
+ * Drop it in as the last child of a full-screen [androidx.compose.foundation.layout.Box]
+ * so it overlays the UI.
+ */
+@Composable
+fun BoxScope.DebugRibbon() {
+    Text(
+        text = "DEBUG",
+        color = Color.White,
+        fontSize = 10.sp,
+        fontWeight = FontWeight.Bold,
+        letterSpacing = 1.sp,
+        textAlign = TextAlign.Center,
+        modifier = Modifier
+            .align(Alignment.TopEnd)
+            .zIndex(1f)
+            // Push the band out so its midline crosses the very corner, then
+            // rotate it to the classic 45° ribbon.
+            .offset(x = 36.dp, y = 24.dp)
+            .rotate(45f)
+            .background(Color(0xFFB23B00))
+            .width(140.dp)
+            .padding(vertical = 2.dp),
+    )
+}

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

@@ -34,7 +34,7 @@ private val LineThickness = 2.dp
  * the middle of a minute. Drives the "now" line in the day/week grids.
  */
 @Composable
-private fun rememberCurrentMinute(): State<Instant> {
+fun rememberCurrentMinute(): State<Instant> {
     val instant = remember { mutableStateOf(Clock.System.now()) }
     LaunchedEffect(Unit) {
         while (true) {

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

@@ -0,0 +1,16 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.runtime.compositionLocalOf
+import kotlin.time.Instant
+
+/**
+ * The cut-off instant before which a calendar event counts as "completed" and is
+ * drawn dimmed in the month/week grids — i.e. the current wall-clock minute when
+ * the "dim completed events" setting is on, or `null` when it is off (nothing
+ * dims). Provided per grid screen so only the event chips that read it recompose
+ * as the minute ticks, mirroring [LocalShowHourLines] / [LocalUse24HourFormat].
+ */
+val LocalDimCutoff = compositionLocalOf<Instant?> { null }
+
+/** Opacity applied to a completed/past event chip when it is dimmed. */
+const val EventDimAlpha = 0.4f

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

@@ -13,6 +13,7 @@ import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Check
+import androidx.compose.material3.Checkbox
 import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
@@ -26,6 +27,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -111,10 +113,15 @@ fun <T> OptionPicker(
 }
 
 /**
- * Reminder-default picker, full-screen: the grouped list (with an optional "Use
+ * Reminder-default picker, full-screen and **multi-select**: each [presets]
- * default reminder" row and a "None" row), the [presets] as lead-time rows, and
+ * lead time (plus any chosen custom value) is a checkbox row that toggles
- * a "Custom" row that expands an inline number field plus a segmented unit
+ * independently, so a default can carry several reminders ("1 week before" *and*
- * selector. Returns the choice as a [CalendarReminderOverride].
+ * "on the day"). A per-calendar picker ([allowInherit]) gains an exclusive "Use
+ * default reminder" row above the list; choosing it defers to the global default
+ * and clears the checked times. With nothing checked and inherit off, the choice
+ * is [CalendarReminderOverride.None] (an explicit no-reminder). A "Custom" row
+ * expands an inline number field plus a unit selector to add an arbitrary lead
+ * time to the set. Changes apply live via [onSelect]; the user leaves via back.
  */
 @Composable
 fun ReminderDefaultPicker(
@@ -125,57 +132,74 @@ fun ReminderDefaultPicker(
     onSelect: (CalendarReminderOverride) -> Unit,
     onDismiss: () -> Unit,
 ) {
-    val selectedMinutes = (selected as? CalendarReminderOverride.Minutes)?.minutes
+    // Optimistic local state: the chosen override is authoritative while the
-    val customSelected = selectedMinutes != null && selectedMinutes !in presets
+    // picker is open, so quick successive toggles compose on each other instead
-    val seed = decomposeReminder(selectedMinutes?.takeIf { customSelected })
+    // of racing the round-trip through the settings flow (which would drop a
+    // toggle made before the previous write echoes back). Seeded once on open;
+    // the picker leaves composition on dismiss, so reopening re-reads [selected].
+    var current by remember { mutableStateOf(selected) }
+    val inherits = current is CalendarReminderOverride.Inherit
+    val selectedMinutes = (current as? CalendarReminderOverride.Minutes)?.minutes.orEmpty()
+    // Presets plus any selected custom (non-preset) values, each as its own row.
+    val rows = presets + selectedMinutes.filter { it !in presets }.sorted()
 
     var customExpanded by rememberSaveable { mutableStateOf(false) }
-    var amountText by rememberSaveable { mutableStateOf(seed.first) }
+    var amountText by rememberSaveable { mutableStateOf("") }
-    var unit by rememberSaveable { mutableStateOf(seed.second) }
+    var unit by rememberSaveable { mutableStateOf(ReminderUnit.Minutes) }
 
-    val options = buildList {
+    fun apply(override: CalendarReminderOverride) {
-        if (allowInherit) add(CalendarReminderOverride.Inherit)
+        current = override
-        add(CalendarReminderOverride.None)
+        onSelect(override)
-        presets.forEach { add(CalendarReminderOverride.Minutes(it)) }
     }
-    val rowCount = options.size + 1 // + the custom row
+    // Emit the override for a new set of minutes: empty collapses to None, which
+    // (with inherit unchosen) reads as an explicit "no reminder".
+    fun emit(minutes: List<Int>) {
+        val norm = minutes.distinct().sorted()
+        apply(
+            if (norm.isEmpty()) {
+                CalendarReminderOverride.None
+            } else {
+                CalendarReminderOverride.Minutes(norm)
+            },
+        )
+    }
+    fun toggle(minute: Int) =
+        emit(if (minute in selectedMinutes) selectedMinutes - minute else selectedMinutes + minute)
 
     FullScreenPicker(title = title, onDismiss = onDismiss) {
-        options.forEachIndexed { index, option ->
+        // Exclusive "use default" choice (per-calendar only): its own group above
-            val isSelected = option == selected
+        // the multi-select list, since inheriting is mutually exclusive with
+        // picking specific times.
+        if (allowInherit) {
             GroupedRow(
-                title = reminderOverrideLabel(option),
+                title = stringResource(R.string.reminder_use_default),
-                position = positionOf(index, rowCount),
+                position = Position.Alone,
-                selected = isSelected,
+                selected = inherits,
-                trailing = if (isSelected) {
+                trailing = if (inherits) {
                     { SelectedCheck() }
                 } else {
                     null
                 },
-                onClick = {
+                onClick = { apply(CalendarReminderOverride.Inherit) },
-                    onSelect(option)
+            )
-                    onDismiss()
+            Spacer(Modifier.height(24.dp))
-                },
+        }
+        val rowCount = rows.size + 1 // + the custom row
+        rows.forEachIndexed { index, minute ->
+            val checked = minute in selectedMinutes
+            GroupedRow(
+                title = reminderLeadTimeLabel(minute),
+                position = positionOf(index, rowCount),
+                selected = checked,
+                trailing = { Checkbox(checked = checked, onCheckedChange = { toggle(minute) }) },
+                onClick = { toggle(minute) },
             )
         }
         // When expanded, the Custom row connects downward into the editor card
         // so the two read as one grouped container (the per-calendar pattern).
         GroupedRow(
-            title = if (customSelected) {
+            title = stringResource(R.string.event_edit_reminder_custom),
-                stringResource(
+            position = if (customExpanded) Position.Top else positionOf(rows.size, rowCount),
-                    R.string.reminder_custom_with_value,
-                    reminderLeadTimeLabel(selectedMinutes!!),
-                )
-            } else {
-                stringResource(R.string.event_edit_reminder_custom)
-            },
-            position = if (customExpanded) Position.Top else positionOf(options.size, rowCount),
-            selected = customSelected,
-            trailing = if (customSelected) {
-                { SelectedCheck() }
-            } else {
-                null
-            },
             onClick = { customExpanded = !customExpanded },
         )
         AnimatedVisibility(
@@ -189,8 +213,9 @@ fun ReminderDefaultPicker(
                 unit = unit,
                 onUnitChange = { unit = it },
                 onConfirm = { minutes ->
-                    onSelect(CalendarReminderOverride.Minutes(minutes))
+                    emit(selectedMinutes + minutes)
-                    onDismiss()
+                    amountText = ""
+                    customExpanded = false
                 },
             )
         }
@@ -428,18 +453,3 @@ fun agendaRangeLabel(range: AgendaRange): String = when (range) {
     is AgendaRange.Custom -> pluralStringResource(R.plurals.agenda_range_days, range.days, range.days)
 }
 
-@Composable
-private fun reminderOverrideLabel(override: CalendarReminderOverride): String = when (override) {
-    CalendarReminderOverride.Inherit -> stringResource(R.string.reminder_use_default)
-    CalendarReminderOverride.None -> stringResource(R.string.reminder_none)
-    is CalendarReminderOverride.Minutes -> reminderLeadTimeLabel(override.minutes)
-}
-
-/** Seed the custom editor: the largest exact unit for [minutes] (null → empty). */
-private fun decomposeReminder(minutes: Int?): Pair<String, ReminderUnit> = when {
-    minutes == null -> "" to ReminderUnit.Minutes
-    minutes % 10_080 == 0 -> (minutes / 10_080).toString() to ReminderUnit.Weeks
-    minutes % 1_440 == 0 -> (minutes / 1_440).toString() to ReminderUnit.Days
-    minutes % 60 == 0 -> (minutes / 60).toString() to ReminderUnit.Hours
-    else -> minutes.toString() to ReminderUnit.Minutes
-}

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

@@ -108,10 +108,10 @@ class EventEditViewModel @Inject constructor(
     )
 
     private data class ReminderDefaults(
-        val timed: Int?,
+        val timed: List<Int>,
-        val allDay: Int?,
+        val allDay: List<Int>,
-        val timedOverrides: Map<Long, Int?>,
+        val timedOverrides: Map<Long, List<Int>>,
-        val allDayOverrides: Map<Long, Int?>,
+        val allDayOverrides: Map<Long, List<Int>>,
     )
 
     private data class ExternalInputs(
@@ -260,7 +260,7 @@ class EventEditViewModel @Inject constructor(
             // Re-check after suspending: bail if the form closed or the user edited.
             val form = _form.value ?: return@launch
             if (_editTarget.value != null || _remindersTouched.value) return@launch
-            val default = resolveDefaultReminder(
+            val reminders = resolveDefaultReminder(
                 timedGlobal = defaults.timed,
                 allDayGlobal = defaults.allDay,
                 timedOverrides = defaults.timedOverrides,
@@ -268,7 +268,6 @@ class EventEditViewModel @Inject constructor(
                 calendarId = targetId,
                 isAllDay = form.isAllDay,
             )
-            val reminders = listOfNotNull(default)
             _form.value = form.copy(reminders = reminders)
             // Surface the section so an auto-applied default is visible and
             // removable, even when Reminders isn't a default-shown field.

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

@@ -36,6 +36,8 @@ import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableIntStateOf
@@ -44,6 +46,7 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.graphics.Color
@@ -60,10 +63,14 @@ import androidx.compose.ui.unit.dp
 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.CalendarDrawer
 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.EventDimAlpha
+import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
+import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
@@ -97,6 +104,14 @@ fun MonthScreen(
     val state by viewModel.state.collectAsStateWithLifecycle()
     val month by viewModel.month.collectAsStateWithLifecycle()
     val weekStart by viewModel.weekStart.collectAsStateWithLifecycle()
+    val dimCompleted by viewModel.dimCompletedEvents.collectAsStateWithLifecycle()
+    // The instant before which an event counts as completed, or null when dimming
+    // is off. derivedStateOf keeps the per-minute "now" from recomposing the
+    // screen while the setting is off (it stays null regardless of the tick).
+    val nowState = rememberCurrentMinute()
+    val dimCutoff by remember(dimCompleted) {
+        derivedStateOf { if (dimCompleted) nowState.value else null }
+    }
 
     val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
     val drawerState = rememberDrawerState(DrawerValue.Closed)
@@ -193,14 +208,16 @@ fun MonthScreen(
                     .fillMaxSize(),
             ) {
                 WeekdayHeader(weekStart = weekStart)
-                MonthContent(
+                CompositionLocalProvider(LocalDimCutoff provides dimCutoff) {
-                    state = state,
+                    MonthContent(
-                    slideDir = slideDir,
+                        state = state,
-                    onSwipeNext = goNext,
+                        slideDir = slideDir,
-                    onSwipePrev = goPrev,
+                        onSwipeNext = goNext,
-                    onRetry = jumpToToday,
+                        onSwipePrev = goPrev,
-                    onOpenDay = onOpenDay,
+                        onRetry = jumpToToday,
-                )
+                        onOpenDay = onOpenDay,
+                    )
+                }
             }
         }
     }
@@ -558,6 +575,8 @@ private fun MonthBar(
     modifier: Modifier = Modifier,
 ) {
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
+    val dimCutoff = LocalDimCutoff.current
+    val dimmed = dimCutoff != null && event.hasEnded(dimCutoff)
     val shape = RoundedCornerShape(
         topStart = if (continuesLeft) 0.dp else 4.dp,
         bottomStart = if (continuesLeft) 0.dp else 4.dp,
@@ -565,7 +584,7 @@ private fun MonthBar(
         bottomEnd = if (continuesRight) 0.dp else 4.dp,
     )
     Box(
-        modifier = modifier
+        modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
             .background(pastelize(event.color, dark), shape)
             .padding(horizontal = 4.dp)
             .semantics { contentDescription = title },

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

@@ -59,6 +59,14 @@ class MonthViewModel @Inject constructor(
             initialValue = DayOfWeek.MONDAY,
         )
 
+    /** Whether to fade events that have already finished (display concern only). */
+    val dimCompletedEvents: StateFlow<Boolean> = settingsPrefs.dimCompletedEvents
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = false,
+        )
+
     private val todayDate: LocalDate
         get() = Clock.System.now().toLocalDateTime(zone).date
 

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

@@ -86,6 +86,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.crash.CrashReporter
 import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
+import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
@@ -475,6 +476,7 @@ private fun AppearanceScreen(
     var showDefaultView by remember { mutableStateOf(false) }
     var showAgendaScreenRange by remember { mutableStateOf(false) }
     var showAgendaWidgetRange by remember { mutableStateOf(false) }
+    var showPastEvents by remember { mutableStateOf(false) }
 
     CollapsingScaffold(
         title = stringResource(R.string.settings_section_appearance),
@@ -533,7 +535,7 @@ private fun AppearanceScreen(
         GroupedRow(
             title = stringResource(R.string.settings_hour_lines),
             summary = stringResource(R.string.settings_hour_lines_summary),
-            position = Position.Bottom,
+            position = Position.Middle,
             trailing = {
                 Switch(
                     checked = state.showHourLines,
@@ -542,16 +544,36 @@ private fun AppearanceScreen(
             },
             onClick = { viewModel.setShowHourLines(!state.showHourLines) },
         )
+        GroupedRow(
+            title = stringResource(R.string.settings_dim_completed),
+            summary = stringResource(R.string.settings_dim_completed_summary),
+            position = Position.Bottom,
+            trailing = {
+                Switch(
+                    checked = state.dimCompletedEvents,
+                    onCheckedChange = viewModel::setDimCompletedEvents,
+                )
+            },
+            onClick = { viewModel.setDimCompletedEvents(!state.dimCompletedEvents) },
+        )
 
         Spacer(Modifier.height(16.dp))
 
-        // Agenda
+        // Agenda — the only group labelled, so its agenda-specific rows are easy
+        // to pick out among the otherwise unheadered Appearance settings.
+        SectionHeader(stringResource(R.string.settings_agenda_header))
         GroupedRow(
             title = stringResource(R.string.settings_agenda_range),
             summary = agendaRangeLabel(state.agendaScreenRange),
             position = Position.Top,
             onClick = { showAgendaScreenRange = true },
         )
+        GroupedRow(
+            title = stringResource(R.string.settings_past_events),
+            summary = pastEventDisplayLabel(state.pastEventDisplay),
+            position = Position.Middle,
+            onClick = { showPastEvents = true },
+        )
         GroupedRow(
             title = stringResource(R.string.settings_agenda_widget_range),
             summary = agendaRangeLabel(state.agendaWidgetRange),
@@ -620,6 +642,16 @@ private fun AppearanceScreen(
             onDismiss = { showTimeFormat = false },
         )
     }
+    if (showPastEvents) {
+        OptionPicker(
+            title = stringResource(R.string.settings_past_events),
+            options = PastEventDisplay.entries,
+            selected = state.pastEventDisplay,
+            label = { pastEventDisplayLabel(it) },
+            onSelect = viewModel::setPastEventDisplay,
+            onDismiss = { showPastEvents = false },
+        )
+    }
     if (showDefaultView) {
         OptionPicker(
             title = stringResource(R.string.settings_default_view),
@@ -937,7 +969,7 @@ private fun NotificationsScreen(
             presets = REMINDER_PRESETS,
             selected = state.defaultReminderMinutes.toReminderChoice(),
             allowInherit = false,
-            onSelect = { viewModel.setDefaultReminderMinutes(it.toMinutesOrNull()) },
+            onSelect = { viewModel.setDefaultReminderMinutes(it.toMinutesList()) },
             onDismiss = { showDefaultReminder = false },
         )
     }
@@ -947,7 +979,7 @@ private fun NotificationsScreen(
             presets = ALLDAY_REMINDER_PRESETS,
             selected = state.defaultAllDayReminderMinutes.toReminderChoice(),
             allowInherit = false,
-            onSelect = { viewModel.setDefaultAllDayReminderMinutes(it.toMinutesOrNull()) },
+            onSelect = { viewModel.setDefaultAllDayReminderMinutes(it.toMinutesList()) },
             onDismiss = { showAllDayReminder = false },
         )
     }
@@ -996,13 +1028,13 @@ private fun NotificationsScreen(
 /** Which calendar + event kind a per-calendar reminder-override dialog targets. */
 private data class OverrideTarget(val calendarId: Long, val isAllDay: Boolean)
 
-/** A global default (null = none) as a picker choice for selection highlighting. */
+/** A global default (empty = none) as a picker choice for selection highlighting. */
-private fun Int?.toReminderChoice(): CalendarReminderOverride =
+private fun List<Int>.toReminderChoice(): CalendarReminderOverride =
-    if (this == null) CalendarReminderOverride.None else CalendarReminderOverride.Minutes(this)
+    if (isEmpty()) CalendarReminderOverride.None else CalendarReminderOverride.Minutes(this)
 
 /** A picked choice as global-default minutes (Inherit isn't offered for globals). */
-private fun CalendarReminderOverride.toMinutesOrNull(): Int? =
+private fun CalendarReminderOverride.toMinutesList(): List<Int> =
-    (this as? CalendarReminderOverride.Minutes)?.minutes
+    (this as? CalendarReminderOverride.Minutes)?.minutes ?: emptyList()
 
 /**
  * Whether Calendula is exempt from battery optimisation, re-read on every
@@ -1077,27 +1109,33 @@ private fun formatTimeOfDay(context: Context, minutesOfDay: Int): String {
 }
 
 /** The stored override for [calendarId], as a picker choice (absent → inherit). */
-private fun Map<Long, Int?>.choiceFor(calendarId: Long): CalendarReminderOverride = when {
+private fun Map<Long, List<Int>>.choiceFor(calendarId: Long): CalendarReminderOverride = when {
     !containsKey(calendarId) -> CalendarReminderOverride.Inherit
-    this[calendarId] == null -> CalendarReminderOverride.None
+    this.getValue(calendarId).isEmpty() -> CalendarReminderOverride.None
-    else -> CalendarReminderOverride.Minutes(this.getValue(calendarId)!!)
+    else -> CalendarReminderOverride.Minutes(this.getValue(calendarId))
 }
 
-/** Label for a global-default choice: null → "None", else the lead time. */
+/** Label for a global-default choice: empty → "None", else the lead times joined. */
 @Composable
-private fun reminderChoiceLabel(minutes: Int?): String =
+private fun reminderChoiceLabel(minutes: List<Int>): String {
-    if (minutes == null) stringResource(R.string.reminder_none) else reminderLeadTimeLabel(minutes)
+    if (minutes.isEmpty()) return stringResource(R.string.reminder_none)
+    // reminderLeadTimeLabel is @Composable, so resolve each part in a loop rather
+    // than a (non-composable) joinToString transform.
+    val parts = ArrayList<String>(minutes.size)
+    for (m in minutes) parts.add(reminderLeadTimeLabel(m))
+    return parts.joinToString(", ")
+}
 
 /** Row summary for a calendar: its override, or the inherited global default. */
 @Composable
 private fun calendarOverrideSummary(
     choice: CalendarReminderOverride,
-    globalDefault: Int?,
+    globalDefault: List<Int>,
 ): String = when (choice) {
     CalendarReminderOverride.Inherit ->
         stringResource(R.string.settings_calendar_reminder_inherits, reminderChoiceLabel(globalDefault))
     CalendarReminderOverride.None -> stringResource(R.string.reminder_none)
-    is CalendarReminderOverride.Minutes -> reminderLeadTimeLabel(choice.minutes)
+    is CalendarReminderOverride.Minutes -> reminderChoiceLabel(choice.minutes)
 }
 
 // ---------------------------------------------------------------------------
@@ -1170,6 +1208,26 @@ private fun timeFormatLabel(pref: TimeFormatPref): String = stringResource(
     },
 )
 
+/** A small primary-coloured group label, matching the Calendars settings screen. */
+@Composable
+private fun SectionHeader(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.labelLarge,
+        color = MaterialTheme.colorScheme.primary,
+        modifier = Modifier.padding(start = 24.dp, end = 24.dp, top = 16.dp, bottom = 4.dp),
+    )
+}
+
+@Composable
+private fun pastEventDisplayLabel(mode: PastEventDisplay): String = stringResource(
+    when (mode) {
+        PastEventDisplay.SHOW -> R.string.settings_past_events_show
+        PastEventDisplay.DIM -> R.string.settings_past_events_dim
+        PastEventDisplay.HIDE -> R.string.settings_past_events_hide
+    },
+)
+
 @Composable
 private fun languageLabel(tag: String?): String =
     if (tag == null) stringResource(R.string.settings_language_auto) else AppLanguage.displayName(tag)

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
+import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
@@ -24,6 +25,10 @@ data class SettingsUiState(
     val timeFormat: TimeFormatPref = TimeFormatPref.AUTO,
     /** Whether the week/day timeline draws an hour separator line (v2.11). */
     val showHourLines: Boolean = false,
+    /** How the Agenda screen treats events that already ended today. */
+    val pastEventDisplay: PastEventDisplay = PastEventDisplay.SHOW,
+    /** Whether the month/week grids fade events that have already finished. */
+    val dimCompletedEvents: Boolean = false,
     /** How far ahead the in-app Agenda screen shows events (v2.11). */
     val agendaScreenRange: AgendaRange = AgendaRange.Month,
     /** How far ahead the agenda widget shows events (v2.11). */
@@ -39,24 +44,24 @@ data class SettingsUiState(
     /** Whether Calendula posts reminder notifications (v1.4). */
     val remindersEnabled: Boolean = true,
     /**
-     * The default reminder lead time (minutes) prefilled on new timed events;
+     * The default reminder lead times (minutes) prefilled on new timed events;
-     * null = no default reminder. Per-calendar overrides take precedence.
+     * empty = no default reminder. Per-calendar overrides take precedence.
      */
-    val defaultReminderMinutes: Int? = null,
+    val defaultReminderMinutes: List<Int> = emptyList(),
-    /** The default reminder lead time prefilled on new all-day events; null = none. */
+    /** The default reminder lead times prefilled on new all-day events; empty = none. */
-    val defaultAllDayReminderMinutes: Int? = null,
+    val defaultAllDayReminderMinutes: List<Int> = emptyList(),
     /** Wall-clock time (minutes from midnight) all-day reminders fire at; default 09:00. */
     val allDayReminderTimeMinutes: Int = SettingsPrefs.DEFAULT_ALLDAY_REMINDER_TIME,
     /** How long the notification "Snooze" action defers a reminder; default 10 min. */
     val snoozeMinutes: Int = SettingsPrefs.DEFAULT_SNOOZE_MINUTES,
     /**
      * Per-calendar overrides of [defaultReminderMinutes] for timed events: a
-     * calendar present in the map overrides the global default (null value = no
+     * calendar present in the map overrides the global default (empty value = no
      * reminder); absent = inherit the global default.
      */
-    val perCalendarReminderOverride: Map<Long, Int?> = emptyMap(),
+    val perCalendarReminderOverride: Map<Long, List<Int>> = emptyMap(),
     /** Per-calendar overrides of [defaultAllDayReminderMinutes] for all-day events. */
-    val perCalendarAllDayReminderOverride: Map<Long, Int?> = emptyMap(),
+    val perCalendarAllDayReminderOverride: Map<Long, List<Int>> = emptyMap(),
     /** Writable calendars, shown as per-calendar reminder-override rows. */
     val writableCalendars: List<CalendarSource> = emptyList(),
     /**

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

@@ -11,6 +11,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
+import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
@@ -20,6 +21,7 @@ import de.jeanlucmakiola.calendula.domain.EventFormField
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.storageValue
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.widget.agenda.AGENDA_PAST_DISPLAY_KEY
 import de.jeanlucmakiola.calendula.widget.agenda.AGENDA_RANGE_KEY
 import de.jeanlucmakiola.calendula.widget.agenda.AgendaWidget
 import de.jeanlucmakiola.calendula.widget.month.MonthWidget
@@ -99,6 +101,8 @@ class SettingsViewModel @Inject constructor(
             combine(
                 prefs.agendaShowRangeBar,
                 prefs.autofocusEventTitle,
+                prefs.pastEventDisplay,
+                prefs.dimCompletedEvents,
                 ::MiscSettings,
             ),
         ) { base, defaults, overrides, views, misc ->
@@ -110,6 +114,8 @@ class SettingsViewModel @Inject constructor(
                 showHourLines = views.showHourLines,
                 agendaShowRangeBar = misc.showRangeBar,
                 autofocusEventTitle = misc.autofocusEventTitle,
+                pastEventDisplay = misc.pastEventDisplay,
+                dimCompletedEvents = misc.dimCompletedEvents,
                 allowColorOnUnsupportedCalendars = defaults.allowColor,
                 defaultReminderMinutes = defaults.defaultReminder,
                 defaultAllDayReminderMinutes = defaults.allDayReminder,
@@ -133,15 +139,15 @@ class SettingsViewModel @Inject constructor(
 
     private data class ReminderDefaults(
         val allowColor: Boolean,
-        val defaultReminder: Int?,
+        val defaultReminder: List<Int>,
-        val allDayReminder: Int?,
+        val allDayReminder: List<Int>,
         val allDayReminderTime: Int,
         val snoozeMinutes: Int,
     )
 
     private data class ReminderOverrides(
-        val timed: Map<Long, Int?>,
+        val timed: Map<Long, List<Int>>,
-        val allDay: Map<Long, Int?>,
+        val allDay: Map<Long, List<Int>>,
         val calendars: List<CalendarSource>,
     )
 
@@ -156,6 +162,8 @@ class SettingsViewModel @Inject constructor(
     private data class MiscSettings(
         val showRangeBar: Boolean,
         val autofocusEventTitle: Boolean,
+        val pastEventDisplay: PastEventDisplay,
+        val dimCompletedEvents: Boolean,
     )
 
     fun setThemeMode(mode: ThemeMode) {
@@ -211,6 +219,26 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setShowHourLines(enabled) }
     }
 
+    fun setPastEventDisplay(mode: PastEventDisplay) {
+        viewModelScope.launch {
+            prefs.setPastEventDisplay(mode)
+            // The agenda widget honours this setting too, so push it into each
+            // instance's Glance state and recompose — same reliable-update path as
+            // setAgendaWidgetRange (updateAll alone won't re-run the data preamble).
+            widgetRefreshMutex.withLock {
+                val manager = GlanceAppWidgetManager(appContext)
+                manager.getGlanceIds(AgendaWidget::class.java).forEach { id ->
+                    updateAppWidgetState(appContext, id) { it[AGENDA_PAST_DISPLAY_KEY] = mode.name }
+                }
+                AgendaWidget().updateAll(appContext)
+            }
+        }
+    }
+
+    fun setDimCompletedEvents(enabled: Boolean) {
+        viewModelScope.launch { prefs.setDimCompletedEvents(enabled) }
+    }
+
     fun setDefaultView(view: CalendarView) {
         viewModelScope.launch { prefs.setDefaultView(view) }
     }
@@ -227,11 +255,11 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setAutofocusEventTitle(enabled) }
     }
 
-    fun setDefaultReminderMinutes(minutes: Int?) {
+    fun setDefaultReminderMinutes(minutes: List<Int>) {
         viewModelScope.launch { prefs.setDefaultReminderMinutes(minutes) }
     }
 
-    fun setDefaultAllDayReminderMinutes(minutes: Int?) {
+    fun setDefaultAllDayReminderMinutes(minutes: List<Int>) {
         viewModelScope.launch { prefs.setDefaultAllDayReminderMinutes(minutes) }
     }
 

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

@@ -45,7 +45,9 @@ import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableIntStateOf
@@ -55,6 +57,7 @@ import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.graphics.Color
@@ -73,11 +76,15 @@ 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.domain.hasEnded
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 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.EventDimAlpha
+import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
 import de.jeanlucmakiola.calendula.ui.common.NowLine
+import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
@@ -129,6 +136,14 @@ fun WeekScreen(
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
     val weekStart by viewModel.weekStartDate.collectAsStateWithLifecycle()
+    val dimCompleted by viewModel.dimCompletedEvents.collectAsStateWithLifecycle()
+    // The instant before which an event counts as completed, or null when dimming
+    // is off. derivedStateOf keeps the per-minute "now" from recomposing the
+    // screen while the setting is off (it stays null regardless of the tick).
+    val nowState = rememberCurrentMinute()
+    val dimCutoff by remember(dimCompleted) {
+        derivedStateOf { if (dimCompleted) nowState.value else null }
+    }
 
     val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
     val drawerState = rememberDrawerState(DrawerValue.Closed)
@@ -221,19 +236,21 @@ fun WeekScreen(
                 )
             },
         ) { innerPadding ->
-            WeekContent(
+            CompositionLocalProvider(LocalDimCutoff provides dimCutoff) {
-                state = state,
+                WeekContent(
-                slideDir = slideDir,
+                    state = state,
-                topSectionColor = topSectionColor,
+                    slideDir = slideDir,
-                onSwipeNext = goNext,
+                    topSectionColor = topSectionColor,
-                onSwipePrev = goPrev,
+                    onSwipeNext = goNext,
-                onRetry = jumpToToday,
+                    onSwipePrev = goPrev,
-                onEventClick = onEventClick,
+                    onRetry = jumpToToday,
-                onCreateAt = { d, minutes -> onCreateEvent(d, minutes) },
+                    onEventClick = onEventClick,
-                modifier = Modifier
+                    onCreateAt = { d, minutes -> onCreateEvent(d, minutes) },
-                    .padding(innerPadding)
+                    modifier = Modifier
-                    .fillMaxSize(),
+                        .padding(innerPadding)
-            )
+                        .fillMaxSize(),
+                )
+            }
         }
     }
 }
@@ -550,8 +567,10 @@ private fun AllDayBar(
     modifier: Modifier = Modifier,
 ) {
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
+    val dimCutoff = LocalDimCutoff.current
+    val dimmed = dimCutoff != null && event.hasEnded(dimCutoff)
     Box(
-        modifier = modifier
+        modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
             .background(pastelize(event.color, dark), RoundedCornerShape(4.dp))
             .clickable(onClick = onClick)
             .padding(horizontal = 6.dp, vertical = 2.dp)
@@ -692,6 +711,7 @@ private fun DayColumnCard(
                 EventBlock(
                     block = block,
                     dark = dark,
+                    height = height,
                     onClick = { onEventClick(block.event) },
                     modifier = Modifier
                         .offset(x = laneWidth * block.lane, y = top)
@@ -712,6 +732,7 @@ private fun DayColumnCard(
 private fun EventBlock(
     block: TimedBlock,
     dark: Boolean,
+    height: Dp,
     onClick: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
@@ -720,9 +741,26 @@ private fun EventBlock(
     val locale = currentLocale()
     val timeLabel = "${minToHm(block.startMin, use24Hour, locale)}–" +
         minToHm(block.endMin, use24Hour, locale)
-    val showTime = block.endMin - block.startMin >= 45
+    // Only full-width (non-overlapping) blocks that are tall enough show the time.
+    // On narrow overlapping columns we drop it so the title can wrap to fill the
+    // whole block, mirroring Google Calendar.
+    val showTime = block.endMin - block.startMin >= 45 && block.laneCount == 1
+    val density = LocalDensity.current
+    val titleLineHeight = with(density) {
+        MaterialTheme.typography.labelMedium.lineHeight.toDp()
+    }
+    val timeLineHeight = with(density) {
+        MaterialTheme.typography.labelSmall.lineHeight.toDp()
+    }
+    // Wrap the title across as many lines as the block can fit (minus the 2.dp
+    // top/bottom padding and the reserved time line) instead of clipping it to a
+    // single character on slim, overlapping blocks.
+    val contentHeight = height - 4.dp - if (showTime) timeLineHeight else 0.dp
+    val titleMaxLines = (contentHeight / titleLineHeight).toInt().coerceAtLeast(1)
+    val dimCutoff = LocalDimCutoff.current
+    val dimmed = dimCutoff != null && block.event.hasEnded(dimCutoff)
     Box(
-        modifier = modifier
+        modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
             .background(pastelize(block.event.color, dark), RoundedCornerShape(4.dp))
             .clickable(onClick = onClick)
             .padding(horizontal = 4.dp, vertical = 2.dp)
@@ -732,18 +770,15 @@ private fun EventBlock(
             Text(
                 text = title,
                 style = MaterialTheme.typography.labelMedium,
-                maxLines = if (showTime) 1 else 2,
+                maxLines = titleMaxLines,
                 overflow = TextOverflow.Ellipsis,
                 color = Color.Black.copy(alpha = 0.85f),
             )
             if (showTime) {
-                // Narrow columns can't fit "13:00–14:00" on one line, so let it
-                // wrap to a second line (after the dash) instead of clipping the
-                // end time.
                 Text(
                     text = timeLabel,
                     style = MaterialTheme.typography.labelSmall,
-                    maxLines = 2,
+                    maxLines = 1,
                     overflow = TextOverflow.Ellipsis,
                     color = Color.Black.copy(alpha = 0.6f),
                 )

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

@@ -50,6 +50,14 @@ class WeekViewModel @Inject constructor(
     private val zone = TimeZone.currentSystemDefault()
     private val locale: Locale = Locale.getDefault()
 
+    /** Whether to fade events that have already finished (display concern only). */
+    val dimCompletedEvents: StateFlow<Boolean> = settingsPrefs.dimCompletedEvents
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = false,
+        )
+
     private val todayDate: LocalDate
         get() = Clock.System.now().toLocalDateTime(zone).date
 

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

@@ -4,6 +4,7 @@ import android.Manifest
 import android.content.Context
 import android.content.pm.PackageManager
 import androidx.core.content.ContextCompat
+import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.EventInstance
@@ -24,6 +25,7 @@ import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import java.util.Locale
 import kotlin.time.Clock
+import kotlin.time.Instant
 
 /**
  * How far either side of today the month widget pre-loads. The displayed month
@@ -52,6 +54,8 @@ sealed interface AgendaWidgetData {
          * range is sliced from this in the composition (read reactively from
          * Glance state), so a range change is pure recomposition rather than a
          * flaky widget session restart — the same approach the month widget uses.
+         * Kept unfiltered: hiding/dimming finished events also happens reactively
+         * in the composition, against [now], for the same reliable-update reason.
          */
         val days: List<AgendaDay>,
         /** Resolved clock convention for event time labels (the time-format pref). */
@@ -60,6 +64,10 @@ sealed interface AgendaWidgetData {
         val weekStart: DayOfWeek,
         /** Saved range pref — the fallback when an instance has no Glance state yet. */
         val savedRange: AgendaRange,
+        /** Saved past-event display pref — the fallback before Glance state is set. */
+        val savedPastDisplay: PastEventDisplay,
+        /** Snapshot instant the data was read at, for "has this event ended?" tests. */
+        val now: Instant,
     ) : AgendaWidgetData
 }
 
@@ -108,6 +116,7 @@ internal suspend fun Context.loadAgendaWidgetData(): AgendaWidgetData {
     val ep = widgetEntryPoint()
     val prefs = ep.settingsPrefs()
     val savedRange = prefs.agendaWidgetRange.first()
+    val savedPastDisplay = prefs.pastEventDisplay.first()
     val weekStart = prefs.weekStart.first().resolveFirstDay(Locale.getDefault())
     // Load the widest selectable window once; the displayed range is sliced in
     // the composition from Glance state, so changing the range is a plain
@@ -122,6 +131,8 @@ internal suspend fun Context.loadAgendaWidgetData(): AgendaWidgetData {
         is24Hour = is24Hour,
         weekStart = weekStart,
         savedRange = savedRange,
+        savedPastDisplay = savedPastDisplay,
+        now = Clock.System.now(),
     )
 }
 

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

@@ -43,11 +43,15 @@ import androidx.glance.text.Text
 import androidx.glance.text.TextStyle
 import de.jeanlucmakiola.calendula.MainActivity
 import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
+import de.jeanlucmakiola.calendula.data.prefs.parsePastEventDisplay
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.hasEnded
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.dayCount
 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.pastelize
 import de.jeanlucmakiola.calendula.widget.AgendaWidgetData
@@ -79,6 +83,14 @@ import java.util.Locale
  */
 internal val AGENDA_RANGE_KEY = stringPreferencesKey("agenda_range")
 
+/**
+ * Per-instance Glance state key holding the past-event display mode (as
+ * [PastEventDisplay.name]). Read reactively in the composition for the same
+ * reason as [AGENDA_RANGE_KEY] — so toggling the setting reflects on the live
+ * widget without depending on the `provideGlance` preamble re-running.
+ */
+internal val AGENDA_PAST_DISPLAY_KEY = stringPreferencesKey("agenda_past_display")
+
 class AgendaWidget : GlanceAppWidget() {
 
     override val stateDefinition = PreferencesGlanceStateDefinition
@@ -125,11 +137,26 @@ private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
                 // to the saved pref for a freshly placed widget), then the wide
                 // pre-loaded window is sliced to it — pure recomposition.
                 val range = parseAgendaRange(currentState(AGENDA_RANGE_KEY), data.savedRange)
+                val pastDisplay =
+                    parsePastEventDisplay(currentState(AGENDA_PAST_DISPLAY_KEY), data.savedPastDisplay)
                 val rangeEnd = data.today.plus(
                     range.dayCount(data.today, data.weekStart) - 1,
                     DateTimeUnit.DAY,
                 )
-                val visibleDays = data.days.filter { it.date <= rangeEnd }
+                // Slice to the chosen range, then drop finished events (and any day
+                // they leave empty) when the mode is Hide — so "Upcoming" really is.
+                val visibleDays = data.days
+                    .filter { it.date <= rangeEnd }
+                    .let { days ->
+                        if (pastDisplay == PastEventDisplay.HIDE) {
+                            days.mapNotNull { day ->
+                                val remaining = day.events.filterNot { it.hasEnded(data.now) }
+                                if (remaining.isEmpty()) null else day.copy(events = remaining)
+                            }
+                        } else {
+                            days
+                        }
+                    }
                 if (visibleDays.isEmpty()) {
                     WidgetMessage(R.string.agenda_empty_title)
                 } else {
@@ -143,7 +170,13 @@ private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
                         items(rows.size) { index ->
                             when (val row = rows[index]) {
                                 is AgendaRow.Header -> DayHeaderRow(row.date, row.today)
-                                is AgendaRow.Event -> EventRow(row.event, dark, data.is24Hour)
+                                is AgendaRow.Event -> EventRow(
+                                    event = row.event,
+                                    dark = dark,
+                                    is24Hour = data.is24Hour,
+                                    dimmed = pastDisplay == PastEventDisplay.DIM &&
+                                        row.event.hasEnded(data.now),
+                                )
                             }
                         }
                     }
@@ -224,9 +257,15 @@ private fun DayHeaderRow(date: LocalDate, today: LocalDate) {
 }
 
 @Composable
-private fun EventRow(event: EventInstance, dark: Boolean, is24Hour: Boolean) {
+private fun EventRow(event: EventInstance, dark: Boolean, is24Hour: Boolean, dimmed: Boolean) {
     val context = androidx.glance.LocalContext.current
     val title = event.title.ifBlank { context.getString(R.string.event_untitled) }
+    // Glance has no generic alpha modifier, so dim by fading the colour stripe and
+    // dropping both text lines to the lower-emphasis on-surface-variant tone.
+    val stripeColor = pastelize(event.color, dark).let {
+        if (dimmed) it.copy(alpha = EventDimAlpha) else it
+    }
+    val titleColor = if (dimmed) GlanceTheme.colors.onSurfaceVariant else GlanceTheme.colors.onSurface
     Row(
         modifier = GlanceModifier
             .fillMaxWidth()
@@ -249,14 +288,14 @@ private fun EventRow(event: EventInstance, dark: Boolean, is24Hour: Boolean) {
                 .width(5.dp)
                 .height(36.dp)
                 .cornerRadius(3.dp)
-                .background(pastelize(event.color, dark)),
+                .background(stripeColor),
         ) {}
         Spacer(GlanceModifier.width(10.dp))
         Column(modifier = GlanceModifier.defaultWeight()) {
             Text(
                 text = title,
                 maxLines = 1,
-                style = TextStyle(color = GlanceTheme.colors.onSurface, fontSize = 14.sp),
+                style = TextStyle(color = titleColor, fontSize = 14.sp),
             )
             Text(
                 text = eventTimeSummary(context, event, is24Hour),

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

@@ -316,7 +316,6 @@
     <string name="reminder_none">Keine</string>
     <string name="reminder_use_default">Standard-Erinnerung verwenden</string>
     <string name="reminder_custom_amount">Anzahl</string>
-    <string name="reminder_custom_with_value">Benutzerdefiniert (%1$s)</string>
     <string name="reminder_custom_set">Übernehmen</string>
     <string name="settings_calendar_reminders_hint">Standard pro Kalender überschreiben — getrennt für Termine mit Uhrzeit und ganztägige Termine. Ein Kalender kann den Standard übernehmen, weglassen oder einen eigenen festlegen.</string>
     <string name="settings_calendar_reminder_inherits">Standard (%1$s)</string>

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

@@ -282,6 +282,13 @@
     <string name="settings_time_format_24h">24-hour (14:00)</string>
     <string name="settings_hour_lines">Hour lines</string>
     <string name="settings_hour_lines_summary">Show a separator line at each hour in week and day view</string>
+    <string name="settings_dim_completed">Dim completed events</string>
+    <string name="settings_dim_completed_summary">Fade events that have already ended in month and week view</string>
+    <string name="settings_past_events">Past events</string>
+    <string name="settings_past_events_show">Show</string>
+    <string name="settings_past_events_dim">Dim</string>
+    <string name="settings_past_events_hide">Hide</string>
+    <string name="settings_agenda_header">Agenda</string>
     <string name="settings_agenda_range">Agenda range</string>
     <string name="settings_agenda_range_hint">How far ahead the Agenda screen lists events.</string>
     <string name="settings_agenda_widget_range">Agenda widget range</string>
@@ -317,7 +324,6 @@
     <string name="reminder_none">None</string>
     <string name="reminder_use_default">Use default reminder</string>
     <string name="reminder_custom_amount">Amount</string>
-    <string name="reminder_custom_with_value">Custom (%1$s)</string>
     <string name="reminder_custom_set">Set</string>
     <string name="settings_calendar_reminders_title">Per-calendar reminders</string>
     <string name="settings_calendar_reminders_hint">Override the default per calendar — separately for timed and all-day events. A calendar can keep the default, drop it, or set its own.</string>

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapperTest.kt

@@ -199,11 +199,12 @@ class EventWriteMapperTest {
         assertThat(values[CalendarContract.Events.TITLE]).isEqualTo("Moved")
         assertThat(values[CalendarContract.Events.EVENT_LOCATION]).isEqualTo("Berlin")
         assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_164_800_000L)
-        assertThat(values[CalendarContract.Events.DTEND])
+        // The occurrence's length travels as DURATION, never DTEND — the provider
-            .isEqualTo(1_781_164_800_000L + 5_400_000L)
+        // rejects DTEND on an exception ("Exceptions can't overwrite dtend") and
-        // A single occurrence never carries its own rule.
+        // derives the end from DTSTART + DURATION, clearing the inherited RRULE.
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P5400S")
+        assertThat(values).doesNotContainKey(CalendarContract.Events.DTEND)
         assertThat(values).doesNotContainKey(CalendarContract.Events.RRULE)
-        assertThat(values).doesNotContainKey(CalendarContract.Events.DURATION)
     }
 
     @Test

app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt

@@ -183,22 +183,38 @@ class SettingsPrefsTest {
     }
 
     @Test
-    fun `default reminder is none until set`(@TempDir tempDir: Path) = runTest {
+    fun `default reminder is empty until set`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
-        assertThat(prefs.defaultReminderMinutes.first()).isNull()
+        assertThat(prefs.defaultReminderMinutes.first()).isEmpty()
     }
 
     @Test
-    fun `default reminder round-trips, including none`(@TempDir tempDir: Path) = runTest {
+    fun `default reminder round-trips none, single, and multiple lead times`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
-        prefs.setDefaultReminderMinutes(30)
+        prefs.setDefaultReminderMinutes(listOf(30))
-        assertThat(prefs.defaultReminderMinutes.first()).isEqualTo(30)
+        assertThat(prefs.defaultReminderMinutes.first()).containsExactly(30)
-        prefs.setDefaultReminderMinutes(null)
+        // Several lead times persist, normalised to distinct ascending order.
-        assertThat(prefs.defaultReminderMinutes.first()).isNull()
+        prefs.setDefaultReminderMinutes(listOf(10_080, 0, 30, 30))
+        assertThat(prefs.defaultReminderMinutes.first()).containsExactly(0, 30, 10_080).inOrder()
+        prefs.setDefaultReminderMinutes(emptyList())
+        assertThat(prefs.defaultReminderMinutes.first()).isEmpty()
     }
 
     @Test
-    fun `garbage stored default reminder reads as none`(@TempDir tempDir: Path) = runTest {
+    fun `legacy single-value default reminder parses as a one-element list`(@TempDir tempDir: Path) = runTest {
+        val store = newDataStore(tempDir)
+        val prefs = SettingsPrefs(store)
+        // The pre-multi-reminder format stored a bare integer string.
+        store.updateData { p ->
+            val m = p.toMutablePreferences()
+            m[SettingsPrefs.DEFAULT_REMINDER_KEY] = "30"
+            m
+        }
+        assertThat(prefs.defaultReminderMinutes.first()).containsExactly(30)
+    }
+
+    @Test
+    fun `garbage stored default reminder reads as empty`(@TempDir tempDir: Path) = runTest {
         val store = newDataStore(tempDir)
         val prefs = SettingsPrefs(store)
         store.updateData { p ->
@@ -206,7 +222,7 @@ class SettingsPrefsTest {
             m[SettingsPrefs.DEFAULT_REMINDER_KEY] = "soon"
             m
         }
-        assertThat(prefs.defaultReminderMinutes.first()).isNull()
+        assertThat(prefs.defaultReminderMinutes.first()).isEmpty()
     }
 
     @Test
@@ -214,16 +230,16 @@ class SettingsPrefsTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
         assertThat(prefs.perCalendarReminderOverride.first()).isEmpty()
 
-        prefs.setCalendarReminderOverride(7L, CalendarReminderOverride.Minutes(15))
+        prefs.setCalendarReminderOverride(7L, CalendarReminderOverride.Minutes(listOf(15, 10_080)))
         prefs.setCalendarReminderOverride(9L, CalendarReminderOverride.None)
         prefs.perCalendarReminderOverride.first().let { map ->
-            assertThat(map).containsExactly(7L, 15, 9L, null)
+            assertThat(map).containsExactly(7L, listOf(15, 10_080), 9L, emptyList<Int>())
         }
 
-        // Inherit drops the override entirely (absent != null value).
+        // Inherit drops the override entirely (absent != an empty-list value).
         prefs.setCalendarReminderOverride(9L, CalendarReminderOverride.Inherit)
         prefs.perCalendarReminderOverride.first().let { map ->
-            assertThat(map).containsExactly(7L, 15)
+            assertThat(map).containsExactly(7L, listOf(15, 10_080))
             assertThat(map.containsKey(9L)).isFalse()
         }
     }
@@ -231,48 +247,48 @@ class SettingsPrefsTest {
     @Test
     fun `all-day default round-trips, including none`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
-        assertThat(prefs.defaultAllDayReminderMinutes.first()).isNull()
+        assertThat(prefs.defaultAllDayReminderMinutes.first()).isEmpty()
-        prefs.setDefaultAllDayReminderMinutes(1_440)
+        prefs.setDefaultAllDayReminderMinutes(listOf(1_440))
-        assertThat(prefs.defaultAllDayReminderMinutes.first()).isEqualTo(1_440)
+        assertThat(prefs.defaultAllDayReminderMinutes.first()).containsExactly(1_440)
-        prefs.setDefaultAllDayReminderMinutes(null)
+        prefs.setDefaultAllDayReminderMinutes(emptyList())
-        assertThat(prefs.defaultAllDayReminderMinutes.first()).isNull()
+        assertThat(prefs.defaultAllDayReminderMinutes.first()).isEmpty()
     }
 
     @Test
     fun `per-calendar all-day override round-trips independently of the timed one`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
-        prefs.setCalendarReminderOverride(7L, CalendarReminderOverride.Minutes(15))
+        prefs.setCalendarReminderOverride(7L, CalendarReminderOverride.Minutes(listOf(15)))
-        prefs.setCalendarAllDayReminderOverride(7L, CalendarReminderOverride.Minutes(1_440))
+        prefs.setCalendarAllDayReminderOverride(7L, CalendarReminderOverride.Minutes(listOf(1_440)))
-        assertThat(prefs.perCalendarReminderOverride.first()).containsExactly(7L, 15)
+        assertThat(prefs.perCalendarReminderOverride.first()).containsExactly(7L, listOf(15))
-        assertThat(prefs.perCalendarAllDayReminderOverride.first()).containsExactly(7L, 1_440)
+        assertThat(prefs.perCalendarAllDayReminderOverride.first()).containsExactly(7L, listOf(1_440))
         // Clearing the all-day override leaves the timed one untouched.
         prefs.setCalendarAllDayReminderOverride(7L, CalendarReminderOverride.Inherit)
         assertThat(prefs.perCalendarAllDayReminderOverride.first()).isEmpty()
-        assertThat(prefs.perCalendarReminderOverride.first()).containsExactly(7L, 15)
+        assertThat(prefs.perCalendarReminderOverride.first()).containsExactly(7L, listOf(15))
     }
 
     @Test
     fun `resolveDefaultReminder picks the kind-matching override or global`() {
-        val timed = mapOf(7L to 15, 9L to null)
+        val timed = mapOf(7L to listOf(15, 10_080), 9L to emptyList<Int>())
-        val allDay = mapOf(7L to 2_880)
+        val allDay = mapOf(7L to listOf(2_880))
         fun resolve(calendarId: Long?, isAllDay: Boolean) = resolveDefaultReminder(
-            timedGlobal = 30,
+            timedGlobal = listOf(30),
-            allDayGlobal = 1_440,
+            allDayGlobal = listOf(1_440),
             timedOverrides = timed,
             allDayOverrides = allDay,
             calendarId = calendarId,
             isAllDay = isAllDay,
         )
-        // Timed: minutes override, explicit none, inherit global, no calendar.
+        // Timed: multi-value override, explicit none, inherit global, no calendar.
-        assertThat(resolve(7L, isAllDay = false)).isEqualTo(15)
+        assertThat(resolve(7L, isAllDay = false)).containsExactly(15, 10_080).inOrder()
-        assertThat(resolve(9L, isAllDay = false)).isNull()
+        assertThat(resolve(9L, isAllDay = false)).isEmpty()
-        assertThat(resolve(5L, isAllDay = false)).isEqualTo(30)
+        assertThat(resolve(5L, isAllDay = false)).containsExactly(30)
-        assertThat(resolve(null, isAllDay = false)).isEqualTo(30)
+        assertThat(resolve(null, isAllDay = false)).containsExactly(30)
         // All-day: its own override wins; absent → all-day global; a timed-only
         // override (cal 9) does not bleed into all-day.
-        assertThat(resolve(7L, isAllDay = true)).isEqualTo(2_880)
+        assertThat(resolve(7L, isAllDay = true)).containsExactly(2_880)
-        assertThat(resolve(9L, isAllDay = true)).isEqualTo(1_440)
+        assertThat(resolve(9L, isAllDay = true)).containsExactly(1_440)
-        assertThat(resolve(5L, isAllDay = true)).isEqualTo(1_440)
+        assertThat(resolve(5L, isAllDay = true)).containsExactly(1_440)
     }
 
     @Test

app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/PostableAlertsTest.kt

@@ -0,0 +1,55 @@
+package de.jeanlucmakiola.calendula.data.reminders
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+class PostableAlertsTest {
+
+    private fun alert(alertId: Long, calendarId: Long) = ReminderAlert(
+        alertId = alertId,
+        eventId = alertId * 10,
+        calendarId = calendarId,
+        beginMillis = 0L,
+        endMillis = 0L,
+        title = "Event $alertId",
+        location = null,
+        isAllDay = false,
+    )
+
+    @Test
+    fun `keeps alerts when no calendar is disabled`() {
+        val due = listOf(alert(1, calendarId = 100), alert(2, calendarId = 200))
+
+        val postable = postableAlerts(due, disabledCalendarIds = emptySet())
+
+        assertThat(postable).isEqualTo(due)
+    }
+
+    @Test
+    fun `drops alerts for a disabled calendar`() {
+        val keep = alert(1, calendarId = 100)
+        val drop = alert(2, calendarId = 200)
+
+        val postable = postableAlerts(listOf(keep, drop), disabledCalendarIds = setOf(200))
+
+        assertThat(postable).containsExactly(keep)
+    }
+
+    @Test
+    fun `drops every alert when all their calendars are disabled`() {
+        val due = listOf(alert(1, calendarId = 100), alert(2, calendarId = 100))
+
+        val postable = postableAlerts(due, disabledCalendarIds = setOf(100))
+
+        assertThat(postable).isEmpty()
+    }
+
+    @Test
+    fun `keeps multiple alerts from the same enabled calendar`() {
+        val due = listOf(alert(1, calendarId = 100), alert(2, calendarId = 100))
+
+        val postable = postableAlerts(due, disabledCalendarIds = setOf(999))
+
+        assertThat(postable).isEqualTo(due)
+    }
+}

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

@@ -0,0 +1,19 @@
+### Added
+- See past events your way. Two new settings change how events that have already
+  ended are shown. **Past events** (Settings → Appearance → Agenda) lets the
+  agenda — both in the app and the home-screen "Upcoming" widget — keep them as
+  usual, dim them, or hide them from the list entirely. **Dim completed events**
+  (Settings → Appearance) separately fades finished events in the month and week
+  views. Both are off by default, an event only counts as finished once it has
+  actually ended (events still in progress are never dimmed), and the lists
+  update on their own as the day goes on. Thanks to @ptab for the suggestion
+  ([#12]).
+
+### Changed
+- Readable titles on overlapping events. In the week and day views, events that
+  overlap split a day into slim columns where the title used to be clipped to a
+  character or two. The title now wraps across as many lines as the block can
+  fit, and the time is hidden on those narrow blocks so the name can fill the
+  space — so you can tell events apart without opening each one. Thanks to @ptab
+  for the suggestion ([#13]).
+