docs(changelog): record the settings rework (#69)

The whole #69 entry was missing: the reorganised hub, the previewing pickers,
Backup & restore as its own entry, the recurrence date preview and the event
visibility explanations. Also corrects the agenda widget size path, which moved
to Settings → Widgets & tiles in the same rework.

CHANGELOG.md

@@ -28,12 +28,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - The calendar picker in the event form and in the .ics import screen now ends
   with a **"Missing a calendar?"** row that opens Settings → Calendars, where
   those marks then explain why a calendar isn't offered ([#76]).
-- The agenda widget's text size is yours to set. **Settings → Agenda → Agenda
+- The agenda widget's text size is yours to set. **Settings → Widgets & tiles →
-  widget size** offers Small, Medium, Large and Extra large, replacing the guess
+  Agenda widget size** offers Small, Medium, Large and Extra large, replacing the guess
   the widget used to make from its own measurements. Small is what it looks like
   today, so nothing changes until you turn it up ([#51]).
+- A repeating event now shows you its next few dates, not just a description of
+  the rule. Both the preset list and the custom recurrence picker carry a
+  **Next:** line — "Next: 30 Jul, 6 Aug, 13 Aug" — under the rule they would
+  save. A phrase like "monthly" on the 31st, or "every 2 weeks on Mon & Fri",
+  can mean something other than it sounds like, and only the dates say so. A
+  rule that can never fire says that instead ([#69]).
+- The event visibility options now say who they affect. **Public**, **Private**
+  and **Confidential** each carry a line about what other people on a shared
+  calendar see — the part the four words on their own leave out ([#69]).
 
 ### Changed
+- **Settings has been reorganised so each setting sits where you would look for
+  it.** One long undifferentiated list is now three labelled groups — Look &
+  behaviour, Data, and App — whose rows open sub-screens and say what they do
+  rather than only naming themselves. Appearance, Views, New event form,
+  Notifications and the new Widgets & tiles are separate screens now, so the
+  settings for a calendar view are no longer mixed in with the ones for the
+  app's colours or for the home-screen widgets ([#69]).
+- Settings that are hard to picture from their name now show you what they do.
+  The week-start picker rearranges a real month grid as you choose, the
+  past-events setting previews a sample agenda day for Show, Dim and Hide, the
+  font pickers set a specimen line in the face you are choosing, and the Agenda
+  range options carry the dates each one actually covers. Options that follow
+  the system additionally name which way they currently fall ([#69]).
+- **Backup & restore** is now its own Settings entry instead of living inside
+  the calendar manager, where it was easy to miss — keeping a copy of your
+  calendars is a different question from which calendars you have. The calendar
+  manager keeps a row pointing to it, and nothing about how backup or automatic
+  backup works has changed ([#69]).
 - Calendula's source code now lives on **Codeberg**, where its issues already
   were. The **Source code** and **License** links in Settings → About point
   there, so reporting a bug and reading the code no longer land on two different
@@ -1223,3 +1250,4 @@ automatically, with zero telemetry and no internet permission.
 [#87]: https://codeberg.org/jlmakiola/calendula/issues/87
 [#89]: https://codeberg.org/jlmakiola/calendula/issues/89
 [#103]: https://codeberg.org/jlmakiola/calendula/issues/103
+[#69]: https://codeberg.org/jlmakiola/calendula/issues/69

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

@@ -47,12 +47,9 @@ class CalendulaApp : Application() {
     }
 
     /**
-     * Bring reminder delivery up with the process (#75). The app plans and arms
+     * Bring reminder delivery up with the process (#75): a scan re-arms whatever
-     * its own reminder alarms now, so launch is one of the moments that has to
+     * the system dropped and posts what a missed alarm still owes, then the
-     * re-check them: a scan re-arms whatever the system dropped, posts anything
+     * provider watch keeps edits re-planned. The daily worker is the backstop.
-     * a missed alarm still owes, and starts watching the provider so an edit
-     * re-plans without waiting for the next pass. The daily worker is the
-     * backstop for a device that drops the alarm with no reboot to announce it.
      */
     private fun startReminderDelivery() {
         val deps = EntryPointAccessors.fromApplication(
@@ -65,12 +62,9 @@ class CalendulaApp : Application() {
     }
 
     /**
-     * Flush any calendar switch-off the app hasn't been allowed to write into
+     * Flush any calendar switch-off not yet written to `Calendars.VISIBLE`,
-     * the system's `Calendars.VISIBLE` yet — including the retired app-local
+     * including the set inherited from the retired app-local model (#75). A
-     * "disabled calendars" set the upgrade inherits (#75). A no-op on a fresh
+     * no-op in the steady state; `RootScreen` re-runs it after a later grant.
-     * install and in the steady state; a launch without the calendar permission
-     * leaves the set pending, and `RootScreen` runs it again once the app comes
-     * up holding it — whichever way it was granted.
      */
     private fun reconcileCalendarVisibility() {
         val deps = EntryPointAccessors.fromApplication(
@@ -101,10 +95,8 @@ class CalendulaApp : Application() {
 
     /**
      * Re-arm (or cancel) the daily special-dates reconcile from the saved
-     * settings on every launch — like [reconcileAutoBackup], this cancels
+     * settings, like [reconcileAutoBackup]. The on-open refresh is RootScreen's
-     * orphaned work after the feature is turned off and re-schedules after a
+     * ON_RESUME trigger, so no immediate run is needed here.
-     * reinstall. The foreground trigger (RootScreen ON_RESUME) does the on-open
-     * refresh, so no immediate run is needed here.
      */
     private fun reconcileSpecialDates() {
         val deps = EntryPointAccessors.fromApplication(this, SpecialDatesSyncWorker.Deps::class.java)

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

@@ -73,9 +73,8 @@ internal fun nextYearlyOccurrence(month: Int, day: Int, today: LocalDate): Local
 /**
  * Recover the semantic whole-day lead time from a raw all-day reminder
  * [rawMinutes] — the inverse of [toProviderAllDayMinutes], for the form and the
- * detail screen. Delegates to [allDayLeadDays] so what is displayed is the day
+ * detail screen. Delegates to [allDayLeadDays], so the day displayed is the day
- * the reminder actually fires on; see there for how an encoded row is told from
+ * the reminder actually fires on.
- * a plain one written by another calendar app.
  */
 internal fun fromProviderAllDayMinutes(
     rawMinutes: Int,

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

@@ -117,19 +117,15 @@ interface CalendarDataSource {
 
     /**
      * Show or hide the calendar device-wide by writing `Calendars.VISIBLE` — the
-     * app's one visibility model (#75). `VISIBLE` also gates the provider's own
+     * app's one visibility model (#75), which also gates its reminders. One of
-     * reminder scheduling, so switching a calendar off here is what actually
+     * the three columns the platform documents as app-writable, and device-local.
-     * stops its notifications; switching it on is what brings them back.
-     * Writable by a plain app (one of the three columns the platform documents
-     * as such) and device-local — no sync adapter pushes it anywhere.
      */
     fun setCalendarVisible(id: Long, visible: Boolean)
 
     /**
-     * Whether one calendar is currently switched on at system level, without
+     * Whether one calendar is switched on at system level, without reading every
-     * reading every row — for the reminder gate, which sees a calendar id and
+     * row — for the reminder gate, which sees only a calendar id. Null when the
-     * nothing else. Null when the answer can't be had: no row (the calendar was
+     * answer can't be had: no row, or no read permission.
-     * deleted) or no read permission.
      */
     fun isCalendarVisible(id: Long): Boolean?
 
@@ -405,14 +401,11 @@ class AndroidCalendarDataSource @Inject constructor(
     }
 
     /**
-     * Addressed by appended id on the plain (non-sync-adapter) Calendars URI,
+     * Addressed by appended id on the plain (non-sync-adapter) Calendars URI, one
-     * one calendar per call. Both parts are load-bearing:
+     * calendar per call. Both parts are load-bearing:
-     * `CalendarProvider2.updateInTransaction` short-circuits to a raw database
+     * `CalendarProvider2.updateInTransaction` skips the dirty marking and the
-     * update unless the selection is `_id=…`, skipping the dirty marking *and*
+     * `checkNextAlarm()` reschedule unless the selection is `_id=…`, and the
-     * the `checkNextAlarm()` reschedule — i.e. an `_id IN (…)` batch would write
+     * plain URI is what makes the write apply to synced calendars too.
-     * the flag but never re-arm the reminder alarms this write exists to
-     * trigger. The sync-adapter URI is avoided so the write also applies to
-     * synced calendars, which is where the bug bites.
      */
     override fun setCalendarVisible(id: Long, visible: Boolean) {
         val values = ContentValues().apply {

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

@@ -31,9 +31,7 @@ internal fun ColumnReader.toCalendarSource(): CalendarSource {
         isManaged = isLocal &&
             getString(CalendarProjection.IDX_MANAGED_MARKER)
                 ?.startsWith(CalendarProjection.MANAGED_MARKER_PREFIX) == true,
-        // A provider that leaves the column NULL is treated as syncing — the
+        // NULL is treated as syncing — the harmless default.
-        // harmless default, since this flag only ever holds the one-shot
-        // visibility migration back from switching a calendar on.
         syncsEvents = isNull(CalendarProjection.IDX_SYNC_EVENTS) ||
             getInt(CalendarProjection.IDX_SYNC_EVENTS) != 0,
     )

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

@@ -39,16 +39,12 @@ interface CalendarRepository {
     suspend fun deleteCalendar(id: Long)
 
     /**
-     * Show or hide [ids] device-wide (`Calendars.VISIBLE`), which is also what
+     * Show or hide [ids] device-wide (`Calendars.VISIBLE`), which also gates
-     * turns the provider's reminder scheduling for them on or off — see
+     * their reminders — see [CalendarDataSource.setCalendarVisible]. Written one
-     * [CalendarDataSource.setCalendarVisible]. Each calendar is written on its
+     * at a time, in order; a failure part-way leaves the earlier writes standing.
-     * own, in order; a failure part-way leaves the earlier writes standing (the
-     * observer reports whatever actually landed).
      *
      * Without `WRITE_CALENDAR` the choice is kept app-side instead (see
-     * [de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs.pendingDisabledCalendarIds]),
+     * [de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs.pendingDisabledCalendarIds]).
-     * where it filters events and reminders just the same until it can be
-     * written.
      */
     suspend fun setCalendarsVisible(ids: Collection<Long>, visible: Boolean)
 

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

@@ -68,23 +68,17 @@ class CalendarRepositoryImpl @Inject constructor(
 
     /**
      * Re-query signal for everything filtered by visibility: the provider's own
-     * notifications, plus every change to the pending switch-off set (an id
+     * notifications, plus every change to the pending switch-off set.
-     * leaves it as its `VISIBLE` write lands, which changes what is shown).
-     * [calendarsSnapshot] keeps the two in step.
      */
     private fun visibilityTicks(): Flow<Unit> = merge(
         ticks.onStart { emit(Unit) },
-        // The current value is already covered by the tick above; only later
+        // drop(1): the current value is already covered by the tick above.
-        // changes re-query (the set is deduped, so an unrelated DataStore write
-        // doesn't).
         prefs.pendingDisabledCalendarIds.drop(1).map {},
     )
 
-    // A switch-off the app hasn't been allowed to write yet is folded into the
+    // A switch-off not yet written to the provider is folded into the flag
-    // flag itself, so every consumer — the Settings switch, the filter sheet,
+    // itself, so every consumer reads one visibility (#75). The reconciler goes
-    // the form and import pickers, the widgets — reads one visibility and can't
+    // to the data source directly — it needs the provider's own answer.
-    // disagree with what the user just tapped. The reconciler reads the data
-    // source directly, because it needs the provider's own answer.
     override fun calendars(): Flow<List<CalendarSource>> =
         visibilityTicks().reQuery {
             val calendars = calendarsSnapshot()
@@ -94,19 +88,13 @@ class CalendarRepositoryImpl @Inject constructor(
                 if (it.id in pendingDisabled) it.copy(isVisibleInSystem = false) else it
             }
         }
-            // Collapse re-emissions that carry an identical list (see
-            // [instances]).
             .distinctUntilChanged()
             .flowOn(io)
 
-    // Instances are filtered by the system's per-calendar VISIBLE flag ∪ the
+    // Instances are filtered by the system's VISIBLE flag ∪ the switch-offs
-    // switch-offs still waiting to be written to it ∪ the app-side hidden set:
+    // still waiting to be written to it ∪ the app-side hidden set from the
-    // an event is dropped when the user switched its calendar off in Settings →
+    // filter sheet. [calendars] stays unfiltered so those screens can list and
-    // Calendars (which also stops the provider scheduling its reminders) *or*
+    // re-enable invisible calendars.
-    // hid it in the filter sheet. Re-runs when the provider ticks — writing
-    // VISIBLE notifies, so switching a calendar updates every view — or when
-    // either set changes. [calendars] stays unfiltered so those screens can list
-    // and re-enable invisible calendars.
     override fun instances(range: ClosedRange<Instant>): Flow<List<EventInstance>> =
         combine(
             visibilityTicks().reQuery {
@@ -127,10 +115,8 @@ class CalendarRepositoryImpl @Inject constructor(
             if (excluded.isEmpty()) queried.instances
             else queried.instances.filterNot { it.calendarId in excluded }
         }
-            // Any DataStore edit re-emits the hidden set even when it is
+            // Any DataStore edit re-emits the hidden set even when unchanged;
-            // unchanged (e.g. writing the last-used calendar), which would
+            // collapse those so views don't re-render for them.
-            // re-surface an identical list — collapse those so views don't
-            // re-render for them.
             .distinctUntilChanged()
             .flowOn(io)
 
@@ -151,21 +137,14 @@ class CalendarRepositoryImpl @Inject constructor(
     private var cachedCalendars: List<CalendarSource> = emptyList()
 
     /**
-     * The calendar list for the current tick, queried once and shared. Every
+     * The calendar list for the current tick, queried once and shared, so every
-     * open view collects [calendars] *and* filters its instances by visibility,
+     * open view doesn't pay for its own `Calendars` query and all of them see
-     * which used to cost one full `Calendars` query each per tick. Reusing a
+     * one snapshot.
-     * single read also keeps them consistent: within a tick, what a screen lists
-     * and what its events are filtered against can't come from two snapshots.
      *
-     * An empty result is never cached — it is what a read without the calendar
+     * An empty result is never cached — that is what a read without the calendar
-     * permission returns, and the grant itself doesn't notify the provider.
+     * permission returns, and the grant itself doesn't notify the provider. The
-     *
+     * pending switch-off set keys the cache alongside the tick, because an id
-     * The pending switch-off set keys the cache alongside the tick. An id leaves
+     * leaves it before the invalidating observer is dispatched.
-     * that set the moment its `VISIBLE` write lands, while the observer that
-     * would invalidate the snapshot is only dispatched through the main looper
-     * afterwards — so a snapshot taken while the id was still pending, read
-     * against the set that no longer holds it, would report the calendar as *on*
-     * again and re-admit exactly the events being hidden.
      */
     private suspend fun calendarsSnapshot(): List<CalendarSource> = calendarsLock.withLock {
         val current = generation.get()

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

@@ -21,25 +21,15 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * Keeps the app's pending "switched off" set (see
+ * Keeps [CalendarPrefs.pendingDisabledCalendarIds] and the system's
- * [CalendarPrefs.pendingDisabledCalendarIds]) and the system's
+ * `Calendars.VISIBLE` in step (#75): the fold-in of the retired app-local
- * `Calendars.VISIBLE` in step — the fold-in of the retired app-local visibility
+ * visibility model, and the standing drain for switch-offs made without
- * model (#75), and the standing drain for switch-offs made without
  * `WRITE_CALENDAR`.
  *
- * Runs on every launch, and again whenever the app comes up holding the calendar
+ * Runs on every launch and on every calendar-permission grant; a no-op once the
- * permission — a grant made on Android's own app-settings screen never reaches
+ * pending set is empty and the notice is settled. Only ever hides (see
- * the permission screen's callback. It is a no-op whenever the pending set is
+ * [calendarVisibilityPlan]); on an upgraded install the first run that sees a
- * empty and the notice has been settled, which
+ * system-hidden calendar arms the one-time explanatory notice.
- * is the steady state: each entry is written and dropped individually, so a run
- * that dies part-way resumes exactly where it stopped and never re-applies a
- * write the user has since undone by hand.
- *
- * The reconciliation only hides (see [calendarVisibilityPlan]). Calendars hidden
- * at system level stay hidden, and on an *upgraded* install the first run that
- * sees one arms the one-time notice explaining why Calendula no longer lists
- * their events. A fresh install never had the old behaviour, so it retires that
- * notice unshown — every other device ships with something hidden.
  */
 @Singleton
 class CalendarVisibilityReconciler @Inject constructor(
@@ -50,43 +40,30 @@ class CalendarVisibilityReconciler @Inject constructor(
 ) {
 
     suspend fun run() = withContext(io) {
-        // Everything, the DataStore reads included, sits inside the guard: this
+        // The DataStore reads sit inside the guard too: this runs in a bare
-        // runs in a bare application-scope coroutine with no exception handler,
+        // application-scope coroutine, so an IOException from a damaged
-        // so an IOException from a damaged preferences file would otherwise take
+        // preferences file would take the process down on every launch.
-        // the process down on every launch.
         try {
-            // A fresh install has no retired model behind it — nothing to
+            // Settled ahead of the permission gate, so an update installed
-            // migrate, and nothing to explain. Settled ahead of the permission
+            // before the first grant can't later look like an upgrade.
-            // gate so an update installed before the first grant can't make a
-            // first run look like an upgrade afterwards.
             if (!isUpgradeInstall()) settleNoticeOnce(pending = false)
             if (!hasPermission(Manifest.permission.READ_CALENDAR)) return@withContext
             val pending = prefs.pendingDisabledCalendarIds.first()
             val noticeSettled = prefs.visibilityNoticePending.first() != null
-            // The steady state, and every run after the first: nothing left to
-            // drain and nothing left to decide, so don't pay for the query.
             if (pending.isEmpty() && noticeSettled) return@withContext
             val calendars = dataSource.calendars()
-            // An empty read means "couldn't read", not "no calendars": the data
+            // Empty means "couldn't read" (null cursor), not "no calendars".
-            // source turns a null cursor — a provider momentarily unavailable —
+            // Both decisions below are one-way, so leave them to the next run.
-            // into an empty list. Both decisions below are one-way, so taking
-            // that reading as the truth would drop the whole pending set without
-            // ever writing VISIBLE = 0 (switching the user's calendars back on,
-            // events and reminders with them) and settle the notice as "nothing
-            // to explain". Leave both to the next run.
             if (calendars.isEmpty()) return@withContext
             settleNoticeOnce(hasSystemHiddenCalendars(calendars, pending))
             if (pending.isEmpty() || !hasPermission(Manifest.permission.WRITE_CALENDAR)) {
                 return@withContext
             }
             val plan = calendarVisibilityPlan(calendars, pending)
-            // Already off, or gone from the device — nothing to write, so let
-            // those ids leave the pending set with the rest.
             prefs.removePendingDisabledCalendarIds(plan.settled)
             // One calendar per write: the provider skips its reminder-alarm
             // reschedule for anything but a single-id update (see
-            // [CalendarDataSource.setCalendarVisible]). Dropping each id as it
+            // [CalendarDataSource.setCalendarVisible]).
-            // lands keeps a part-applied run resumable.
             for (id in plan.hide) {
                 dataSource.setCalendarVisible(id, false)
                 prefs.removePendingDisabledCalendarIds(setOf(id))
@@ -100,9 +77,7 @@ class CalendarVisibilityReconciler @Inject constructor(
 
     /**
      * Settle the one-time notice: [pending] arms it, false retires it unshown.
-     * Answered once, by whichever run can answer it first; the answer is stored
+     * Answered once and stored either way, so it can't resurface later.
-     * either way, so the notice can't resurface later, when the same state would
-     * no longer be news to the user.
      */
     private suspend fun settleNoticeOnce(pending: Boolean) {
         if (prefs.visibilityNoticePending.first() != null) return
@@ -111,10 +86,7 @@ class CalendarVisibilityReconciler @Inject constructor(
 
     /**
      * Whether this install has ever run an earlier version. The notice explains
-     * a change to behaviour the user has already seen, so a first install has
+     * a behaviour change, so a first install has nothing to announce.
-     * nothing to announce — and hidden calendars are the *norm* on a fresh
-     * device (a second account's, "Holidays in …", a subscribed calendar), which
-     * would otherwise put a changelog dialog in front of a first-run user.
      */
     private fun isUpgradeInstall(): Boolean = try {
         @Suppress("DEPRECATION")

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

@@ -29,10 +29,8 @@ class CalendarPrefs @Inject constructor(
     private val store: DataStore<Preferences>,
 ) {
 
-    // Both id sets are deduped: the store is shared with SettingsPrefs, so every
+    // Both id sets are deduped: the store is shared with SettingsPrefs, so any
-    // unrelated write (a settings toggle, the last-used calendar) re-emits an
+    // unrelated write would otherwise re-emit an identical set.
-    // identical set otherwise — and a change to the pending set now costs a
-    // fresh provider read in CalendarRepositoryImpl.
     val hiddenCalendarIds: Flow<Set<Long>> = store.data
         .map { prefs -> prefs[HIDDEN_IDS_KEY].parseIds() }
         .distinctUntilChanged()
@@ -42,17 +40,13 @@ class CalendarPrefs @Inject constructor(
     }
 
     /**
-     * Calendars switched off in Settings → Calendars that the provider does not
+     * Switch-offs the provider does not know about yet, because writing
-     * know about yet. That switch writes the system's `Calendars.VISIBLE` (#75),
+     * `Calendars.VISIBLE` needs `WRITE_CALENDAR` (#75). Also inherits the
-     * which needs `WRITE_CALENDAR` — a user who granted read-only keeps their
+     * retired app-local model's set, from the same key.
-     * choice here instead, and so does everyone upgrading from the retired
-     * app-local model, whose set is read straight back out of the same key.
      *
-     * Honoured as a display and reminder filter for as long as it is non-empty,
+     * Honoured as a display and reminder filter while non-empty, but not a
-     * so an un-flushable switch still does what the user asked. Not a second
+     * second visibility model: `CalendarVisibilityReconciler` drains it entry by
-     * visibility model: `CalendarVisibilityReconciler` drains it into the
+     * entry as soon as the app may write, and nothing adds to it while it may.
-     * provider entry by entry the moment the app may write, and nothing ever
-     * adds to it while it may.
      */
     val pendingDisabledCalendarIds: Flow<Set<Long>> = store.data
         .map { prefs -> prefs[DISABLED_IDS_KEY].parseIds() }
@@ -62,9 +56,8 @@ class CalendarPrefs @Inject constructor(
         editPendingDisabled { it + ids }
 
     /**
-     * Drop [ids] from the pending set — one id at a time as the reconciler
+     * Drop [ids] from the pending set, one at a time as the reconciler flushes
-     * flushes it, so a run that fails part-way never re-applies what already
+     * them, so a run that fails part-way never re-applies what already landed.
-     * landed (and can't undo a switch the user has since flipped by hand).
      */
     suspend fun removePendingDisabledCalendarIds(ids: Collection<Long>) =
         editPendingDisabled { it - ids.toSet() }

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

@@ -10,19 +10,13 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * How far reminder delivery has got. One number, and it replaces everything the
+ * How far reminder delivery has got — the one number replacing the provider's
- * provider's `CalendarAlerts.STATE` used to do for us (#75).
+ * `CalendarAlerts.STATE` (#75). A scan posts the reminders falling after this
+ * watermark and up to now, then moves it to now, so a scan running twice cannot
+ * post twice while a late one still catches up.
  *
- * A scan posts the reminders whose moment falls after this watermark and up to
+ * Unset means "never scanned", not zero: the first scan after an install would
- * now, then moves it to now. That single rule gives both halves of what the
+ * otherwise treat every reminder since the epoch as overdue.
- * retired path got from the provider: a scan that runs twice cannot post the
- * same reminder again, and a scan that runs *late* — after a reboot, an app
- * update or a doze window swallowed the alarm — still posts everything the
- * missed alarm would have.
- *
- * Unset means "never scanned". It is deliberately not treated as zero: the first
- * scan after an install or an upgrade would otherwise consider every reminder
- * since the epoch overdue and bury the user in notifications.
  */
 @Singleton
 class ReminderStatePrefs @Inject constructor(

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

@@ -93,13 +93,9 @@ class ReminderActionReceiver : BroadcastReceiver() {
         private const val EXTRA_ALL_DAY = "all_day"
 
         /**
-         * An explicit intent to this receiver carrying [alert] as extras.
+         * An explicit intent to this receiver carrying [alert] as extras. The
-         *
+         * data URI duplicates no information but is what keeps two reminders'
-         * The data URI names the reminder and carries no information the extras
+         * `PendingIntent`s apart — `filterEquals` never compares extras.
-         * don't. It is what actually keeps two reminders' `PendingIntent`s
-         * apart: `filterEquals` compares action, component, data, type and
-         * categories — never extras — so without it a request-code collision
-         * would have them share one alarm and one payload.
          */
         fun intent(context: Context, action: String, alert: ReminderAlert): Intent =
             Intent(context, ReminderActionReceiver::class.java).apply {
@@ -116,13 +112,9 @@ class ReminderActionReceiver : BroadcastReceiver() {
             }
 
         /**
-         * A stable request code per (alert, action) so one notification's
+         * A stable request code per (alert, action), so one notification's
-         * PendingIntents stay distinct and don't clobber each other.
+         * PendingIntents stay distinct. The shift keeps the action slot intact;
-         *
+         * the top bits it drops are separated by [intent]'s per-reminder URI.
-         * The key is a hash now rather than a small row id, so the shift is what
-         * keeps the action slot intact; the top three bits it drops can make two
-         * *different* reminders share a code, which the per-reminder data URI in
-         * [intent] separates.
          */
         fun requestCode(alert: ReminderAlert, action: String): Int {
             val actionOffset = when (action) {

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

@@ -19,17 +19,10 @@ internal fun AlarmManager.canScheduleExactCompat(): Boolean =
     Build.VERSION.SDK_INT < Build.VERSION_CODES.S || canScheduleExactAlarms()
 
 /**
- * Holds the app's own wake-up for the next reminder — the half of delivery that
+ * Holds the app's own wake-up for the next reminder (#75). Exactly one alarm
- * used to be the provider's (#75).
+ * exists at a time, for the earliest reminder ahead; every firing re-scans and
- *
+ * re-arms. Exact, with an inexact allow-while-idle fallback where the OS
- * Exactly **one** alarm exists at a time, for the earliest reminder still ahead.
+ * withholds the capability (API 31–32 with the permission revoked).
- * Every firing re-scans and re-arms, so a reminder added, moved or deleted in
- * between is picked up on the next pass instead of needing an alarm per reminder
- * to be kept in sync with the provider's tables.
- *
- * A reminder that lands late is a broken reminder, hence an *exact* alarm; the
- * inexact allow-while-idle fallback only applies where the OS withholds the
- * capability (API 31–32 with the user's permission revoked).
  */
 @Singleton
 class ReminderAlarmScheduler @Inject constructor(

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

@@ -4,14 +4,9 @@ import de.jeanlucmakiola.calendula.domain.reminders.PlannedReminder
 
 /**
  * One reminder as the notification layer needs it: what to show, and the stable
- * [key] that identifies it across a reboot, a re-scan and a reinstall.
+ * [key] identifying it across a reboot, a re-scan and a reinstall. Derived from
- *
+ * the reminder itself (see [PlannedReminder.key]) — in-house delivery has no
- * [key] used to be the `CalendarAlerts` row id. It is now derived from the
+ * `CalendarAlerts` row to take an id from (#75).
- * reminder itself (see [PlannedReminder.key]) because there is no row any more —
- * in-house delivery reads `Instances` and `Reminders` and owns the alarm (#75).
- * Everything downstream only ever needed it to be stable and unique, which it
- * still is: it keys the notification tag, so a reminder posted twice replaces
- * itself instead of stacking, and it keys the snooze/dismiss `PendingIntent`s.
  */
 data class ReminderAlert(
     val key: Long,

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

@@ -9,16 +9,11 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * The read side of in-house reminder delivery: occurrences and the reminder
+ * The read side of in-house reminder delivery: occurrences and their reminder
- * offsets hanging off them, straight out of the provider's own tables.
+ * offsets, read from `Instances` and `Reminders` rather than `CalendarAlerts`,
+ * which cannot be assumed to be written (#75).
  *
- * Deliberately *not* `CalendarAlerts`. That table is the provider's own working
+ * An interface so [ReminderScanner] can be exercised on the JVM.
- * copy of this same information, and the whole point of #75's second round is
- * that we can no longer assume it gets written. `Instances` and `Reminders` are
- * plain data the app already reads everywhere else.
- *
- * An interface so [ReminderScanner] can be exercised on the JVM without a
- * ContentResolver, in the shape the rest of `data/calendar` uses.
  */
 interface ReminderInstanceSource {
 
@@ -46,11 +41,9 @@ class ProviderReminderInstanceSource @Inject constructor(
             ContentUris.appendId(this, fromMillis)
             ContentUris.appendId(this, toMillis)
         }.build()
-        // `visible` is the calendar's system flag, which the app's one visibility
+        // `visible` is the flag the app's one visibility model writes (#75).
-        // model writes (#75) — a switched-off calendar must not plan reminders.
+        // The status clause mirrors CalendarDataSource.instances: NULL means
-        // The status clause mirrors CalendarDataSource.instances: a cancelled
+        // "normal", so a bare `!= CANCELED` would drop every ordinary event.
-        // single occurrence of a series is a real row, and NULL means "normal",
-        // so a bare `!= CANCELED` would drop every ordinary event.
         val selection = "${CalendarContract.Calendars.VISIBLE} = 1 AND " +
             "(${CalendarContract.Instances.STATUS} IS NULL OR " +
             "${CalendarContract.Instances.STATUS} != ${CalendarContract.Events.STATUS_CANCELED})"
@@ -78,8 +71,8 @@ class ProviderReminderInstanceSource @Inject constructor(
     override fun reminderMinutes(eventIds: Collection<Long>): Map<Long, List<Int>> {
         if (eventIds.isEmpty()) return emptyMap()
         val out = mutableMapOf<Long, MutableList<Int>>()
-        // Batched because the ids go into the selection literally; an unbounded
+        // Batched: the ids go into the selection literally, and an unbounded
-        // `IN (...)` on a busy calendar would grow the SQL past what SQLite takes.
+        // `IN (...)` would grow the SQL past what SQLite takes.
         eventIds.distinct().chunked(EVENT_ID_BATCH).forEach { batch ->
             context.contentResolver.query(
                 CalendarContract.Reminders.CONTENT_URI,

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

@@ -15,13 +15,8 @@ import java.util.concurrent.TimeUnit
 
 /**
  * The backstop under the alarm: a daily scan that runs whether or not the alarm
- * survived.
+ * survived. Finds nothing to do in the steady state; it exists for the device
- *
+ * that quietly drops the alarm without a reboot to announce it (#75).
- * The scan alarm re-arms itself at most a day out, so in the steady state this
- * finds nothing to do. It exists for the case the whole feature is about — a
- * device that quietly drops the alarm without a reboot to announce it. The
- * scheduling half of reminder delivery must not have a single point of failure,
- * which is exactly what the provider's broadcast turned out to be.
  */
 object ReminderMaintenanceScheduler {
 
@@ -55,8 +50,8 @@ class ReminderMaintenanceWorker(
             .scan()
         Result.success()
     } catch (e: Exception) {
-        // The scan swallows its own failures; anything reaching here is the
+        // The scan swallows its own failures, so anything reaching here is the
-        // entry point itself, which a retry will not mend. Never fail the chain.
+        // entry point itself — a retry will not mend it.
         Log.w(TAG, "Reminder maintenance scan failed", e)
         Result.success()
     }

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

@@ -54,12 +54,10 @@ class ReminderNotifier @Inject constructor(
     }
 
     /**
-     * The single choke point for "this calendar is switched off". The scan
+     * The single choke point for "this calendar is switched off", covering the
-     * already filters on `Calendars.VISIBLE`, but two paths reach [post] around
+     * two paths that reach [post] around the scan's own filter: a snooze armed
-     * it: a snooze re-shown from its own alarm, armed before the calendar was
+     * before the switch-off, and a read-only install whose switch lives in
-     * switched off, and a read-only install whose switch lives app-side
+     * [CalendarPrefs].
-     * ([CalendarPrefs]) because it may not write the flag. Both are covered here
-     * rather than in either receiver.
      */
     private suspend fun isSilenced(calendarId: Long): Boolean =
         calendarId in calendarPrefs.pendingDisabledCalendarIds.first() ||
@@ -123,7 +121,7 @@ class ReminderNotifier @Inject constructor(
             // POST_NOTIFICATIONS was revoked between canPost() and here.
             Log.w(TAG, "Could not post reminder for event ${alert.eventId}", e)
         }
-        // Handled either way: re-running it would hit the same revoked permission.
+        // Handled either way — a retry hits the same revoked permission.
         return true
     }
 
@@ -142,8 +140,7 @@ class ReminderNotifier @Inject constructor(
 
     private fun detailIntent(alert: ReminderAlert): PendingIntent = PendingIntent.getActivity(
         context,
-        // Shares the per-(alert, action) request-code scheme with the buttons, so
+        // Shares the per-(alert, action) request-code scheme with the buttons.
-        // the key's wider value range can't collide one notification's intents.
         /* requestCode = */ ReminderActionReceiver.requestCode(
             alert, ReminderActionReceiver.ACTION_OPEN,
         ),

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

@@ -33,13 +33,9 @@ import javax.inject.Singleton
 
 /**
  * One pass of in-house reminder delivery: read what is planned, post what has
- * come due, and arm the next wake-up.
+ * come due, and arm the next wake-up. Every trigger runs the same [scan], and
- *
+ * re-running is always safe — the watermark in [ReminderStatePrefs] decides what
- * This is the whole loop. Every trigger — the alarm firing, boot, a clock or
+ * is owed, not the trigger.
- * timezone change, an edit landing in the provider, the app starting, the daily
- * safety net — runs the same [scan], so there is a single path to reason about
- * and no ordering between triggers to get wrong. Re-running it is always safe:
- * the watermark in [ReminderStatePrefs] decides what is owed, not the trigger.
  */
 @Singleton
 class ReminderScanner @Inject constructor(
@@ -68,8 +64,7 @@ class ReminderScanner @Inject constructor(
             try {
                 runScan()
             } catch (e: SecurityException) {
-                // The calendar permission was revoked mid-flight. Nothing to
+                // Permission revoked mid-flight; the next grant re-scans.
-                // re-arm and nothing to recover from — the next grant re-scans.
                 Log.w(TAG, "Reminder scan lacks the calendar permission", e)
             } catch (e: Exception) {
                 Log.w(TAG, "Reminder scan failed", e)
@@ -82,18 +77,16 @@ class ReminderScanner @Inject constructor(
         if (!hasReadCalendar()) return
 
         if (!settingsPrefs.remindersEnabled.first()) {
-            // Reminders off: drop the wake-up, but keep the watermark moving so
+            // Reminders off: drop the wake-up, but keep the watermark moving
-            // switching them back on doesn't replay everything missed meanwhile.
+            // so switching them back on doesn't replay the backlog.
             alarms.cancelScan()
             state.setLastScanMillis(now)
             return
         }
 
         val lookahead = reminderQueryHorizon(LOOKAHEAD_MILLIS, source.longestReminderMinutes())
-        // Reach a little into the past as well: an event already under way can
+        // Reach into the past too: an all-day "at time of event" encodes to a
-        // still owe a reminder (an all-day "at time of event" encodes to a
+        // negative offset, and a catch-up pass needs the occurrences it missed.
-        // negative offset, which fires after begin), and a catch-up pass needs
-        // to see the occurrences whose moment it missed.
         val occurrences = source.occurrences(now - PAST_WINDOW_MILLIS, now + lookahead)
         val planned = planReminders(
             instances = occurrences,
@@ -112,8 +105,8 @@ class ReminderScanner @Inject constructor(
         if (notifier.canPost()) {
             schedule.due.forEach { notifier.post(it.toAlert()) }
         }
-        // Advance regardless of whether anything could be posted: a user who
+        // Advance even when nothing could be posted, so muting notifications
-        // muted notifications is not owed a backlog when they unmute.
+        // doesn't build a backlog.
         state.setLastScanMillis(now)
         alarms.scheduleScan(schedule.nextAlarmMillis)
     }
@@ -123,13 +116,9 @@ class ReminderScanner @Inject constructor(
     ) == PackageManager.PERMISSION_GRANTED
 
     /**
-     * Re-scan when the provider changes, so an event saved or deleted in the app
+     * Re-scan when the provider changes, so a saved or deleted event re-arms the
-     * re-arms the alarm immediately rather than waiting for the next pass.
+     * alarm at once. Debounced, since a single save lands as several
-     *
+     * notifications. Process-lifetime only; other triggers cover the rest.
-     * Debounced: a single save writes the event, its reminders and its
-     * attendees, and each lands as its own notification. Only useful while the
-     * process is alive — every other trigger covers the rest, which is why
-     * nothing here needs to survive it.
      */
     fun startWatchingProvider() {
         if (watching) return
@@ -159,9 +148,8 @@ class ReminderScanner @Inject constructor(
         const val PAST_WINDOW_MILLIS = 24L * 60 * 60 * 1000
 
         /**
-         * Never wait longer than a day for the next pass, even with nothing
+         * Never wait longer than a day for the next pass: it rolls the lookahead
-         * pending: it rolls the lookahead window forward and re-arms an alarm
+         * window forward and re-arms an alarm the system may have dropped.
-         * the system may have dropped.
          */
         const val MAX_ALARM_INTERVAL_MILLIS = 24L * 60 * 60 * 1000
 

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

@@ -11,22 +11,13 @@ import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 /**
- * Every reason to re-run a reminder scan that arrives from outside the process.
+ * Every out-of-process reason to re-run a reminder scan: our own [ACTION_SCAN]
+ * alarm, boot and package-replaced (both wipe pending alarms), and time or
+ * timezone changes (both move reminders relative to the armed alarm). All do the
+ * same thing, since [ReminderScanner.scan] is idempotent.
  *
- * All of them do the same thing, because [ReminderScanner.scan] is idempotent
+ * Exported for the system broadcasts; an early scan triggered by another app is
- * and works out what is owed from its watermark rather than from why it was
+ * harmless.
- * called:
- *
- * - **our own alarm** ([ACTION_SCAN]) — the ordinary case, a reminder is due;
- * - **boot** and **package replaced** — both wipe pending alarms, so the app has
- *   to re-arm or reminders stop silently, which is the failure #75 is about;
- * - **time and timezone changes** — they move every reminder relative to the
- *   armed alarm, and an all-day reminder's fire hour is recomposed in the
- *   current zone, so both need a fresh plan.
- *
- * Exported because the system broadcasts arrive from outside. [ACTION_SCAN] is
- * ours and always sent as an explicit intent; another app triggering a scan
- * early would only make it re-read the provider and re-arm, which is harmless.
  */
 @AndroidEntryPoint
 class ReminderScheduleReceiver : BroadcastReceiver() {
@@ -34,10 +25,9 @@ class ReminderScheduleReceiver : BroadcastReceiver() {
     @Inject lateinit var scanner: ReminderScanner
 
     override fun onReceive(context: Context, intent: Intent) {
-        // Every action here does the same thing, but the filter still has to be
+        // Checked despite every action doing the same thing: the receiver is
-        // checked: the receiver is exported, and the system broadcasts it takes
+        // exported and the broadcasts it takes are protected, so any other
-        // are protected, so an intent arriving with any other action did not
+        // action did not come from where it claims to.
-        // come from where it claims to.
         if (intent.action !in HANDLED_ACTIONS) return
         val pendingResult = goAsync()
         CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {

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

@@ -10,17 +10,13 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * Schedules a one-off exact alarm that re-shows a snoozed reminder.
+ * Schedules a one-off exact alarm that re-shows a snoozed reminder. Separate
+ * from [ReminderAlarmScheduler]'s single moving scan alarm: a snooze is pinned
+ * to one reminder and has to outlive the watermark moving past it, so it carries
+ * the reminder in its own intent.
  *
- * Separate from [ReminderAlarmScheduler]'s scan alarm, and deliberately so: a
+ * Falls back to an inexact allow-while-idle alarm where the OS withholds the
- * snooze is pinned to one reminder at a time the user chose, while the scan
+ * exact-alarm capability (API 31–32 with the permission revoked).
- * alarm is a single moving wake-up for whatever comes next. A re-show also has
- * to outlive the scan's watermark moving past that reminder, so it carries the
- * reminder in its own intent rather than re-deriving it.
- *
- * A snooze that lands late is a broken snooze, hence an *exact* alarm; we fall
- * back to an inexact allow-while-idle alarm only if the OS withholds the
- * exact-alarm capability (API 31–32 where the user revoked it).
  */
 @Singleton
 class ReminderSnoozeScheduler @Inject constructor(
@@ -40,8 +36,8 @@ class ReminderSnoozeScheduler @Inject constructor(
                 AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
             )
         } else {
-            // Exact alarms revoked (API 31–32): an inexact wake is the honest
+            // Exact alarms revoked (API 31–32); an inexact wake is the best
-            // best we can do without nagging for SCHEDULE_EXACT_ALARM.
+            // available without nagging for SCHEDULE_EXACT_ALARM.
             alarmManager.setAndAllowWhileIdle(
                 AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
             )

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

@@ -1,15 +1,13 @@
 package de.jeanlucmakiola.calendula.domain
 
 /**
- * The ways a calendar can behave unlike a plain, writable one — each of them a
+ * The ways a calendar can behave unlike a plain, writable one — each a reason it
- * reason it is missing from the event and import pickers, and each of them
+ * is missing from the event and import pickers (#76).
- * something the app knows and used to keep to itself (#76).
  */
 enum class CalendarStateLabel {
     /**
      * A special-dates mirror the app fills from contacts. Writable and visible,
-     * yet no event target: anything authored here is deleted by the next sync,
+     * yet no event target: anything authored here is deleted by the next sync.
-     * which is why it is the one exclusion with nothing else to give it away.
      */
     MANAGED,
 
@@ -21,22 +19,17 @@ enum class CalendarStateLabel {
 }
 
 /**
- * Whether the account this calendar belongs to keeps its events off the device
+ * Whether the account keeps this calendar's events off the device
- * (`Calendars.SYNC_EVENTS = 0`) — an "empty by construction" calendar: the rows
+ * (`Calendars.SYNC_EVENTS = 0`) — empty by construction. Device-local calendars
- * simply aren't here, so nothing can display them and no reminder can fire.
+ * are excluded: nothing syncs them by definition, and one from another app can
- *
+ * hold real events at `sync_events = 0`.
- * Device-local calendars are excluded deliberately. Nothing syncs them by
- * definition, so the flag says nothing about them, and a local calendar from
- * another app can hold real events at `sync_events = 0` — the same unsoundness
- * that made the #75 migration guard wrong.
  */
 val CalendarSource.isNotSynced: Boolean
     get() = !syncsEvents && !isLocal
 
 /**
  * Whether a visibility switch on this calendar can change anything the user
- * would see. It can't for a non-syncing one: there are no events on the device
+ * would see — it can't for a non-syncing one, with no events on the device.
- * to reveal, so the switch would be a control that does nothing.
  */
 val CalendarSource.hasVisibilitySwitch: Boolean
     get() = !isNotSynced
@@ -44,18 +37,9 @@ val CalendarSource.hasVisibilitySwitch: Boolean
 /**
  * Whether this calendar can be offered as a target for a new or imported event.
  * The one predicate behind both pickers, so the states [CalendarStateLabel]
- * names on a manager row are exactly the states that keep a calendar out of
+ * names on a manager row are exactly the states that keep a calendar out of them
- * them (#76):
+ * (#76). An event already living in an excluded calendar keeps it; the editor
- *
+ * adds that calendar back to its picker.
- * - read-only has nowhere to write;
- * - switched off would hide the event the moment it was saved;
- * - a managed mirror has the next contact sync delete it;
- * - a non-syncing one never carries the event up to the account, and
- *   `CalendarProvider2` wipes the calendar's rows outright when the
- *   subscription is switched back on — a saved event is a dead end either way.
- *
- * This is the test for *targets*. An event already living in an excluded
- * calendar keeps it; the editor adds that calendar back to its picker.
  */
 val CalendarSource.isEventTarget: Boolean
     get() = canModifyContents && isVisibleInSystem && !isManaged && !isNotSynced

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

@@ -12,22 +12,16 @@ data class CalendarVisibilityPlan(
 }
 
 /**
- * Reconcile [pendingDisabledIds] — calendars switched off in Settings →
+ * Reconcile [pendingDisabledIds] — switch-offs the app could not write, plus
- * Calendars while the app could not write `Calendars.VISIBLE`, plus whatever
+ * what the retired app-local visibility model left behind (#75) — against the
- * the retired app-local visibility model left behind (#75) — against the
  * calendars actually on the device.
  *
- * The plan only ever *hides*. Switching a calendar off is intent the user
+ * Only ever *hides*: switching a system-hidden calendar back on would un-hide it
- * expressed in Calendula, so carrying it into the provider is fair. The other
+ * in every other calendar app too. Calendula follows the flag and explains
- * direction is deliberately absent: a calendar hidden at system level was hidden
+ * itself once (see [hasSystemHiddenCalendars]).
- * somewhere else (another calendar app, the account's own settings), and
- * switching it back on would un-hide it there too *and* start firing reminders
- * nobody asked for. Calendula follows that flag instead and explains itself once
- * (see [hasSystemHiddenCalendars]).
  *
- * [CalendarVisibilityPlan.settled] carries the ids that need no write — already
+ * [CalendarVisibilityPlan.settled] carries the ids needing no write — already
- * hidden, or gone from the device. They leave the pending set exactly as a
+ * hidden, or gone from the device.
- * successful write would.
  */
 fun calendarVisibilityPlan(
     calendars: List<CalendarSource>,
@@ -38,8 +32,7 @@ fun calendarVisibilityPlan(
     val settled = mutableSetOf<Long>()
     for (id in pendingDisabledIds) {
         val calendar = byId[id]
-        // No row means the calendar is gone; already invisible means someone
+        // Gone from the device, or already invisible — nothing to write.
-        // (us, on an earlier run) got there first. Either way: nothing to write.
         if (calendar != null && calendar.isVisibleInSystem) hide += id else settled += id
     }
     return CalendarVisibilityPlan(hide = hide, settled = settled)
@@ -47,10 +40,7 @@ fun calendarVisibilityPlan(
 
 /**
  * Whether any calendar is switched off at system level without Calendula having
- * asked for it. Those calendars showed their events before the app adopted
+ * asked for it — the condition the one-time notice explains.
- * `Calendars.VISIBLE` as its one visibility model and no longer do, which is
- * what the one-time notice explains — the alternative, switching them on, would
- * reach into every other calendar app on the device.
  */
 fun hasSystemHiddenCalendars(
     calendars: List<CalendarSource>,

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

@@ -13,11 +13,9 @@ data class CalendarSource(
     val accountType: String,
     val color: Int,
     /**
-     * The system's per-calendar `Calendars.VISIBLE` flag — the single visibility
+     * The system's `Calendars.VISIBLE` flag — the single visibility model,
-     * model: it decides both what Calendula shows and whether the provider
+     * deciding both what Calendula shows and whether this calendar plans
-     * schedules this calendar's reminder alarms at all (#75). Settings →
+     * reminders (#75). The drawer's filter sheet is a separate in-app declutter.
-     * Calendars writes it; the drawer's filter sheet is a separate, purely
-     * in-app declutter that leaves reminders alone.
      */
     val isVisibleInSystem: Boolean,
     /**
@@ -47,10 +45,8 @@ data class CalendarSource(
     val isManaged: Boolean = false,
     /**
      * Whether the provider keeps this calendar's events on the device
-     * (`Calendars.SYNC_EVENTS`). Independent of [isVisibleInSystem]. For a
+     * (`Calendars.SYNC_EVENTS`), independent of [isVisibleInSystem]. Says
-     * synced account it means the events aren't stored locally at all, so the
+     * nothing about device-local calendars, which can hold events with it off.
-     * calendar reads as permanently empty; a device-local calendar another app
-     * created can hold events with the flag off, so it says nothing there.
      * Read for the "not synced" row label (#76).
      */
     val syncsEvents: Boolean = true,
@@ -77,12 +73,9 @@ data class EventInstance(
 fun EventInstance.hasEnded(now: Instant): Boolean = end <= now
 
 /**
- * The zone this event's calendar dates live in. Timed events are resolved in the
+ * The zone this event's calendar dates live in: the device [zone] for timed
- * device [zone]; all-day events live at UTC midnights with an exclusive end, so
+ * events, UTC for all-day ones, whose midnights would otherwise shift day
- * resolving them anywhere else shifts the day boundaries — east of UTC the end
+ * boundaries (#65, #82). Every surface naming an all-day date goes through here.
- * leaks onto the following day (#65), west of UTC the start pulls back onto the
- * previous one (#82). Every surface that has to name an all-day event's date
- * goes through here, so grid, agenda, detail and search cannot disagree.
  */
 fun EventInstance.dateZone(zone: TimeZone): TimeZone =
     if (isAllDay) TimeZone.UTC else zone
@@ -92,9 +85,8 @@ fun EventInstance.spanFirstDay(zone: TimeZone): LocalDate =
     start.toLocalDateTime(dateZone(zone)).date
 
 /**
- * The last calendar day this event actually occupies. An event ending exactly at
+ * The last calendar day this event occupies. An event ending exactly at midnight
- * midnight (all-day events end at the exclusive next-midnight) does not reach
+ * does not reach into that day, so resolve just before [EventInstance.end].
- * into that boundary day, so resolve the instant just before [EventInstance.end].
  */
 fun EventInstance.spanLastDay(zone: TimeZone): LocalDate {
     val lastInstant = if (end > start) end - 1.milliseconds else start

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

@@ -10,31 +10,18 @@ import kotlinx.datetime.plus
 
 /**
  * The first [limit] dates a [SimpleRecurrence] fires on, starting at [start]
- * (the event's own start date, i.e. DTSTART), for showing a rule as dates
+ * (DTSTART), for previewing a rule as dates instead of as words. A preview only,
- * instead of as words.
+ * kept to the shapes the picker can build; the provider stays the authority.
  *
- * A recurrence rule is the one place in the editor where a correct-sounding
+ * Mirrors RFC 5545: [start] is always the first occurrence (§3.8.5.3), even when
- * phrase can still mean something the user didn't intend — "every 2 weeks on
+ * the rule's own picks miss it; a monthly or yearly rule *skips* a period the
- * Mon, Fri", "monthly" on the 31st — and the only honest answer is the dates
+ * start day doesn't exist in rather than clamping; a weekly rule repeats in
- * themselves. This is a *preview*, deliberately kept to the shapes the picker
+ * blocks of `interval` weeks beginning on Monday (the default WKST, since
- * can build; the provider remains the authority on what actually gets stored
+ * [toRRule] never writes one); [RecurrenceEnd.Count] counts real occurrences and
- * and expanded.
+ * [RecurrenceEnd.Until] is inclusive.
  *
- * The rules it mirrors, all from RFC 5545 (the spec the platform's recurrence
+ * Returns fewer than [limit] dates when the series ends first, and an empty list
- * engine implements):
+ * only when the rule yields nothing at all (an UNTIL before [start]).
- * - a monthly or yearly rule **skips** a period the start day doesn't exist in,
- *   rather than sliding to the month's last day: the 31st recurring monthly
- *   lands only in 31-day months, 29 February yearly only in leap years.
- * - a weekly rule with weekday picks repeats in blocks of `interval` weeks,
- *   with the week beginning on **Monday** — the RFC's default WKST, and the one
- *   that applies here because [toRRule] never writes a WKST part. The
- *   display-only "first day of week" preference deliberately doesn't enter into
- *   it, or the preview would disagree with the stored rule.
- * - [RecurrenceEnd.Count] counts real occurrences (skipped periods don't
- *   consume one), [RecurrenceEnd.Until] is inclusive of its date.
- *
- * Returns fewer than [limit] dates when the series ends first, and an empty
- * list when the rule yields nothing at all (an UNTIL before the start).
  */
 fun SimpleRecurrence.upcomingOccurrences(start: LocalDate, limit: Int): List<LocalDate> {
     if (limit <= 0) return emptyList()
@@ -42,15 +29,17 @@ fun SimpleRecurrence.upcomingOccurrences(start: LocalDate, limit: Int): List<Loc
     val maxCount = (end as? RecurrenceEnd.Count)?.times ?: Int.MAX_VALUE
     val wanted = minOf(limit, maxCount)
     if (wanted <= 0) return emptyList()
+    if (until != null && start > until) return emptyList()
 
-    val result = mutableListOf<LocalDate>()
+    // DTSTART is in the recurrence set whatever the rule picks, so seed with it
+    // and let the walk skip anything landing on or before it.
+    val result = mutableListOf(start)
     var period = 0
-    // Periods that produce nothing (a skipped 31st, a weekday block whose picks
+    // Periods can yield nothing (a skipped 31st), so the cap counts periods
-    // all fall before the start) must not stall the walk, so the cap is on
+    // examined rather than dates found.
-    // periods examined rather than on dates found.
     while (result.size < wanted && period < MAX_PERIODS) {
         for (date in occurrencesInPeriod(period, start)) {
-            if (date < start) continue
+            if (date <= start) continue
             if (until != null && date > until) return result
             result += date
             if (result.size == wanted) return result
@@ -67,8 +56,8 @@ private fun SimpleRecurrence.occurrencesInPeriod(period: Int, start: LocalDate):
         RecurrenceFreq.Weekly -> weeklyOccurrences(period, start)
         RecurrenceFreq.Monthly -> {
             val month = start.plus(period * interval, DateTimeUnit.MONTH)
-            // plus() clamps the day into the shorter month; the rule instead
+            // plus() clamps into the shorter month, but the rule skips such a
-            // skips such a period, so a clamped date means "not this month".
+            // period — so a clamped date means "not this month".
             listOfNotNull(dateOrNull(month.year, month.month.number, start.day))
         }
         RecurrenceFreq.Yearly ->
@@ -96,13 +85,9 @@ private fun SimpleRecurrence.weeklyOccurrences(period: Int, start: LocalDate): L
 }
 
 /**
- * Whether a run of [occurrences] starting at [start] leaves its starting year —
+ * Whether a run of [occurrences] starting at [start] leaves its starting year,
- * i.e. whether showing them without a year would be ambiguous.
+ * i.e. whether showing them without a year would be ambiguous — a yearly rule
- *
+ * would otherwise read as the same date repeated.
- * Day and month alone are enough for a rule that stays inside one year, and
- * dropping the year keeps the line short. They are actively misleading
- * otherwise: a yearly rule reads as the same date three times over, and a
- * monthly one rolling past December gives no hint that it has.
  */
 fun occurrencesSpanYears(occurrences: List<LocalDate>, start: LocalDate): Boolean =
     occurrences.any { it.year != start.year } || occurrences.map { it.year }.distinct().size > 1
@@ -114,9 +99,8 @@ private fun dateOrNull(year: Int, month: Int, day: Int): LocalDate? =
 private const val DAYS_PER_WEEK = 7
 
 /**
- * How many repetitions to examine before giving up. Generous enough for the
+ * How many repetitions to examine before giving up: generous enough for the
- * sparsest rule the picker can build (29 February yearly with a 999-year
+ * sparsest rule the picker can build, bounded so a rule whose occurrences all
- * interval is nonsense; 31st monthly needs at most a handful), and bounded so a
+ * fall outside its own UNTIL can't spin.
- * rule whose occurrences all fall outside its own UNTIL can't spin.
  */
 private const val MAX_PERIODS = 2_000

app/src/main/java/de/jeanlucmakiola/calendula/domain/reminders/ReminderPlan.kt

@@ -8,21 +8,8 @@ import java.time.ZoneOffset
 import java.time.temporal.ChronoUnit
 
 /**
- * Works out *when* each reminder has to fire and *which* ones are due, with no
+ * Pure decision layer of in-house reminder delivery (#75): instances and reminder
- * provider and no clock of its own — the whole decision layer of in-house
+ * offsets in, fire instants out. No provider, no clock. See docs/ARCHITECTURE.md.
- * reminder delivery (#75).
- *
- * Calendula used to leave both halves to the calendar provider: it scheduled the
- * alarms, wrote the `CalendarAlerts` rows, and broadcast `EVENT_REMINDER` at the
- * right moment. That chain is intact on stock Android but demonstrably not on
- * every device — AOSP's own unbundled calendar carries three separate
- * workarounds for OEMs that retarget the broadcast, or that only write the alert
- * row at alert time. An app that can only *react* to that broadcast has no way
- * to notice it never came.
- *
- * So the offsets in `CalendarContract.Reminders` are now read as data and turned
- * into alarms we own. Everything here is pure: instances and reminder offsets in,
- * fire instants out.
  */
 
 /** An occurrence that reminders can hang off, flattened out of `Instances`. */
@@ -46,11 +33,8 @@ data class PlannedReminder(
     val alarmMillis: Long,
 ) {
     /**
-     * Stable identity of this reminder, derived from what defines it rather
+     * Stable identity, keying the notification tag and the snooze/dismiss
-     * than from a provider row id (there is none any more). It keys the
+     * `PendingIntent`s. Survives reboot, re-scan and reinstall.
-     * notification tag and the snooze/dismiss `PendingIntent`s, so it has to
-     * survive a reboot, a re-scan and a reinstall — the same reminder must land
-     * on the same notification instead of stacking a second one.
      */
     val key: Long = key(instance.eventId, instance.beginMillis, minutes)
 
@@ -75,28 +59,10 @@ private const val MINUTES_PER_DAY = 1_440
 /**
  * Pair every instance with each of its event's reminder offsets.
  *
- * A **timed** occurrence is trivial: `begin` is an absolute instant, so
+ * Timed occurrences fire at `begin − minutes`. All-day ones read the offset only
- * `begin − minutes` is exact by construction, in any timezone, across any DST
+ * for *which day* it means ([allDayLeadDays]) and take the hour from
- * boundary.
+ * [allDayTimeMinutes], recomposed against each occurrence's own date in [zone].
- *
+ * Duplicate offsets in [minutesByEvent] collapse.
- * An **all-day** occurrence is not, and taking the offset at face value is what
- * makes reminders land at the wrong hour. Its `begin` is UTC midnight, and the
- * stored offset is not a plain lead time — `AllDayReminderEncoding` folds the
- * wanted wall-clock hour into it, sampled against *one* date's UTC offset. Fire
- * at `begin − minutes` and every occurrence in a different DST phase than the one
- * that was sampled drifts by the offset delta, an hour early in one direction and
- * an hour late in the other. Rows written by other apps carry no wall-clock at
- * all — a conventional `1440` fires at UTC midnight, which is 01:00 or 02:00
- * local in Berlin and the wrong day west of UTC.
- *
- * So the offset is only read for *which day* it means, via [allDayLeadDays], and
- * the hour comes from [allDayTimeMinutes] — the one global "show all-day
- * reminders at" setting — recomposed against each occurrence's own date in
- * [zone]. 09:00 Berlin is then 09:00 Berlin on every occurrence, whatever the
- * offset was when the row was written.
- *
- * [minutesByEvent] may hold duplicate offsets (two identical reminder rows on one
- * event); they collapse, because they would otherwise fight over one notification.
  */
 fun planReminders(
     instances: List<ReminderEventInstance>,
@@ -124,30 +90,15 @@ private fun allDayDate(beginMillis: Long): LocalDate =
 /**
  * How many whole days before its occurrence a raw all-day offset means.
  *
- * Normally the local date of the encoded fire instant answers it: our own rows
+ * Our own rows fold the wanted hour into the offset, so the local date of the
- * fold the wanted hour into the offset, so that date *is* the day the reminder
+ * encoded instant is the answer. A plain multiple of 1440 is a foreign bare lead
- * belongs to, whatever the offset was when it was written.
+ * time and taken at face value instead — unless the instant lands on the hour the
+ * setting names (within [NAMED_HOUR_TOLERANCE_MINUTES], for DST drift), where the
+ * encodings collide and the tie goes to our own reading.
  *
- * A plain multiple of 1440 is the exception. Those come from calendar apps that
+ * Also used by
- * store a bare lead time against UTC midnight, and east of UTC both readings
+ * [de.jeanlucmakiola.calendula.data.calendar.fromProviderAllDayMinutes] for
- * agree anyway — but west of UTC the instant falls on the previous local date,
+ * display, so screen and notification agree.
- * so the day count has to be taken at face value or it comes out one too many.
- *
- * Except when the row is one of ours after all: our offset lands on a multiple
- * whenever the all-day hour equals the zone's UTC offset (20:00 in New York,
- * 19:00 an hour further west, and so on), and reading those at face value fired
- * them a day late — a "1 day before" arriving on the morning of the event. So
- * the hour decides, not the shape of the number: an instant landing on the hour
- * the setting names is ours. Within an hour or so of it counts, because a fixed
- * offset written in one DST phase drifts by the offset delta in the other.
- *
- * The two are genuinely indistinguishable in that band — the encodings collide
- * exactly there — so the tie goes to the reading that honours the lead time the
- * user chose in this app.
- *
- * [de.jeanlucmakiola.calendula.data.calendar.fromProviderAllDayMinutes] calls
- * this for display, so the notification arrives on the day the event screen says
- * it will.
  */
 internal fun allDayLeadDays(
     rawMinutes: Int,
@@ -185,17 +136,10 @@ private fun allDayAlarmMillis(
 /**
  * Split [planned] into what is due now and when to wake up next.
  *
- * Due means the fire instant falls in `(lastFiredMillis, nowMillis]` — a
+ * Due means the fire instant falls in `(lastFiredMillis, nowMillis]`, so a scan
- * half-open watermark, so a scan triggered twice cannot post the same reminder
+ * running twice cannot post twice while a late one still catches up. Reminders
- * twice, while a scan that runs late still catches everything the missed alarm
+ * whose event has ended are dropped ([isStillRelevant]). [nextAlarmMillis] is
- * would have posted. That catch-up is the point: an alarm dropped by a reboot,
+ * capped at [horizonMillis] so the lookahead window keeps rolling forward.
- * an app update or a doze window is recovered by the next scan rather than lost.
- *
- * A reminder whose event has already ended is dropped rather than posted late —
- * see [isStillRelevant].
- *
- * [nextAlarmMillis] is capped at [horizonMillis] even when nothing is pending, so
- * the scan re-runs at least that often and the lookahead window rolls forward.
  */
 fun scheduleReminders(
     planned: List<PlannedReminder>,
@@ -225,31 +169,20 @@ fun ReminderEventInstance.isStillRelevant(nowMillis: Long): Boolean =
     (endMillis.takeIf { it > 0L } ?: beginMillis) >= nowMillis
 
 /**
- * The watermark a scan at [nowMillis] should measure against, given what the
+ * The watermark a scan at [nowMillis] should measure against. A first-ever scan
- * last one recorded.
+ * claims the present rather than replaying everything since the epoch; a
- *
+ * watermark in the future (clock moved back) is clamped so it can't silence
- * A first-ever scan ([lastScanMillis] `null`) claims the present, so an install
+ * every reminder until real time catches up.
- * or an upgrade onto in-house delivery does not treat every reminder since the
- * epoch as overdue and bury the user in notifications. A watermark in the
- * *future* — the clock was moved back, or the user travelled across the date
- * line — is clamped for the mirror-image reason: left alone it would silence
- * every reminder until real time caught up with it.
  */
 fun reminderWatermark(lastScanMillis: Long?, nowMillis: Long): Long =
     lastScanMillis?.coerceAtMost(nowMillis) ?: nowMillis
 
 /**
- * How far ahead instances must be queried for [scheduleReminders] to see every
+ * How far ahead instances must be queried: the plain lookahead plus the longest
- * reminder in time: the plain lookahead plus the longest offset any reminder row
+ * reminder offset, so a "two weeks before" is planned before it comes due. The
- * carries, so a "two weeks before" reminder is planned before it comes due
+ * stretch is capped at [MAX_REMINDER_LEAD_MILLIS] — `maxReminderMinutes` is the
- * instead of firing late (the limitation Etar's equivalent documents).
+ * largest row in the whole provider, and a nonsense one would otherwise make
- *
+ * every scan expand every series over years.
- * The stretch is capped at [MAX_REMINDER_LEAD_MILLIS]. `maxReminderMinutes` is
- * whatever the largest row in the whole provider says, across every calendar and
- * whoever wrote it — an imported `TRIGGER:-P100W`, or a sync adapter writing
- * nonsense, would otherwise make every scan (launch, every provider change, every
- * alarm) expand every recurring series over years. A lead beyond the cap is not
- * delivered; a year is far past anything the picker composes.
  */
 fun reminderQueryHorizon(lookaheadMillis: Long, maxReminderMinutes: Int): Long =
     lookaheadMillis + (maxReminderMinutes * MILLIS_PER_MINUTE).coerceIn(0L, MAX_REMINDER_LEAD_MILLIS)

app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt

@@ -149,9 +149,8 @@ fun CalendarHost(
     // over Settings and survives view switches.
     var showCalendars by rememberSaveable { mutableStateOf(false) }
 
-    // Backup & restore (#69) — like the manager, driven by the calendar list
+    // Backup & restore (#69) — hoisted like the manager, being driven by the
-    // rather than by preferences, so it is hoisted here instead of living as a
+    // calendar list rather than by preferences. Reached from both.
-    // Settings sub-section. Reached from Settings and from the manager.
     var showBackup by rememberSaveable { mutableStateOf(false) }
 
     // Event form (v1.2 create) — same held-key pattern as the detail screen:
@@ -486,10 +485,8 @@ fun CalendarHost(
             )
         }
 
-        // Calendar manager — declared last so it covers every overlay that can
+        // Declared last so it covers every overlay that can open it: Settings,
-        // open it: Settings, both event forms, and the .ics import picker (#76).
+        // both event forms, and the .ics import picker (#76).
-        // Coming back from it leaves the caller exactly as it was, with the
-        // calendar list already refreshed by the provider's notification.
         AnimatedVisibility(
             visible = showCalendars,
             enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
@@ -509,12 +506,15 @@ fun CalendarHost(
         ) {
             BackupScreen(
                 onBack = { showBackup = false },
-                // Restoring runs the normal .ics import, and that way round this
+                // Restore runs the normal .ics import, and both this screen and
-                // screen has to step aside: declared above the import overlays,
+                // the manager that can have opened it are declared above the
-                // it would otherwise cover the screen it just asked for. Closing
+                // import overlays — so both have to step aside.
-                // it hands the user back to whatever opened Backup once the
+                onImport = {
-                // import is done.
+                    importUri = it
-                onImport = { importUri = it; importForceMany = true; showBackup = false },
+                    importForceMany = true
+                    showBackup = false
+                    showCalendars = false
+                },
             )
         }
     }

app/src/main/java/de/jeanlucmakiola/calendula/ui/RootScreen.kt

@@ -51,8 +51,8 @@ fun RootScreen(
         )
     }
 
-    // Whether the app came up already holding it — a launch scan has covered
+    // A launch scan already covers the app coming up with the permission, so
-    // that case, so only a grant made during this session owes a re-scan.
+    // only a grant made during this session owes a re-scan.
     val grantedAtLaunch = remember { hasPermission }
 
     val lifecycle = LocalLifecycleOwner.current.lifecycle
@@ -86,12 +86,11 @@ fun RootScreen(
             val reminderOnboarding: ReminderOnboardingViewModel = hiltViewModel()
             val onboardingDone by reminderOnboarding.onboardingDone.collectAsStateWithLifecycle()
             // One-time explainer for the switch to the device's own calendar
-            // visibility (#75); armed by the reconciler, shown over the app.
+            // visibility (#75), armed by the reconciler.
             val visibilityNotice: CalendarVisibilityNoticeViewModel = hiltViewModel()
             val noticePending by visibilityNotice.pending.collectAsStateWithLifecycle()
-            // Runs on entry however the permission was granted — including from
+            // Runs on entry however the permission was granted, including via
-            // Android's app-settings screen, which only comes back through the
+            // Android's app-settings screen (caught by the ON_RESUME above).
-            // ON_RESUME check above. Cheap once there is nothing left to do.
             LaunchedEffect(Unit) {
                 visibilityNotice.reconcile()
                 if (!grantedAtLaunch) reminderOnboarding.rearmAfterGrant()

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

@@ -92,20 +92,27 @@ fun parseAgendaRange(stored: String?, default: AgendaRange): AgendaRange = when
  * - [AgendaRange.ThisMonth] → month and year ("June 2026")
  * - everything else → "start – end" ("27 Jun – 3 Jul 2026"), with the start's
  *   year shown too only when it differs from the end's.
+ *
+ * [monthAsSpan] puts [AgendaRange.ThisMonth] on the "start – end" form as well.
+ * The agenda's own header browses the whole month, so the month name is right
+ * there; the range picker previews the window an option opens *today*, which for
+ * "This month" is only the rest of it.
  */
 fun agendaRangeWindowSummary(
     range: AgendaRange,
     start: LocalDate,
     end: LocalDate,
     locale: Locale,
+    monthAsSpan: Boolean = false,
 ): String {
     val javaStart = java.time.LocalDate.of(start.year, start.month.ordinal + 1, start.day)
     val javaEnd = java.time.LocalDate.of(end.year, end.month.ordinal + 1, end.day)
     val dayMonth = localizedDateFormatter(locale, "dMMM")
     val dayMonthYear = localizedDateFormatter(locale, "dMMMy")
-    return when (range) {
+    return when {
-        AgendaRange.Day -> dayMonthYear.format(javaStart)
+        range == AgendaRange.Day -> dayMonthYear.format(javaStart)
-        AgendaRange.ThisMonth -> localizedDateFormatter(locale, "LLLLy").format(javaStart)
+        range == AgendaRange.ThisMonth && !monthAsSpan ->
+            localizedDateFormatter(locale, "LLLLy").format(javaStart)
         else -> {
             val startFmt = if (start.year == end.year) dayMonth else dayMonthYear
             "${startFmt.format(javaStart)} – ${dayMonthYear.format(javaEnd)}"

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupScreen.kt

@@ -59,10 +59,8 @@ import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.floret.components.positionOf
 import java.time.LocalDate
 
-// SAF mime filter for the restore picker. `.ics` files reach us under several
+// SAF mime filter for the restore picker. Source apps hand `.ics` files out
-// mimes depending on the source app (our own export uses text/calendar; others
+// under several mimes, so accept the common set.
-// hand them out as octet-stream or text/plain), so accept the common set rather
-// than hide valid backups behind an over-tight filter.
 private val RESTORE_MIME_TYPES = arrayOf(
     "text/calendar",
     "application/octet-stream",
@@ -70,11 +68,8 @@ private val RESTORE_MIME_TYPES = arrayOf(
 )
 
 /**
- * Backup & restore (#69). Local calendars aren't synced anywhere, so a `.ics`
+ * Backup & restore (#69): `.ics` export and restore for local calendars, with
- * export is their only safety net — that made it a data-safety feature hiding in
+ * optional automatic backup. Shares [CalendarsViewModel] with the manager.
- * the calendar manager, where nobody went looking. It now has its own Settings
- * entry, sharing [CalendarsViewModel] with the manager (both are driven by the
- * same calendar list).
  *
  * A full-screen destination hoisted in `CalendarHost`; [onBack] pops it,
  * [onImport] hands a picked file to the app's normal .ics import flow.
@@ -92,29 +87,24 @@ fun BackupScreen(
     val context = LocalContext.current
     val snackbarHostState = remember { SnackbarHostState() }
 
-    // Export covers the user's own local calendars (managed special-dates
+    // Export covers local calendars only; managed special-dates mirrors are
-    // mirrors don't count — they are rebuilt from contacts). Restore can target
+    // rebuilt from contacts. Restore can target anything the import picker offers.
-    // any calendar the import picker would offer, so its availability is broader.
     val exportable = calendars.filter { it.isLocal && it.canModifyContents && !it.isManaged }
     val canImport = calendars.any { it.isEventTarget }
 
-    // SAF "create document" target for the backup file. The picked Uri is handed
+    // Exports everything eligible (null); the per-calendar selector owns its
-    // to the VM to stream the .ics into. This launcher exports everything
+    // own launcher.
-    // eligible (null); the per-calendar selector owns its own launcher.
     val createBackup = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.CreateDocument("text/calendar"),
     ) { uri -> uri?.let { viewModel.exportBackup(it, null) } }
     var showExportPicker by rememberSaveable { mutableStateOf(false) }
 
-    // SAF "open document" picker for restoring events from a .ics file. The
+    // Restore runs the picked file through the normal .ics import flow.
-    // picked Uri is handed up to the host, which runs it through the same import
-    // flow as an externally opened .ics (parse, dedup by UID, target picker).
     val openBackup = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.OpenDocument(),
     ) { uri -> uri?.let(onImport) }
 
-    // SAF folder picker for the automatic-backup destination; the VM persists the
+    // The VM persists the write grant so background runs can keep writing.
-    // write grant so background runs can keep writing to it.
     val pickFolder = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.OpenDocumentTree(),
     ) { uri -> uri?.let(viewModel::setAutoBackupFolder) }
@@ -148,15 +138,12 @@ fun BackupScreen(
         HintText(stringResource(R.string.calendars_backup_hint))
 
         if (exportable.isNotEmpty()) {
-            // One connected card: the one-time export on top, restore under it,
-            // then automatic backup (and its folder/interval rows when on).
             GroupedRow(
                 title = stringResource(R.string.calendars_backup_action),
                 position = Position.Top,
                 leading = { LeadingAvatar(Icons.Default.FileDownload) },
                 onClick = {
-                    // With more than one exportable calendar, let the user choose
+                    // A single exportable calendar skips the selector.
-                    // which to include; a single one exports straight away.
                     if (exportable.size == 1) {
                         runCatching { createBackup.launch("calendula-backup-${LocalDate.now()}.ics") }
                     } else {
@@ -198,9 +185,8 @@ fun BackupScreen(
                 HintText(backupStatusText(autoBackup.status))
             }
         } else if (canImport) {
-            // Nothing to back up (no writable local calendar), but events can
+            // Nothing to back up, but restore is still possible — don't hide
-            // still be restored into a writable calendar — offer restore on its
+            // it behind export eligibility.
-            // own so it isn't hidden behind export eligibility.
             SectionHeader(stringResource(R.string.calendars_restore_header))
             HintText(stringResource(R.string.calendars_restore_hint))
             GroupedRow(
@@ -239,11 +225,8 @@ private fun ExportCalendarPicker(
     onExport: (Uri, Set<Long>?) -> Unit,
     onDismiss: () -> Unit,
 ) {
-    // Seed once with everything selected and hold it across recomposition and
+    // Deliberately not keyed on [calendars]: that list is observer-driven, so
-    // rotation. NOT keyed on [calendars]: the list is observer-driven, so keying
+    // keying it would reset the user's de-selections on every provider re-emit.
-    // it would silently reset the user's de-selections whenever the provider
-    // re-emits (a background sync, a recolor). Ids that later vanish are harmless
-    // — the data layer intersects the chosen set with the eligible calendars.
     var selected by rememberSaveable(
         stateSaver = listSaver(
             save = { it.toList() },
@@ -348,7 +331,7 @@ private fun BackupIntervalDialog(
     onConfirm: (Long) -> Unit,
     onDismiss: () -> Unit,
 ) {
-    // minutes-per-unit for each entry; pick the largest unit the current value divides into.
+    // Pick the largest unit the current value divides into.
     val unitMinutes = remember { listOf(1L, 60L, MINUTES_PER_DAY, MINUTES_PER_WEEK) }
     val units = stringArrayResource(R.array.backup_interval_units).toList()
     val initialUnit = unitMinutes.indexOfLast { currentMinutes % it == 0L }.coerceAtLeast(0)

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarVisibilityNotice.kt

@@ -23,10 +23,8 @@ import javax.inject.Inject
 
 /**
  * The one-time notice that Calendula now follows the device's per-calendar
- * visibility (#75). Armed by `CalendarVisibilityReconciler` on the first launch
+ * visibility (#75), armed by `CalendarVisibilityReconciler`. The app does not
- * that finds a calendar switched off outside the app — those used to show their
+ * switch those calendars back on — that would un-hide them everywhere else too.
- * events here and no longer do, and the app deliberately does not switch them
- * back on, because that would un-hide them in every other calendar app too.
  */
 @HiltViewModel
 class CalendarVisibilityNoticeViewModel @Inject constructor(
@@ -35,12 +33,9 @@ class CalendarVisibilityNoticeViewModel @Inject constructor(
 ) : ViewModel() {
 
     /**
-     * Reconcile whenever the app comes up with the calendar permission held.
+     * Reconcile whenever the app comes up with the calendar permission held,
-     * The launch itself is covered by `CalendulaApp`, but a permission granted
+     * rather than off one grant route: a permission granted on Android's
-     * on Android's app-settings screen comes back through `RootScreen`'s
+     * app-settings screen never reaches the permission screen's callback.
-     * ON_RESUME and never touches the permission screen's callback — so the
-     * trigger hangs off "we are showing the app", not off one grant route.
-     * Settled runs cost two DataStore reads and stop there.
      */
     fun reconcile() {
         viewModelScope.launch { reconciler.run() }

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsScreen.kt

@@ -107,14 +107,11 @@ private const val NEW_CALENDAR_ID = Long.MIN_VALUE
 
 /**
  * Calendar manager (reached from Settings). Lists the app's own device-only
- * calendars with create / rename / recolor / delete (via a full-screen editor),
+ * calendars with create / rename / recolor / delete, and synced calendars
- * and lists synced calendars read-only with a per-account "manage in the source
+ * read-only with a per-account "manage in the source app" deep-link.
- * app" deep-link — the app never touches a synced calendar's server.
  *
  * Export/import lives in its own Settings entry ([BackupScreen], #69); this
- * screen only points at it, because the two are looked for separately: "which
+ * screen only points at it. [onBack] pops the destination.
- * calendars do I have" versus "keep a copy of them". A full-screen destination;
- * [onBack] pops it.
  */
 @Composable
 fun CalendarsScreen(
@@ -252,9 +249,7 @@ private fun CalendarsList(
             }
         }
 
-        // Backup lives in its own Settings entry now (#69) — this row is the
+        // Pointer to the Backup entry (#69), so it stays findable from here.
-        // pointer, so someone looking at their local calendars still finds the
-        // way to keep a copy of them.
         Spacer(Modifier.height(16.dp))
         GroupedRow(
             title = stringResource(R.string.settings_section_backup),
@@ -314,8 +309,8 @@ private fun CalendarsList(
                         onSetAccountVisible(switchable.map { it.id }, enabled)
                     },
                 ) {
-                    // Calendars you can act on first; the ones this device isn't
+                    // Actionable calendars first; non-syncing ones at the
-                    // syncing sit at the bottom, dimmed and switchless.
+                    // bottom, dimmed and switchless.
                     val ordered = cals.orderedForManager()
                     ordered.forEachIndexed { index, calendar ->
                         val disabled = !calendar.isVisibleInSystem || calendar.isNotSynced
@@ -392,11 +387,8 @@ private fun CalendarEditor(
                 },
                 actions = {
                     if (!isNew) {
-                        // Kept in place while the special-dates sync owns this
+                        // Disabled rather than hidden while the special-dates
-                        // calendar, rather than hidden: the button is where you
+                        // sync owns this calendar; the card below says why.
-                        // expect it, disabled, with the card below saying why —
-                        // and it comes back to life the moment the feature is
-                        // off, when the delete would actually stick.
                         IconButton(
                             onClick = { confirmDelete = true },
                             enabled = !deleteLocked,
@@ -523,9 +515,7 @@ private fun CalendarEditor(
 
 /**
  * The row's supporting line: the states that make this calendar behave unlike a
- * plain writable one (#76), then its own description. Text rather than badges —
+ * plain writable one (#76), then its own description.
- * a row can carry several of these at once next to a switch, which is exactly
- * what M3 supporting text composes and a row of static chips doesn't.
  */
 @Composable
 private fun calendarRowSummary(calendar: CalendarSource): String? {
@@ -543,12 +533,9 @@ private fun calendarRowSummary(calendar: CalendarSource): String? {
 }
 
 /**
- * The per-row on/off control, writing the system's `Calendars.VISIBLE`: checked
+ * The per-row on/off control, writing the system's device-local
- * = the calendar is shown, unchecked = it drops out of every surface (events,
+ * `Calendars.VISIBLE`. Unchecked drops the calendar out of every surface and
- * filters, pickers) and the provider stops scheduling its reminders. The flag is
+ * stops its reminders. Carries its own content description.
- * device-local — nothing is deleted and nothing is synced anywhere. Carries its
- * own content description so the toggle is self-describing to screen readers
- * even on a dimmed row.
  */
 @Composable
 private fun EnableSwitch(

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsViewModel.kt

@@ -73,18 +73,10 @@ class CalendarsViewModel @Inject constructor(
         )
 
     /**
-     * Managed special-dates calendars whose deletion would not stick. While the
+     * Managed special-dates calendars whose deletion would not stick: while the
-     * feature is on, the sync owns every mirror: it recreates a missing one for
+     * feature is on, `SpecialDatesSyncEngine.reconcileCalendars` undoes it on
-     * an enabled type on the next pass and deletes the leftover of a disabled
+     * the next pass. Read off each calendar's durable [CalendarSource.isManaged]
-     * one (`SpecialDatesSyncEngine.reconcileCalendars`), so either way the
+     * marker rather than the stored ids, which lag a sync pass behind.
-     * delete would appear to work and then undo itself. Turning special dates
-     * off empties this set, and deleting a leftover mirror is a real delete from
-     * then on.
-     *
-     * Read off each calendar's own durable marker ([CalendarSource.isManaged],
-     * the `CAL_SYNC2` one the editor lock already trusts) rather than the stored
-     * ids, which are only rewritten on the next sync pass — a preferences loss
-     * would otherwise unlock a live mirror until then.
      */
     val deleteLockedCalendarIds: StateFlow<Set<Long>> = combine(
         calendars,
@@ -147,27 +139,18 @@ class CalendarsViewModel @Inject constructor(
     }
 
     /**
-     * Switch a calendar on or off. This is the app's one visibility model: it
+     * Switch a calendar on or off — the app's one visibility model, writing the
-     * writes the system's `Calendars.VISIBLE`, so the calendar disappears from
+     * system's `Calendars.VISIBLE`. A reminder that came due while the calendar
-     * every surface *and* the provider stops (or resumes) scheduling its
+     * was off stays gone when it is switched back on: the watermark has already
-     * reminders. Nothing is patched by hand — the provider notifies and the
+     * moved past it (#75).
-     * observer re-queries.
-     *
-     * A reminder that came due while the calendar was off stays gone when it is
-     * switched back on. Delivery plans from `Instances` and `Reminders` on every
-     * scan (#75), but the watermark has already moved past that moment, so no
-     * scan returns it again — and on a read-only install the switch never
-     * reaches the provider at all, so nothing even triggers one. Deliberate: the
-     * reminder was silenced on purpose, and the event itself is back in view.
      */
     fun setCalendarVisible(id: Long, visible: Boolean) = write {
         repository.setCalendarsVisible(listOf(id), visible)
     }
 
     /**
-     * Switch every calendar of one account on or off — the "toggle all"
+     * Switch every calendar of one account on or off. Each row is written on its
-     * affordance on an account header. Each row is written on its own, in one
+     * own, in one coroutine so the writes can't race.
-     * coroutine so the writes can't race each other.
      */
     fun setAccountVisible(ids: Collection<Long>, visible: Boolean) = write {
         repository.setCalendarsVisible(ids, visible)

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

@@ -9,13 +9,8 @@ import de.jeanlucmakiola.calendula.domain.CalendarSource
 
 /**
  * One account's calendars, as every surface that lists calendars by account
- * shows them.
+ * shows them. An account is identified by name **and** type (#77): a Google and
- *
+ * a DAVx5 account can share an address and still be two separate accounts.
- * An account is identified by name **and** type (#77). A Google account and a
- * DAVx5 account can carry the same address and still be two separate accounts,
- * from separate apps: merging them mixed their calendars into one group whose
- * header — source logo, "manage in app", toggle-all, collapsed state — was
- * derived from whichever calendar happened to sort first.
  */
 data class CalendarAccountGroup(
     /** Stable identity: what makes two calendars belong to the same account. */
@@ -69,9 +64,8 @@ fun accountGroupTitle(group: CalendarAccountGroup): String =
     }
 
 /**
- * The human name of the app backing [accountType] — the same app whose icon
+ * The human name of the app backing [accountType], falling back to the raw
- * [SourceLogo] draws. Falls back to the raw account type, which is at least
+ * account type when no installed app resolves for it.
- * unique, when no installed app resolves for it.
  */
 @Composable
 fun sourceAppName(accountType: String): String {

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

@@ -45,11 +45,9 @@ import de.jeanlucmakiola.floret.components.SelectedCheck
  * each and a check on the selected one. Emits into the caller's [ColumnScope]
  * (a scrolling column), so the caller owns the surrounding chrome.
  *
- * The list holds event *targets* only, so a calendar that is switched off,
+ * The list holds event *targets* only, so a switched-off, read-only or managed
- * read-only or managed is silently absent — which reads as a missing calendar
+ * calendar is absent (#76). [onManageCalendars], when given, adds the footer row
- * rather than an excluded one (#76). [onManageCalendars], when given, adds the
+ * naming the possible reasons and opening the calendar manager.
- * footer row that names the possible reasons and opens the calendar manager,
- * where each row then says which one applies.
  */
 @Composable
 fun ColumnScope.CalendarPickerGroups(

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

@@ -59,10 +59,9 @@ import kotlin.time.Clock
  * lead time to the set. Changes apply live via [onSelect]; the user leaves via
  * back.
  *
- * [leadTimeSummary] adds a second line to each lead-time row. It exists for the
+ * [leadTimeSummary] adds a second line to each lead-time row, for the all-day
- * all-day pickers, where the lead time alone doesn't say when anything happens:
+ * pickers: the hour comes from the separate "show all-day reminders at" setting,
- * the hour comes from the separate "show all-day reminders at" setting, so
+ * so the lead time alone doesn't say when anything happens.
- * "1 day before" is only half the answer until the row spells out the time.
  */
 @Composable
 fun ReminderDefaultPicker(
@@ -233,10 +232,8 @@ internal fun PickerDescription(text: String) {
  * Mirrors [ReminderDefaultPicker]'s custom-expand pattern.
  *
  * Every option carries the dates it resolves to today as its summary, computed
- * through the same [dayCount] the agenda windows by (hence [weekStart], which
+ * through the same [dayCount] the agenda windows by (hence [weekStart]) — only
- * "This week" depends on). Without it the two groups are near-indistinguishable
+ * the concrete span tells "This week" and "Next 7 days" apart.
- * — "This week" and "Next 7 days" name different windows in the same words, and
- * only the concrete span tells them apart.
  */
 @Composable
 fun AgendaRangePicker(
@@ -260,11 +257,11 @@ fun AgendaRangePicker(
     val locale = currentLocale()
     val zone = remember { TimeZone.currentSystemDefault() }
     val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
-    // The window each option would open right now — the agenda's own end-day
+    // The agenda's own end-day arithmetic (anchor + dayCount - 1), so the dates
-    // arithmetic (anchor + dayCount - 1), so the dates match what it will show.
+    // match what it will show.
     val windowSummary: (AgendaRange) -> String = { range ->
         val end = today.plus(range.dayCount(today, weekStart) - 1, DateTimeUnit.DAY)
-        agendaRangeWindowSummary(range, today, end, locale)
+        agendaRangeWindowSummary(range, today, end, locale, monthAsSpan = true)
     }
 
     val rangeRow: @Composable (AgendaRange, Position) -> Unit = { option, position ->
@@ -306,8 +303,8 @@ fun AgendaRangePicker(
             } else {
                 stringResource(R.string.agenda_range_custom)
             },
-            // Only a chosen custom window has dates to show; an unset one has no
+            // An unset custom window has no day count yet, so the row stays
-            // day count yet, so the row stays single-line until it does.
+            // single-line until it does.
             summary = if (customSelected) windowSummary(selected) else null,
             position = if (customExpanded) Position.Top else positionOf(rolling.size, rollingRowCount),
             selected = customSelected,

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

@@ -105,29 +105,19 @@ fun recurrenceText(rrule: String, locale: Locale): AnnotatedString {
 
 /**
  * The rule's first few dates as one line — "Next: 30 Jul, 6 Aug, 13 Aug" — for
- * the recurrence picker.
+ * the recurrence picker, where [recurrenceText]'s phrase says what the rule is
- *
+ * and this says what it does. Expands via [upcomingOccurrences] and inherits its
- * The phrase [recurrenceText] renders says what the rule *is*; this says what
+ * limits. A rule that yields nothing says so rather than showing an empty list.
- * it *does*, which is the part a monthly rule on the 31st or an every-other-week
- * rule with weekday picks gets wrong in people's heads. It expands the rule
- * with [upcomingOccurrences], so it inherits that function's RFC reading — and
- * its limits: only the shapes the picker itself can build.
- *
- * A rule that yields nothing at all (an end date before the start) says so
- * rather than showing an empty list, since that is a mistake worth catching
- * before saving.
  */
 @Composable
 fun nextOccurrencesText(
     rule: SimpleRecurrence,
-    // Spelled out: in this file, the bare LocalDate is java.time's.
     start: kotlinx.datetime.LocalDate,
     locale: Locale,
 ): String {
     val dates = rule.upcomingOccurrences(start, limit = NEXT_OCCURRENCE_COUNT)
     if (dates.isEmpty()) return stringResource(R.string.event_edit_recurrence_next_none)
-    // Years only once they carry information — a yearly rule is otherwise the
+    // Years only once they carry information (see [spansMultipleYears]).
-    // same date repeated, and a monthly one crossing New Year hides that it did.
     val pattern = if (occurrencesSpanYears(dates, start)) "dMMMy" else "dMMM"
     val formatter = localizedDateFormatter(locale, pattern)
     val formatted = dates.map { formatter.format(it.toJavaLocalDate()) }

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

@@ -515,8 +515,8 @@ private fun EventEditContent(
     // they're locked here; everything else (reminders, location, notes) is the
     // user's to edit.
     val locked = state.isManaged
-    // Read in the form's own window, not the picker's: the field holding focus
+    // Read in the form's own window, not the picker's: the focused field lives
-    // lives here, so this is the controller that can put its keyboard away.
+    // here, so this is the controller that can put its keyboard away.
     val focusManager = LocalFocusManager.current
     val keyboardController = LocalSoftwareKeyboardController.current
     var picker by remember { mutableStateOf<PickerTarget?>(null) }
@@ -1124,10 +1124,8 @@ private fun EventEditContent(
         null -> Unit
     }
 
-    // A full-screen picker over the form is a change of place, so the form's
+    // A full-screen picker is a change of place, so the keyboard shouldn't
-    // keyboard has no business following it there — least of all onto the
+    // follow it. The field keeps its text; only focus and the IME go.
-    // calendar manager, which the picker can hand off to. The form's own field
-    // keeps its text; only focus and the IME go.
     LaunchedEffect(showCalendarPicker) {
         if (showCalendarPicker) {
             focusManager.clearFocus(force = true)
@@ -1143,11 +1141,9 @@ private fun EventEditContent(
                 viewModel.setCalendar(it)
                 showCalendarPicker = false
             },
-            // Close the picker on the way out. It is a Compose Dialog — its own
+            // Close the picker first: it is a Compose Dialog in its own window,
-            // window, always above the activity's content — so the manager would
+            // always above the activity's content, so the manager would
-            // otherwise open behind it and the tap would look dead. The form
+            // otherwise open behind it and the tap would look dead.
-            // stays standing underneath, its calendar row one tap from a picker
-            // that re-queries on open.
             onManageCalendars = onManageCalendars?.let { openManager ->
                 {
                     showCalendarPicker = false
@@ -1344,10 +1340,7 @@ private enum class RecurrenceEndMode { Never, Until, Count }
  *
  * Both steps show the rule as *dates* as well as words: every preset row
  * carries the next few occurrences it would produce from [startDate], and the
- * custom step repeats that under its live read-out. It is where a rule most
+ * custom step repeats that under its live read-out.
- * easily means something other than it sounds like — "monthly" on the 31st
- * skips February, an every-other-week rule lands a fortnight from the start's
- * own week — and only the dates say so.
  */
 @Composable
 private fun RecurrencePickerDialog(
@@ -1409,9 +1402,8 @@ private fun RecurrencePickerDialog(
         RecurrenceEndMode.Until -> untilDate?.let { RecurrenceEnd.Until(it) }
         RecurrenceEndMode.Count -> count?.let { RecurrenceEnd.Count(it) }
     }
-    // Kept as the rule object, not just its RRULE text: the read-out renders the
+    // Kept as the rule object, not just its RRULE text: the read-out and the
-    // string, the date list expands the rule, and both must describe the one
+    // date list must describe the one thing OK would save.
-    // thing OK would save.
     val customRule: SimpleRecurrence? = if (interval != null && customEnd != null) {
         SimpleRecurrence(
             freq = freq,
@@ -1505,9 +1497,8 @@ private fun RecurrencePickerDialog(
                         .padding(horizontal = 16.dp),
                 )
 
-                // The same rule as dates. Rendered even while the form is
+                // Rendered even while incomplete (as an empty line), so the
-                // incomplete (as an empty line) so the controls below don't
+                // controls below don't shift as it comes and goes.
-                // shift as it comes and goes.
                 Text(
                     text = customRule?.let { nextOccurrencesText(it, startDate, locale) }.orEmpty(),
                     style = MaterialTheme.typography.bodyMedium,
@@ -2034,10 +2025,8 @@ private fun readContactAddress(context: Context, uri: Uri): String? =
  * Visibility selector: one card per level, each with its own icon; the
  * current level is highlighted. Tap picks and closes.
  *
- * Every level carries a line saying who this affects, because the four words
+ * Every level carries a line saying who this affects — the labels alone don't
- * alone don't: visibility is about what *other people on a shared calendar*
+ * say that visibility is about what others on a shared calendar see.
- * see, which is exactly the part the label leaves out — and "Confidential" has
- * no meaning at all until you know the server decides what it does with it.
  */
 @Composable
 private fun VisibilityPickerDialog(

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

@@ -233,11 +233,9 @@ class EventEditViewModel @Inject constructor(
         // off the calendar's durable marker, not a stored id, so it holds after a
         // backup restore too.
         val isManaged = local.editTarget != null && resolvedCalendar?.isManaged == true
-        // The picker offers writable calendars only; the event's own calendar is
+        // The event's own calendar is added back whenever it isn't a target
-        // added back whenever it isn't among them — a managed special-dates one,
+        // (managed, or switched off), so the row keeps naming it and saving can
-        // or one switched off on this device — so the row keeps naming it instead
+        // leave the event where it is. A read-only one is still no target.
-        // of reading as the "no calendar" error, and saving can leave the event
-        // where it is. A calendar the app may not write to is still no target.
         val ownCalendar = resolvedCalendar?.takeIf { own ->
             own.canModifyContents && external.writable.none { it.id == own.id }
         }

app/src/main/java/de/jeanlucmakiola/calendula/ui/filter/FilterViewModel.kt

@@ -32,9 +32,8 @@ class FilterViewModel @Inject constructor(
             repository.calendars(),
             prefs.hiddenCalendarIds,
         ) { calendars, hidden ->
-            // Calendars switched off in Settings → Calendars are off device-wide
+            // Calendars switched off device-wide don't belong in the drawer's
-            // and don't belong in the drawer's hide/show list (you can't hide
+            // hide/show list; they live only in Settings → Calendars.
-            // what is already off). They live only in Settings → Calendars.
             val enabled = calendars.filter { it.isVisibleInSystem }
             if (enabled.isEmpty()) {
                 FilterUiState.Failure(FailureReason.NoCalendarsConfigured)

app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportScreen.kt

@@ -175,10 +175,8 @@ private fun ManyContent(
     onSelect: (Long) -> Unit,
     onManageCalendars: (() -> Unit)? = null,
 ) {
-    // No calendar to import into — tell the user honestly, and carry the same
+    // No calendar to import into; carries the same way out the picker's footer
-    // way out the picker's footer offers below. This is the state that footer
+    // offers below (#76).
-    // exists for: every writable calendar being switched off, read-only or
-    // contact-filled is exactly what empties this list (#76).
     if (state.calendars.isEmpty()) {
         CenteredMessage(
             message = stringResource(R.string.import_no_calendar),

app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportViewModel.kt

@@ -86,9 +86,7 @@ class ImportViewModel @Inject constructor(
                     warnings = parsed.warnings,
                 )
                 else -> {
-                    // The same targets the event form offers ([isEventTarget]):
+                    // The same targets the event form offers ([isEventTarget]).
-                    // an import is a bulk create, so a calendar that can't hold
-                    // one event can't hold thirty.
                     ImportUiState.Many(
                         events = parsed.events,
                         warnings = parsed.warnings,

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

@@ -365,10 +365,8 @@ fun MonthScreen(
                     todayText = stringResource(R.string.month_today_action),
                     onToday = jumpToToday,
                     onCreate = {
-                        // Split has a selected day and lists it below the grid, so
+                        // Split has a selected day; the other styles anchor on
-                        // that is the day the new event belongs to. The other
+                        // today when its month is shown, else the 1st.
-                        // styles have no selection: anchor on today when its month
-                        // is shown, else the 1st.
                         onCreateEvent(
                             when {
                                 viewStyle == MonthViewStyle.Split -> selectedDate
@@ -2075,10 +2073,9 @@ private fun MonthBar(
 }
 
 /**
- * Overflow row: a dot per hidden colour (up to three) plus "+N" for the rest.
+ * Overflow row: a dot per hidden colour (up to three) plus "+N" for the rest. A
- *
+ * dot dims once every event sharing its colour has ended, the "+N" once the
- * A dot stands for every hidden event sharing its colour, so it dims only once
+ * whole overflow has (#79).
- * all of them have ended; the "+N" dims once the whole overflow has (#79).
  */
 @Composable
 private fun OverflowDots(

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

@@ -68,12 +68,9 @@ fun MonthWeek.laneEvents(col: Int, day: LocalDate, laneCap: Int): List<EventInst
 }
 
 /**
- * The events on [day] that [laneEvents] had no lane left for — the exact
+ * The events on [day] that [laneEvents] had no lane left for — its exact
- * complement of what it seats, in the same bars-then-pills order. Together the
+ * complement, in the same bars-then-pills order. Returned as events rather than
- * two partition the day, so their sizes add up to [countByDay].
+ * a count because dimming is a per-event question (#79).
- *
- * The "+N" marker needs the events themselves, not just how many there are:
- * dimming a completed event is a per-event question (#79).
  */
 fun MonthWeek.overflowEvents(col: Int, day: LocalDate, laneCap: Int): List<EventInstance> {
     val seatedLanes = spans.count { it.lane < laneCap && col in it.startCol..it.endCol }

app/src/main/java/de/jeanlucmakiola/calendula/ui/permission/PermissionViewModel.kt

@@ -13,8 +13,8 @@ class PermissionViewModel @Inject constructor() : ViewModel() {
     private val _state = MutableStateFlow<PermissionUiState>(PermissionUiState.Rationale)
     val state: StateFlow<PermissionUiState> = _state.asStateFlow()
 
-    // The visibility reconcile a grant owes (#75) hangs off RootScreen showing
+    // The visibility reconcile a grant owes (#75) hangs off RootScreen, which
-    // the app instead: it has to cover the grants made outside it too.
+    // also catches grants made outside the app.
     fun onGranted() {
         _state.value = PermissionUiState.Granted
     }

app/src/main/java/de/jeanlucmakiola/calendula/ui/permission/ReminderOnboardingViewModel.kt

@@ -37,8 +37,7 @@ class ReminderOnboardingViewModel @Inject constructor(
             prefs.setRemindersEnabled(remindersEnabled)
             prefs.setReminderOnboardingDone()
             // Nothing else re-arms the scan: turning reminders off cancels the
-            // alarm, so a later "on" would sit without one until a provider
+            // alarm (#75).
-            // change or the daily worker happened to run (#75).
             scanner.scan()
         }
     }

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

@@ -223,10 +223,9 @@ private fun searchSummary(event: EventInstance): String {
     val start = remember(event.start, zone) {
         JavaInstant.ofEpochMilli(event.start.toEpochMilliseconds()).atZone(zone)
     }
-    // The date comes from the shared span rule, not from [start]: an all-day
+    // From the shared span rule, not [start]: an all-day event sits at UTC
-    // event sits at UTC midnight, so reading its date in the device zone names
+    // midnight and would name the day before west of UTC (#82). The clock time
-    // the day before west of UTC (#82). The clock time below stays in the device
+    // below stays device-zone — it is only rendered for timed events.
-    // zone — it is only ever rendered for timed events.
     val dateText = remember(event.start, event.end, event.isAllDay, locale) {
         DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
             .format(event.spanFirstDay(TimeZone.currentSystemDefault()).toJavaLocalDate())

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

@@ -84,7 +84,6 @@ internal fun AppearanceScreen(
 
     val fonts by viewModel.fontState.collectAsStateWithLifecycle()
     val launcherName by viewModel.launcherName.collectAsStateWithLifecycle()
-    // A picked file that didn't parse as a font: tell the user and keep the old choice.
     val context = LocalContext.current
     val importFailedMessage = stringResource(R.string.settings_font_import_failed)
     LaunchedEffect(Unit) {
@@ -107,8 +106,6 @@ internal fun AppearanceScreen(
         )
         GroupedRow(
             title = stringResource(R.string.settings_dynamic_color),
-            // Says what it does when on; below Android 12 that is replaced by
-            // the reason the switch is dead.
             summary = if (state.dynamicColorAvailable) {
                 stringResource(R.string.settings_dynamic_color_summary)
             } else {
@@ -143,9 +140,7 @@ internal fun AppearanceScreen(
 
         Spacer(Modifier.height(16.dp))
 
-        // Fonts — the two Material typeface roles, each independently choosable
+        // Fonts — the two Material typeface roles (#19).
-        // (issue #19). Headings = brand (display/headline); body = plain
-        // (title/body/label). Both default to the system typeface.
         GroupedRow(
             title = stringResource(R.string.settings_font_headings),
             summary = fontLabel(fonts.brand),
@@ -161,10 +156,8 @@ internal fun AppearanceScreen(
 
         Spacer(Modifier.height(16.dp))
 
-        // App name — chooses the launcher label between "Calendula" and "Calendar"
+        // App name — the launcher label (#44); its own group, being a
-        // (issue #44). Own group: it's a launcher/system concern, not app styling.
+        // launcher concern rather than app styling.
-        // A sub-page chooser (not a switch), matching the app's other "choose one"
-        // settings and leaving room for more names later.
         GroupedRow(
             title = stringResource(R.string.settings_app_name),
             summary = launcherNameLabel(launcherName),
@@ -179,10 +172,8 @@ internal fun AppearanceScreen(
             onDismiss = { showAppName = false },
             predictiveBack = true,
         ) {
-            // Show both names as launcher-mark previews so the user sees what
+            // Both names shown as launcher-mark previews; tapping applies at
-            // they'd switch to, not just the current state. Tapping applies
+            // once and the picker stays open so the change is visible.
-            // immediately and highlights — the picker stays open so the change is
-            // visible; back exits.
             Text(
                 text = stringResource(R.string.settings_app_name_summary),
                 style = MaterialTheme.typography.bodyMedium,
@@ -211,10 +202,8 @@ internal fun AppearanceScreen(
         }
     }
     if (showTheme) {
-        // No preview here on purpose: picking a theme repaints the app itself,
+        // No thumbnails: picking a theme repaints the app itself. Only which
-        // which is a better demonstration than any thumbnail. What the list
+        // way "Follow the system" currently falls needs spelling out.
-        // *can't* show is which way "Follow the system" currently falls, so that
-        // one option says so.
         val systemDark = isSystemInDarkTheme()
         OptionPicker(
             title = stringResource(R.string.settings_theme),
@@ -307,19 +296,8 @@ private val FONT_PICKER_MIME_TYPES = arrayOf(
 
 /**
  * Full-screen font chooser for one [FontRole]: the system default, each bundled
- * font (previewed in its own face), and "Choose file…" which opens the system
+ * font, and "Choose file…" for a .ttf/.otf. A specimen of the current choice
- * picker to load a .ttf/.otf. Selecting a system/bundled option applies at once;
+ * sits above the rows, so the picker stays open on selection and re-renders it.
- * a file is validated and imported by the caller, switching to the custom font
- * on success.
- *
- * Above the rows sits a specimen of the *current* choice, set in the type role
- * this picker governs — headline for [FontRole.BRAND], body for
- * [FontRole.PLAIN]. The per-row "Ag" says what a face looks like; only a full
- * line at the real size says whether it works for the role, and it is the one
- * thing that makes the two font settings distinguishable from each other.
- *
- * Being a preview picker, it stays open on selection (see `FullScreenPicker`):
- * the specimen re-renders instead, which is the whole point of the screen.
  */
 @Composable
 private fun FontPicker(
@@ -335,22 +313,17 @@ private fun FontPicker(
     val launcher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.OpenDocument(),
     ) { uri ->
-        // Stay open on a successful import too: the specimen switches to the
-        // imported face, which is the only look the user gets before committing.
         if (uri != null) onImport(uri)
     }
 
     // System default + the bundled fonts + the "Choose file…" row.
     val rowCount = BundledFont.entries.size + 2
     val isCustom = selected == FONT_CUSTOM_TOKEN
-    // Resolving the custom face stats the disk and builds a fresh FontFamily, so
+    // Resolving the custom face stats the disk, so memoise it; [stamp] is bumped
-    // memoise it; re-keyed on [stamp] (bumped on re-import) so a replaced file
+    // on re-import to refresh a replaced file.
-    // refreshes the preview while plain recompositions reuse the cached family.
     val customPreview = remember(role, isCustom, stamp) {
         if (isCustom) resolveFontFamily(FONT_CUSTOM_TOKEN, role, context) else null
     }
-    // The face the specimen is set in: the same resolution the theme performs,
-    // so what is shown here is what the app will use.
     val selectedFamily = remember(role, selected, stamp) {
         resolveFontFamily(selected, role, context)
     }
@@ -362,8 +335,6 @@ private fun FontPicker(
             preview = FontFamily.Default,
             selected = selected == FONT_SYSTEM_TOKEN,
             position = positionOf(0, rowCount),
-            // Applies straight away and stays open — the specimen above is the
-            // answer to "what does this one look like".
             onClick = { onSelect(FONT_SYSTEM_TOKEN) },
         )
         BundledFont.entries.forEachIndexed { index, font ->
@@ -381,7 +352,6 @@ private fun FontPicker(
             } else {
                 stringResource(R.string.settings_font_choose_file)
             },
-            // A loaded font previews in its own face; otherwise show an upload cue.
             preview = customPreview,
             leadingIcon = if (isCustom) null else Icons.Default.UploadFile,
             selected = isCustom,
@@ -392,11 +362,8 @@ private fun FontPicker(
 }
 
 /**
- * A specimen of [family] set in the type role [role] governs: a headline for
+ * A specimen of [family] in the type role [role] governs, using the app's own
- * the brand role, a paragraph for the plain one — the same styles the app draws
+ * styles with only the family swapped. A null [family] is the system typeface.
- * with, only the family swapped, so nothing here can flatter a face the app
- * won't reproduce. A null [family] is the system typeface, i.e. the Material
- * default the styles already carry.
  */
 @Composable
 private fun FontSpecimen(role: FontRole, family: FontFamily?) {
@@ -412,8 +379,8 @@ private fun FontSpecimen(role: FontRole, family: FontFamily?) {
         ),
         style = style.copy(fontFamily = family ?: style.fontFamily),
         color = MaterialTheme.colorScheme.onSurface,
-        // Two lines up front so switching between a wide and a narrow face
+        // Fixed height, so switching between a wide and a narrow face doesn't
-        // doesn't shuffle the option list up and down under it.
+        // shuffle the option list under it.
         minLines = 2,
         modifier = Modifier
             .fillMaxWidth()
@@ -422,9 +389,8 @@ private fun FontSpecimen(role: FontRole, family: FontFamily?) {
 }
 
 /**
- * One row in the [FontPicker]: the font's name, a leading "Ag" sample rendered in
+ * One row in the [FontPicker]: the font's name, an "Ag" sample in its own
- * the option's own [preview] face (or an [leadingIcon] cue when there's nothing
+ * [preview] face (or an [leadingIcon] cue), and a check when selected.
- * to preview), and a check when it's the current selection.
  */
 @Composable
 private fun FontOptionRow(
@@ -460,11 +426,8 @@ private fun FontOptionRow(
 }
 
 /**
- * One selectable launcher-name preview in the App name picker (issue #44): the
+ * One selectable launcher-name preview in the App name picker (#44): the app's
- * app's launcher mark over the name, framed as a card. The active one carries a
+ * launcher mark over the name, framed as a card.
- * primary border, a tinted container and a check; tapping selects it. The mark
- * is the same for both — only the label changes — so the card previews exactly
- * what the home screen will read.
  */
 @Composable
 private fun AppNameOptionCard(
@@ -494,8 +457,8 @@ private fun AppNameOptionCard(
         horizontalAlignment = Alignment.CenterHorizontally,
         verticalArrangement = Arrangement.spacedBy(12.dp),
     ) {
-        // The adaptive launcher mark, reconstructed as a squircle (as in the
+        // The adaptive mark rebuilt as a squircle, as in the onboarding
-        // onboarding BrandHero) so it renders identically everywhere.
+        // BrandHero, so it renders identically everywhere.
         Box(
             modifier = Modifier
                 .size(64.dp)
@@ -515,7 +478,6 @@ private fun AppNameOptionCard(
             textAlign = TextAlign.Center,
             maxLines = 1,
         )
-        // Selection indicator: a filled check when active, an empty ring otherwise.
         Box(
             modifier = Modifier
                 .size(24.dp)

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

@@ -40,8 +40,7 @@ internal fun EventFormScreen(
             GroupedRow(
                 title = stringResource(eventFormFieldLabel(field)),
                 position = positionOf(index, fields.size),
-                // Same icon the field carries in the new-event form, so a toggle
+                // The same icon the field carries in the new-event form.
-                // is easy to match to the field it controls.
                 leading = {
                     Icon(
                         imageVector = eventFormFieldIcon(field),
@@ -59,9 +58,7 @@ internal fun EventFormScreen(
             )
         }
 
-        // Auto-focus the title on a new event (issue #10) — on by default, since
+        // Auto-focus the title on a new event (#10), on by default.
-        // most events get a title; raising the keyboard saves a tap. Off lets you
-        // set the time/calendar first without the keyboard in the way.
         Spacer(Modifier.height(24.dp))
         GroupedRow(
             title = stringResource(R.string.settings_autofocus_title),
@@ -84,8 +81,7 @@ internal fun EventFormScreen(
         )
 
         // Per-event colour on calendars that publish no colour set (some
-        // CalDAV) — off by default, with the honest caveat that the colour may
+        // CalDAV); off by default, since it may not survive their next sync.
-        // not survive their next sync. Local and palette calendars ignore it.
         Spacer(Modifier.height(24.dp))
         GroupedRow(
             title = stringResource(R.string.settings_color_unsupported),

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

@@ -124,11 +124,8 @@ internal fun NotificationsScreen(
             onClick = { showAllDayReminderTime = true },
         )
 
-        // Delivery reliability + snooze: both are global reminder-delivery
+        // Reliability is a soft, optional battery-optimisation exemption via
-        // settings, so they sit with the defaults above rather than below the
+        // a system-settings deep-link, shown as live status.
-        // long per-calendar list. Reliability is a soft, optional battery-
-        // optimisation exemption (system-settings deep-link, no special
-        // permission); shown as live status, reversible at any time.
         Spacer(Modifier.height(24.dp))
         val batteryExempt = rememberBatteryOptimizationExempt()
         GroupedRow(
@@ -147,7 +144,6 @@ internal fun NotificationsScreen(
             onClick = { openBatteryOptimizationSettings(context) },
         )
 
-        // Snooze: how long the notification's "Snooze" action defers a reminder.
         GroupedRow(
             title = stringResource(R.string.settings_snooze_duration),
             summary = snoozeDurationLabel(state.snoozeMinutes),
@@ -155,10 +151,9 @@ internal fun NotificationsScreen(
             onClick = { showSnooze = true },
         )
 
-        // Per-calendar overrides: the whole section folds behind one header to
+        // Per-calendar overrides, folded behind one header. Each writable
-        // keep the screen tidy. Expanded, each writable calendar gets its own
+        // calendar may keep, drop or replace the global default, separately for
-        // expandable card that may keep, drop, or replace the global default —
+        // timed and all-day events.
-        // separately for timed and all-day events.
         if (state.writableCalendars.isNotEmpty()) {
             Spacer(Modifier.height(24.dp))
             GroupedRow(
@@ -182,8 +177,8 @@ internal fun NotificationsScreen(
                 Column {
                     state.writableCalendars.forEach { calendar ->
                         Spacer(Modifier.height(16.dp))
-                        // A contact special-dates calendar owns its reminders in
+                        // Special-dates calendars own their reminders in their
-                        // its own section — link there instead of an override.
+                        // own section — link there instead.
                         if (calendar.id in state.managedCalendarIds) {
                             GroupedRow(
                                 title = calendar.displayName,
@@ -202,8 +197,6 @@ internal fun NotificationsScreen(
                             return@forEach
                         }
                         val expanded = calendar.id in expandedCalendars
-                        // Calendar card; tapping expands it into a grouped list
-                        // of three (the card + the timed and all-day rows).
                         GroupedRow(
                             title = calendar.displayName,
                             position = if (expanded) Position.Top else Position.Alone,
@@ -366,8 +359,7 @@ private fun snoozeDurationLabel(minutes: Int): String =
 
 /**
  * Whether Calendula is exempt from battery optimisation, re-read on every
- * `ON_RESUME` so the row reflects a change the user just made in system
+ * `ON_RESUME` so a change made in system settings shows up at once.
- * settings without needing to leave and re-enter the screen.
  */
 @Composable
 private fun rememberBatteryOptimizationExempt(): Boolean {
@@ -392,10 +384,8 @@ private fun isIgnoringBatteryOptimizations(context: Context): Boolean {
 }
 
 /**
- * Take the user straight to Calendula's exemption: the direct
+ * Open the direct `REQUEST_IGNORE_BATTERY_OPTIMIZATIONS` dialog, falling back to
- * `REQUEST_IGNORE_BATTERY_OPTIMIZATIONS` dialog ("Allow Calendula to ignore
+ * the optimisation list if the OS refuses it.
- * battery optimisation?") rather than the full app list they'd have to scroll.
- * Falls back to the optimisation list if the OS refuses the direct intent.
  */
 private fun openBatteryOptimizationSettings(context: Context) {
     val direct = Intent(

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

@@ -4,6 +4,7 @@ import androidx.compose.animation.Crossfade
 import androidx.compose.animation.core.snap
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxWidth
@@ -17,7 +18,6 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
-import androidx.compose.ui.input.pointer.PointerEventPass
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.clearAndSetSemantics
@@ -41,19 +41,9 @@ import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Clock
 
 /**
- * The "past events" chooser for the Agenda (#69 follow-up).
+ * The "past events" chooser for the Agenda (#69 follow-up). A stand-in agenda
- *
+ * day sits above the options and re-renders as you pick one, using the Agenda's
- * "Show / dim / hide" is the case where the word cannot carry the choice —
+ * own rows and filtering. A preview picker, so it stays open on selection.
- * *how far* does dimmed fade, and what is left behind when finished events are
- * hidden? So a stand-in agenda day sits above the options and re-renders as you
- * pick one, using the very rows the Agenda draws: dimming is
- * [AgendaEventRow]'s own `dimmed` flag, and hiding drops the row exactly as
- * [de.jeanlucmakiola.calendula.ui.agenda.AgendaScreen] filters it — so the
- * preview cannot claim an effect the screen doesn't have.
- *
- * Like the Month style and App name pickers, selecting applies immediately and
- * leaves the picker open: closing would hide the thing the screen is for. Back
- * exits.
  */
 @Composable
 internal fun PastEventsPicker(
@@ -102,7 +92,6 @@ internal fun PastEventsPicker(
                 } else {
                     null
                 },
-                // Applies straight away; the preview above is the confirmation.
                 onClick = { onSelect(mode) },
             )
         }
@@ -111,9 +100,8 @@ internal fun PastEventsPicker(
 
 /**
  * A stand-in agenda day in a given [mode]: three events on today, the first two
- * already finished. The times are fixed rather than derived from the clock, so
+ * finished. Times are fixed rather than clock-derived, so it reads the same at
- * the preview reads the same at any hour — what varies is only what [mode] does
+ * any hour.
- * to the two finished rows.
  */
 @Composable
 private fun PastEventsPreview(mode: PastEventDisplay, modifier: Modifier = Modifier) {
@@ -125,24 +113,17 @@ private fun PastEventsPreview(mode: PastEventDisplay, modifier: Modifier = Modif
         stringResource(R.string.settings_past_events_sample_evening),
     )
     val sample = remember(today, zone, titles) { samplePastDay(today, zone, titles) }
-    // Hiding drops the finished rows outright; showing and dimming keep them,
+    // The same three-way split AgendaContent makes.
-    // and only dimming fades them — the same three-way split AgendaContent makes.
     val visible = if (mode == PastEventDisplay.HIDE) sample.filterNot { it.hasPassed } else sample
 
     Column(
         modifier = modifier
             .fillMaxWidth()
             .clipToBounds()
-            // A preview is a picture, not a control: swallow touches before the
+            // A picture, not a control: take the taps the fake rows would
-            // rows' own clickables see them, and keep it out of the reading order —
+            // otherwise handle, and keep it out of the reading order. Taps only —
-            // the options below already say what is selected.
+            // consuming drags would stop the picker scrolling from here.
-            .pointerInput(Unit) {
+            .pointerInput(Unit) { detectTapGestures { } }
-                awaitPointerEventScope {
-                    while (true) {
-                        awaitPointerEvent(PointerEventPass.Initial).changes.forEach { it.consume() }
-                    }
-                }
-            }
             .clearAndSetSemantics { },
     ) {
         AgendaDayHeader(date = today, today = today, onOpenDay = {})
@@ -163,11 +144,8 @@ private fun PastEventsPreview(mode: PastEventDisplay, modifier: Modifier = Modif
 private class SampleRow(val event: EventInstance, val hasPassed: Boolean)
 
 /**
- * Today's stand-in events, [titles] in order: two finished (morning, midday) and
+ * Today's stand-in events, [titles] in order: two finished and one to come.
- * one still to come.
+ * Colours are raw ARGB, as the provider hands them out.
- *
- * Colours are raw ARGB on purpose — that is what the provider hands out for an
- * event, so a theme token here would misrepresent what the agenda renders.
  */
 private fun samplePastDay(today: LocalDate, zone: TimeZone, titles: List<String>): List<SampleRow> =
     listOf(

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

@@ -31,23 +31,13 @@ import de.jeanlucmakiola.floret.locale.currentLocale
  */
 
 /**
- * Token-based accent for a leading icon chip (container / on-container pair).
+ * Accent for a leading icon chip. The chips are a scanning aid, so no two rows
- * Neutral chips stay grey; accents are drawn from the M3 scheme so they adapt
+ * in one group share an accent; [Neutral] is a step back for reference rows
- * to theme, dark mode and dynamic colour.
+ * rather than a fourth colour to rotate through.
- *
- * The chips are a scanning aid, so the rule is **no two rows in one group share
- * an accent** — a group in a single colour carries no more information than no
- * colour at all. [Neutral] is not a fourth colour to rotate through but a
- * deliberate step back, for rows that are reference or last-resort rather than
- * somewhere you routinely go.
  */
 internal enum class ChipAccent { Neutral, Primary, Secondary, Tertiary }
 
-/**
+/** Leading circular icon chip, coloured by an M3 container/on-container pair. */
- * Leading circular icon chip. Colours come from the M3 scheme via a container /
- * on-container token pair, so each accent stays correctly paired across theme,
- * dark mode and dynamic colour.
- */
 @Composable
 internal fun CategoryIcon(icon: ImageVector, accent: ChipAccent) {
     val scheme = MaterialTheme.colorScheme
@@ -75,9 +65,7 @@ internal fun CategoryIcon(icon: ImageVector, accent: ChipAccent) {
 
 /**
  * A small primary-coloured group label, matching the Calendars settings screen.
- *
+ * Inset to [GroupedListInset] so it shares the cards' left margin.
- * Starts on [GroupedListInset] — the cards' own edge — so a header, the hint
- * under it and the group it names all share one left margin.
  */
 @Composable
 internal fun SectionHeader(text: String) {
@@ -117,34 +105,18 @@ internal fun reminderChoiceLabel(minutes: List<Int>): String {
     return minutes.map { reminderLeadTimeLabel(it) }.joinToString(", ")
 }
 
-/**
+/** Day-scale lead times for all-day defaults and contact special dates. */
- * Lead times offered for the all-day default — day-scale, since a "minutes
- * before midnight" reminder on an all-day event is rarely what's wanted. Shared
- * with the contact special-dates calendars, whose events are all all-day.
- */
 internal val ALLDAY_REMINDER_PRESETS = listOf(0, 1_440, 2_880, 10_080)
 
-/**
+/** A minute-of-day in the app's own 12/24-hour convention ([LocalUse24HourFormat]). */
- * A minute-of-day ("09:00") in the app's *own* 12/24-hour convention — the same
- * [LocalUse24HourFormat] the agenda and event rows read, so a time shown in
- * settings can't disagree with the times shown everywhere else.
- */
 @Composable
 internal fun settingsTimeOfDay(minutesOfDay: Int): String =
     formatMinuteOfDay(minutesOfDay, LocalUse24HourFormat.current, currentLocale())
 
 /**
- * Second line for an all-day lead-time row: the clock time it fires at.
+ * Second line for an all-day lead-time row: the clock time it fires at. The
- *
+ * offset only decides which day; the hour comes from the global all-day setting
- * An all-day occurrence has no time of its own, so a reminder's stored offset
+ * (see [de.jeanlucmakiola.calendula.domain.reminders.planReminders]).
- * only decides *which day* it belongs to — the hour always comes from the
- * global "show all-day reminders at" setting (see
- * [de.jeanlucmakiola.calendula.domain.reminders.planReminders]). Naming it on
- * every row is what makes "At time of event" readable on an all-day default at
- * all: it means that day at 09:00, not midnight.
- *
- * Shared by the notification defaults, the per-calendar overrides and the
- * contact special-dates calendars — all three read the same one setting.
  */
 @Composable
 internal fun allDayFiringTimeSummary(allDayReminderTimeMinutes: Int): @Composable (Int) -> String? {

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

@@ -70,15 +70,10 @@ import de.jeanlucmakiola.floret.locale.AppLanguage
 private enum class SettingsSection { Appearance, Views, EventForm, Notifications, SpecialDates, Widgets }
 
 /**
- * Settings (M4), restructured in v2.3 into a category hub with sub-screens and
+ * Settings hub: three labelled groups of category rows, each opening a
- * re-sorted in v2.17 (#69) so every setting sits where it is looked for.
+ * sub-screen from its own `*Settings.kt` file (#69). Calendars and Backup open
- *
+ * screens hoisted in `CalendarHost`; Language opens a full-screen picker.
- * The hub reads as three labelled groups — what the app looks like and how it
+ * [onBack] pops the destination.
- * behaves, what it does with your data, and the app itself — and each sub-screen
- * lives in its own `*Settings.kt` file. Calendars and Backup open screens
- * hoisted in `CalendarHost` (they are driven by the calendar list, not by
- * preferences); Language opens a full-screen picker; About is a card at the top.
- * A full-screen destination; [onBack] pops it.
  */
 @Composable
 fun SettingsScreen(
@@ -166,18 +161,14 @@ private fun SettingsHub(
     onOpenBackup: () -> Unit,
 ) {
     CollapsingScaffold(title = stringResource(R.string.settings_title), onBack = onBack, predictiveBack = true) {
-        // The card and the support row are one grouped block: the call to action
+        // Card and support row are one grouped block, so the call to action
-        // is a row continuing the container rather than a tonal button sitting
+        // continues the container instead of sitting inside it as a button.
-        // inside the card.
         Box(Modifier.padding(horizontal = GroupedListInset)) { AboutCard() }
         SupportRow()
         Spacer(Modifier.height(16.dp))
 
-        // Three labelled groups instead of one long undifferentiated list (#69):
+        // Each group cycles its chip accents so no two rows in it look alike
-        // how the app presents itself, what it does with your data, and the app
+        // (see [ChipAccent]).
-        // as an installed thing. Each group cycles its chip accents so no two
-        // rows in it look alike (see [ChipAccent]) — a uniformly coloured group
-        // is as unscannable as an uncoloured one.
         SectionHeader(stringResource(R.string.settings_group_look))
         GroupedRow(
             title = stringResource(R.string.settings_section_appearance),
@@ -224,9 +215,8 @@ private fun SettingsHub(
             leading = { CategoryIcon(Icons.Default.Cake, ChipAccent.Primary) },
             onClick = { onOpenSection(SettingsSection.SpecialDates) },
         )
-        // Export/import used to hide inside the calendar manager, where nobody
+        // Export/import gets its own top-level entry (#69); the calendar
-        // looked for it (#69). It is a data-safety feature, so it gets its own
+        // manager keeps a pointer row to here.
-        // top-level entry; the manager keeps a pointer row to here.
         GroupedRow(
             title = stringResource(R.string.settings_section_backup),
             summary = stringResource(R.string.settings_backup_subtitle),
@@ -247,10 +237,8 @@ private fun SettingsHub(
         LanguageRow(position = Position.Middle)
         ReportProblemRow(position = Position.Bottom)
 
-        // Source, licence and privacy sit at the very bottom rather than in the
+        // Source, licence and privacy sit at the bottom as reference material
-        // About card: they are reference material you look up once, not settings
+        // rather than inside the About card.
-        // you come here to change, and the card at the top now leads with what
-        // the app *is* plus the one link worth offering (support).
         Spacer(Modifier.height(8.dp))
         SectionHeader(stringResource(R.string.settings_group_about))
         AboutLinkRow(
@@ -364,11 +352,8 @@ private fun languageLabel(tag: String?): String =
 
 @Composable
 private fun AboutCard() {
-    // The card layout lives in floret-kit (components.AboutCard); Calendula
+    // Layout lives in floret-kit (components.AboutCard); Calendula supplies
-    // supplies its own logo and author. Source, licence and privacy moved to
+    // its own logo and author. Support is the [SupportRow] joined below.
-    // rows at the foot of the page, and support is now the [SupportRow] joined
-    // to the bottom of this card — so the card itself carries nothing but what
-    // the app is and who made it.
     AboutCard(
         logo = { AppLogo() },
         appName = stringResource(R.string.app_name),
@@ -378,11 +363,7 @@ private fun AboutCard() {
     )
 }
 
-/**
+/** "Support development", as the closing row of the About card's group. */
- * "Support development", as the closing row of the About card's group rather
- * than a tonal button inside it. Same weight as any other row you can tap, with
- * a primary chip to keep it the one accent in this block.
- */
 @Composable
 private fun SupportRow() {
     val context = LocalContext.current
@@ -396,10 +377,9 @@ private fun SupportRow() {
 }
 
 /**
- * One reference link at the foot of the hub (source, licence, privacy): a plain
+ * One reference link at the foot of the hub (source, licence, privacy). The
- * grouped row that opens the URL in the browser. The privacy policy in
+ * privacy policy has to stay reachable from inside the app, not only from the
- * particular has to stay reachable from inside the app, not only from the store
+ * store listing.
- * listing, because Calendula touches calendar and contact data.
  */
 @Composable
 private fun AboutLinkRow(label: String, url: String, icon: ImageVector, position: Position) {
@@ -433,15 +413,9 @@ private fun AppVersionText() {
 }
 
 /**
- * The app icon as a rounded chip: the off-white launcher mark over its slate
+ * The app icon as a rounded chip: the launcher mark over its background colour,
- * background colour, rendered oversized and clipped to fill the chip the way a
+ * oversized and clipped the way a launcher mask would. Sized just past the two
- * launcher mask would.
+ * text lines beside it; [MARK_OVERSCAN] holds the crop as it shrinks.
- *
- * Sized just past the two text lines beside it, so the card's height is set by
- * its content rather than by the mark towering over it. That also keeps it a
- * step above the 40dp category chips on the rows below — still the block's
- * anchor, no longer its outlier. The mark is a vector, so the size is purely a
- * layout choice; [MARK_OVERSCAN] holds the launcher-mask crop as it shrinks.
  */
 @Composable
 private fun AppLogo() {
@@ -464,8 +438,7 @@ private fun AppLogo() {
 private val LOGO_SIZE = 56.dp
 
 /**
- * How far the mark overruns its chip. An adaptive icon's foreground is drawn
+ * How far the mark overruns its chip. An adaptive icon's foreground carries a
- * with a wide safe margin, so at 1:1 the flower would sit small and lost inside
+ * wide safe margin, so at 1:1 it would sit small and lost; launchers crop it too.
- * the chip; the launcher crops the same way.
  */
 private const val MARK_OVERSCAN = 1.5f

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

@@ -80,9 +80,8 @@ class SettingsViewModel @Inject constructor(
 
     /**
      * Writable calendars that are switched on — the only ones that take a
-     * per-calendar reminder override. A calendar switched off in Settings →
+     * per-calendar reminder override, since a switched-off one plans no
-     * Calendars is `VISIBLE = 0`, so the provider schedules no alarms for it and
+     * reminders at all (#75).
-     * a default reminder configured there could never fire (#75).
      */
     private val writableCalendars: Flow<List<CalendarSource>> = repository.calendars()
         .map { calendars -> calendars.filter { it.canModifyContents && it.isVisibleInSystem } }
@@ -225,17 +224,10 @@ class SettingsViewModel @Inject constructor(
     )
 
     /**
-     * The launcher-label choice (issue #44). Backed by the manifest aliases'
+     * The launcher-label choice (#44), backed by the manifest aliases'
-     * component-enabled state rather than a stored preference, so it's read
+     * component-enabled state rather than a preference. Seeded with the manifest
-     * imperatively via [LauncherNameManager] and held here in its own flow — the
+     * default and corrected off-thread — `getComponentEnabledSetting` is a
-     * main settings combine is already at its arity limit and this isn't a
+     * binder round-trip and this ViewModel is built on the main thread.
-     * DataStore flow anyway.
-     *
-     * Seeded with the manifest default and corrected off-thread rather than read
-     * in the initializer: `getComponentEnabledSetting` is a binder round-trip to
-     * system_server, and this ViewModel is constructed on the main thread while
-     * Settings is opening. The row it feeds is well below the fold, so the
-     * one-frame correction is never visible.
      */
     private val _launcherName = MutableStateFlow(LauncherName.CALENDULA)
     val launcherName: StateFlow<LauncherName> = _launcherName.asStateFlow()
@@ -251,10 +243,8 @@ class SettingsViewModel @Inject constructor(
     private val _fontImportFailed = MutableSharedFlow<Unit>(extraBufferCapacity = 1)
     val fontImportFailed: SharedFlow<Unit> = _fontImportFailed
 
-    // Serialises widget redraws so a rapid flip-and-flip-back can't run two
+    // Serialises widget redraws: concurrent updateAll calls coalesce around a
-    // updateAll calls at once — concurrent calls coalesce around a stale read
+    // stale read and can leave the widget on an intermediate value.
-    // and can leave the widget on the intermediate value. Held sequentially,
-    // the last call reads the final committed pref and renders it.
     private val widgetRefreshMutex = Mutex()
 
     private data class ReminderDefaults(
@@ -407,9 +397,7 @@ class SettingsViewModel @Inject constructor(
     fun setSoftenColors(enabled: Boolean) {
         viewModelScope.launch {
             prefs.setSoftenCalendarColors(enabled)
-            // Both widgets paint event colours through the same softener, so a
+            // Both widgets paint event colours through the same softener.
-            // change has to redraw them too (they read the flag in their data
-            // preamble, like is24Hour).
             widgetRefreshMutex.withLock {
                 AgendaWidget().updateAll(appContext)
                 MonthWidget().updateAll(appContext)
@@ -435,9 +423,8 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch {
             val ok = withContext(io) { CustomFontStore.import(appContext, role, uri) }
             if (ok) {
-                // Bump the stamp so replacing an already-active custom font (same
+                // Bump the stamp so replacing an already-active custom font
-                // file, same "custom" token) still breaks font-settings equality
+                // still breaks equality and refreshes the resolved typeface.
-                // and refreshes the resolved typeface.
                 prefs.bumpCustomFontStamp(role)
                 setFont(role, FONT_CUSTOM_TOKEN)
             } else {
@@ -466,10 +453,8 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch {
             prefs.setAgendaWidgetRange(range)
             widgetRefreshMutex.withLock {
-                // Push the range into each instance's Glance state and recompose.
+                // Push into each instance's Glance state and recompose:
-                // The widget reads it via currentState, so this reflects reliably
+                // updateAll alone won't re-run provideGlance's data preamble.
-                // even when updateAll only recomposes a live session (it does not
-                // re-run provideGlance's data preamble).
                 val manager = GlanceAppWidgetManager(appContext)
                 manager.getGlanceIds(AgendaWidget::class.java).forEach { id ->
                     updateAppWidgetState(appContext, id) { it[AGENDA_RANGE_KEY] = range.storageValue() }
@@ -484,13 +469,9 @@ class SettingsViewModel @Inject constructor(
     }
 
     /**
-     * Set the size the agenda widget draws its text at (#51). Pushed into every
+     * Set the size the agenda widget draws its text at (#51), via the same
-     * instance's Glance state and recomposed — the same reliable-update path as
+     * Glance-state path as [setAgendaWidgetRange]. Agenda-only: the month widget
-     * [setAgendaWidgetRange], since `updateAll` alone won't re-run the data
+     * sizes itself from the space it is given (#103).
-     * preamble a live session already ran.
-     *
-     * Agenda-only on purpose: the month widget sizes itself from the space it is
-     * given and always has, so it takes no size setting (#103).
      */
     fun setWidgetSize(size: WidgetSize) {
         viewModelScope.launch {
@@ -508,9 +489,7 @@ class SettingsViewModel @Inject constructor(
     fun setAgendaShowToday(enabled: Boolean) {
         viewModelScope.launch {
             prefs.setAgendaShowToday(enabled)
-            // The agenda widget reads this reactively, so push it into each
+            // Same Glance-state path as setPastEventDisplay.
-            // instance's Glance state and recompose — same reliable-update path as
-            // setPastEventDisplay (updateAll alone won't re-run the data preamble).
             widgetRefreshMutex.withLock {
                 val manager = GlanceAppWidgetManager(appContext)
                 manager.getGlanceIds(AgendaWidget::class.java).forEach { id ->
@@ -538,10 +517,9 @@ class SettingsViewModel @Inject constructor(
     }
 
     /**
-     * Switch the launcher label between "Calendula" and "Calendar" (issue #44).
+     * Switch the launcher label (#44). The card highlights at once, then settles
-     * The card highlights immediately, then settles on whatever the component
+     * on what the component state reports; the writes are binder round-trips and
-     * state actually reports — the two `setComponentEnabledSetting` calls are
+     * run off the main thread.
-     * binder round-trips, so they don't belong on the main thread either.
      */
     fun setLauncherName(name: LauncherName) {
         _launcherName.value = name
@@ -556,9 +534,7 @@ class SettingsViewModel @Inject constructor(
     fun setPastEventDisplay(mode: PastEventDisplay) {
         viewModelScope.launch {
             prefs.setPastEventDisplay(mode)
-            // The agenda widget honours this setting too, so push it into each
+            // Same Glance-state path as setAgendaWidgetRange.
-            // 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 ->
@@ -582,12 +558,10 @@ class SettingsViewModel @Inject constructor(
     }
 
     /**
-     * Enable or disable [view] in the quick-switch cycle. Goes through an atomic
+     * Enable or disable [view] in the quick-switch cycle, via an atomic
-     * read-modify-write so a concurrent reorder can't clobber this toggle (and
+     * read-modify-write so a concurrent reorder can't clobber it. The
-     * vice versa) by re-serialising a stale snapshot. The MIN_ENABLED floor is
+     * MIN_ENABLED floor is re-checked inside the transform, because the screen's
-     * re-checked inside the transform: the screen's own guard reads the
+     * own guard reads an async-echoed snapshot.
-     * async-echoed snapshot, so two quick disable-taps could both look allowed
-     * yet compose to a below-minimum cycle.
      */
     fun setQuickSwitchViewEnabled(view: CalendarView, enabled: Boolean) {
         viewModelScope.launch {
@@ -612,9 +586,8 @@ class SettingsViewModel @Inject constructor(
     }
 
     /**
-     * A scan follows the write, in that order. Switching reminders off cancels
+     * A scan follows the write: switching reminders off cancels the scan alarm,
-     * the scan alarm, so switching them back on has to arm a new one — nothing
+     * so switching them back on has to arm a new one (#75).
-     * else would until a provider change or the daily worker came along (#75).
      */
     fun setRemindersEnabled(enabled: Boolean) {
         viewModelScope.launch {

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

@@ -48,14 +48,10 @@ internal fun SpecialDatesScreen(
     onBack: () -> Unit,
 ) {
     val state by viewModel.specialDatesState.collectAsStateWithLifecycle()
-    // The all-day reminder hour lives in the general settings state; the reminder
-    // picker below names it, since that is when these reminders actually fire.
     val settings by viewModel.state.collectAsStateWithLifecycle()
     val context = LocalContext.current
 
-    // READ_CONTACTS is requested only here, on enable — never at startup. On a
+    // READ_CONTACTS is requested only here, on enable — never at startup.
-    // grant we either enable (if turning on) or just re-sync (clearing a stalled
-    // banner after the permission was re-granted).
     val permissionLauncher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.RequestPermission(),
     ) { granted ->
@@ -122,8 +118,6 @@ internal fun SpecialDatesScreen(
         )
 
         if (state.enabled) {
-            // Per-type card: the toggle, and while on, its title format and its
-            // calendar-wide reminder.
             SpecialDateType.entries.forEachIndexed { index, type ->
                 Spacer(Modifier.height(if (index == 0) 24.dp else 16.dp))
                 val on = type in state.types
@@ -222,8 +216,6 @@ internal fun SpecialDatesScreen(
             allowInherit = false,
             onSelect = { viewModel.setSpecialDatesReminders(type, it) },
             onDismiss = { reminderPickerType = null },
-            // Special dates are all-day events, so their reminders fire at the
-            // one global all-day hour like any other all-day reminder.
             leadTimeSummary = allDayFiringTimeSummary(settings.allDayReminderTimeMinutes),
         )
     }
@@ -268,8 +260,7 @@ private fun SpecialDatesTemplateDialog(
         title = { Text(stringResource(R.string.settings_special_dates_template)) },
         text = {
             Column {
-                // The app's borderless input over a tonal surface (the dialog
+                // The dialog convention — see DialogControls.
-                // convention — see DialogControls), not Material's outlined field.
                 Surface(
                     color = MaterialTheme.colorScheme.surfaceContainerHighest,
                     shape = RoundedCornerShape(12.dp),

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

@@ -52,15 +52,9 @@ import java.time.format.TextStyle as JavaTextStyle
  * Views: everything that changes how a calendar view reads, grouped by the view
  * it belongs to, plus the two cross-view ordering lists (#24, #69).
  *
- * The first group holds what applies everywhere (default view, week start, time
+ * The quick-switch cycle and the drawer list are independent orders — a view
- * format); the rest are per-view. Anything that styles the *app* rather than a
+ * off in the cycle is still reachable from the drawer. The cycle needs at least
- * view (theme, fonts) is in [AppearanceScreen]; the widget's own copies of the
+ * [QuickSwitchConfig.MIN_ENABLED] targets.
- * agenda settings are in [WidgetsScreen].
- *
- * The quick-switch cycle and the navigation-drawer list are two independent
- * orders — a view disabled in the quick-switch cycle is still reachable from the
- * drawer, which always lists every view. The switch needs at least two targets,
- * so the last [QuickSwitchConfig.MIN_ENABLED] enabled views can't be turned off.
  */
 @Composable
 internal fun ViewsScreen(
@@ -266,8 +260,6 @@ internal fun ViewsScreen(
             options = IMPLEMENTED_VIEWS,
             selected = state.defaultView,
             label = { stringResource(it.labelRes) },
-            // The same icon each view carries in the drawer and the switcher
-            // pill, so the row is matched to the view by eye, not by reading.
             leading = {
                 Icon(
                     imageVector = it.icon,
@@ -299,9 +291,8 @@ internal fun ViewsScreen(
             options = TimeFormatPref.entries,
             selected = state.timeFormat,
             label = { timeFormatLabel(it) },
-            // Each option renders the same sample time the way it would write
+            // Each option renders the same sample time its own way;
-            // it — an afternoon one, since that is where 12h and 24h diverge.
+            // "Automatic" also names which of the two it resolves to.
-            // "Automatic" additionally says which of the two it resolves to now.
             summary = { pref ->
                 val sample = formatTimeOfDay(
                     hour = SAMPLE_HOUR,
@@ -335,8 +326,6 @@ internal fun ViewsScreen(
             title = stringResource(R.string.settings_agenda_range),
             description = stringResource(R.string.settings_agenda_range_hint),
             selected = state.agendaScreenRange,
-            // Resolving each option to real dates needs the same week start the
-            // agenda itself windows by.
             weekStart = state.weekStart.resolveFirstDay(currentLocale()),
             onSelect = viewModel::setAgendaScreenRange,
             onDismiss = { showAgendaScreenRange = false },
@@ -400,8 +389,7 @@ private val WEEK_START_OPTIONS: List<WeekStartPref> =
 @Composable
 internal fun weekStartLabel(pref: WeekStartPref): String = when (pref) {
     WeekStartPref.Auto -> stringResource(R.string.settings_week_start_auto)
-    // Localised full weekday name, so any of the seven days reads naturally
+    // Localised weekday name, so no per-day string resource is needed.
-    // without a per-day string resource.
     is WeekStartPref.Day -> java.time.DayOfWeek.of(pref.day.ordinal + 1)
         .getDisplayName(JavaTextStyle.FULL, currentLocale())
 }

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

@@ -31,20 +31,11 @@ import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.floret.locale.currentLocale
 
 /**
- * The week-start chooser, with the grid it rearranges shown above it.
+ * The week-start chooser, with the grid it rearranges above it — the same
+ * [MonthStylePreview] the Month style picker uses, drawn in the user's own month
+ * style. "Follow the system" carries the day it resolves to as its summary.
  *
- * Which column a week opens on is the most visual setting in the app, and the
+ * A preview picker, so selecting applies at once and keeps the picker open.
- * one hardest to hold in your head from a weekday name alone. The preview is
- * the same [MonthStylePreview] the Month style picker uses, drawn in the user's
- * *own* month style, so what moves is exactly what will move on the real
- * screen. It is short here (the option list runs to eight rows), which the
- * preview supports natively by scaling.
- *
- * "Follow the system" carries the day it currently resolves to as its summary —
- * otherwise the one automatic option is the only one whose effect is invisible.
- *
- * A preview picker, so selecting applies at once and keeps the picker open;
- * back exits (see `FullScreenPicker`).
  */
 @Composable
 internal fun WeekStartPicker(
@@ -93,8 +84,6 @@ internal fun WeekStartPicker(
             val isSelected = option == selected
             GroupedRow(
                 title = weekStartLabel(option),
-                // Only the automatic option needs a second line: it is the one
-                // whose effect the label doesn't name.
                 summary = if (option == WeekStartPref.Auto) {
                     stringResource(
                         R.string.settings_week_start_auto_summary,

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

@@ -33,13 +33,9 @@ import de.jeanlucmakiola.floret.locale.currentLocale
 import kotlin.math.roundToInt
 
 /**
- * Widgets & tiles (#69): the home-screen widgets' own settings and the Quick
+ * Widgets & tiles (#69): the home-screen widgets' settings and the Quick
- * Settings tile shortcut — the app's system surfaces, collected in one place.
+ * Settings tile shortcut. The agenda widget keeps its own range and text size,
- *
+ * separate from the Agenda screen's range in [ViewsScreen].
- * The agenda widget keeps its own range and text size, deliberately separate
- * from the Agenda *screen*'s range in [ViewsScreen]: a widget is glanced at, a
- * screen is browsed, and having the two rows sit next to each other (as they did
- * before) made them easy to mistake for one another.
  */
 @Composable
 internal fun WidgetsScreen(
@@ -71,9 +67,8 @@ internal fun WidgetsScreen(
             onClick = { showWidgetSize = true },
         )
 
-        // One-tap add of the "New event" Quick Settings tile. The system prompt
+        // The add-tile prompt is API 33+; below that the tile is still
-        // is API 33+; on older versions the tile is still addable manually from
+        // addable from the QS editor, so the row just doesn't appear.
-        // the QS editor, so the row simply doesn't appear here.
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
             Spacer(Modifier.height(24.dp))
             QuickSettingsTileRow()
@@ -98,10 +93,8 @@ internal fun WidgetsScreen(
             options = WidgetSize.entries,
             selected = state.widgetSize,
             label = { widgetSizeLabel(it) },
-            // A size name says nothing about what you get; the text scale it
+            // No live preview: the widget is Glance/RemoteViews, so a Compose
-            // draws at does. No live preview here on purpose: the widget is
+            // mock-up would be a second implementation free to drift.
-            // Glance/RemoteViews, so a Compose mock-up would be a second
-            // implementation free to drift from the real thing.
             summary = { widgetSizeSummary(it) },
             onSelect = viewModel::setWidgetSize,
             onDismiss = { showWidgetSize = false },
@@ -138,9 +131,8 @@ private fun requestAddQsTile(context: Context) {
 }
 
 /**
- * What a size step actually does, as a percentage of the smallest one's event
+ * What a size step does, as a percentage of the smallest one's event text.
- * text. Derived from the widget's own [metricsFor] table rather than written
+ * Derived from the widget's own [metricsFor] table rather than hardcoded.
- * out here, so a retuned step can't leave this line claiming the old number.
  */
 @Composable
 private fun widgetSizeSummary(size: WidgetSize): String {

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

@@ -2,19 +2,9 @@ package de.jeanlucmakiola.calendula.widget
 
 /**
  * The size step the **agenda** widget draws its text and rows at — a user
- * setting, not something derived from the widget's measured size (#51).
+ * setting, not the measured size (#51), which a launcher reports inaccurately.
+ * The month widget keeps sizing itself from the width it is given (#103).
  *
- * The agenda widget used to bucket its live size (`SizeMode.Exact` +
+ * [SMALL] is the default and reproduces the widget's original constants.
- * `LocalSize.current`) into a tier and scale from that. The size a launcher
- * reports is not the size the widget is drawn into, so the tier it picked could
- * disagree with what was on screen; a size the user sets is predictable and is
- * what the #51 thread actually asked for.
- *
- * The month widget deliberately has no size setting: its grid divides whatever
- * width it is given by seven and always has, which is the behaviour to keep
- * (#103).
- *
- * [SMALL] is the default and reproduces the widget's original constants, so an
- * existing widget looks as it did until its owner turns the size up.
  */
 enum class WidgetSize { SMALL, MEDIUM, LARGE, EXTRA_LARGE }

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

@@ -8,10 +8,8 @@ import de.jeanlucmakiola.calendula.widget.WidgetSize
 
 /**
  * Horizontal layout constants for an agenda event row. These don't scale with the
- * size step — a wider stripe or gap would eat title width, which is the thing the
+ * size step, since a wider stripe or gap would eat title width, but [TEXT_INDENT]
- * row is short of — but [TEXT_INDENT] is *derived* from them so the day header and
+ * is derived from them so non-event text can't drift out of alignment.
- * the "nothing left today" line can never drift out of alignment with the event
- * title column the way a hardcoded 19dp could.
  */
 internal val ROW_H_PAD = 4.dp
 internal val STRIPE_WIDTH = 5.dp
@@ -39,34 +37,21 @@ internal data class AgendaMetrics(
     val dayHeaderTopPad: Dp,    // space above a day header
 ) {
     /**
-     * Resolves the stripe height against the user's system font scale.
+     * Resolves the stripe height against the user's system font scale: the stripe
-     *
+     * is a [Dp] while the lines beside it are `sp`, so without this the text
-     * The stripe is a [Dp] but the two text lines it sits beside are `sp`, so
+     * outgrows it at large font settings.
-     * they scale with the accessibility font setting and the stripe does not —
-     * at "Largest" the text outgrows the stripe and it visibly under-runs the row
-     * it is supposed to mark. Multiplying by the same factor keeps them locked,
-     * and at the default scale of 1.0 reproduces the step's value exactly.
      */
     fun scaledForFont(fontScale: Float): AgendaMetrics =
         if (fontScale == 1f) this else copy(stripeH = stripeH * fontScale)
 }
 
 /*
- * Type sizes are anchored to the Material 3 type scale (see the `material-3`
+ * Type sizes are anchored to the Material 3 type scale, with two deviations:
- * skill's typography reference) rather than invented: 16sp is Title Medium, 14sp
- * Body Medium / Title Small, 12sp Body Small, 16sp Body Large, 22sp Title Large.
  *
- * Two documented deviations:
+ *  ‡ SMALL's 13sp day header is off-scale, held there so SMALL reproduces the
- *
+ *    widget's original constants verbatim (#51).
- *  ‡ SMALL's 13sp day header is off-scale. It is held there deliberately —
+ *  † Above Title Medium the M3 scale jumps 16 → 22 → 24, too coarse for four
- *    SMALL reproduces the widget's original constants verbatim so a widget whose
+ *    steps; interpolated values are used where a role would force a ≥1.4x jump.
- *    owner never touches the size setting looks exactly as it did (#51), and
- *    snapping it to Title Small (14sp) would break that promise for a 1sp gain.
- *
- *  † Above Title Medium the M3 scale jumps 16 → 22 → 24 with nothing in between,
- *    which is far too coarse for four size steps. Where a role would force a
- *    ≥1.4x step between adjacent steps we hold an interpolated value instead and
- *    mark it. The endpoints stay on real roles.
  */
 
 private val SMALL_METRICS = AgendaMetrics(

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

@@ -116,14 +116,10 @@ class AgendaWidget : GlanceAppWidget() {
 
     override val stateDefinition = PreferencesGlanceStateDefinition
 
-    // Single: type and row metrics come from the user's chosen WidgetSize, not
+    // Single: metrics come from the chosen WidgetSize, not the measured one
-    // from the widget's measured size (#103, #51), so there is nothing to gain
+    // (#103, #51), so a RemoteViews per host size bucket would only double the
-    // from Glance building one RemoteViews per host size bucket — and plenty to
+    // payload. The row list stays capped below — an uncapped agenda could push
-    // lose, since that roughly doubles the serialized payload. The row list is
+    // the RemoteViews past the binder transaction limit.
-    // still capped below: an uncapped agenda (the range goes up to
-    // AgendaRange.MAX_CUSTOM_DAYS = 365) could push the RemoteViews past the
-    // binder transaction limit and the host would just show "Problem loading
-    // widget".
     override val sizeMode = SizeMode.Single
 
     override suspend fun provideGlance(context: Context, id: GlanceId) {
@@ -164,10 +160,8 @@ private sealed interface AgendaRow {
 
 @Composable
 private fun AgendaWidgetBody(data: AgendaWidgetData, dark: Boolean) {
-    // Type and row metrics come from the user's chosen size step, read reactively
+    // Read reactively from per-instance Glance state, falling back to the saved
-    // from per-instance Glance state and falling back to the saved pref for a
+    // pref for a freshly placed widget (#103, #51).
-    // freshly placed widget (#103, #51). The permission screen has no loaded prefs
-    // to fall back to, so it takes the default.
     // The stripe is then re-resolved against the system font scale so it tracks the
     // sp-sized text beside it instead of drifting at large accessibility settings.
     val savedSize = (data as? AgendaWidgetData.Ready)?.savedWidgetSize ?: WidgetSize.SMALL

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

@@ -408,11 +408,9 @@ class CalendarRepositoryImplTest {
     fun `a flushed switch-off never reads as on again before the provider ticks`(
         @TempDir tempDir: Path,
     ) = runTest {
-        // The reconciler's shape: write VISIBLE = 0 straight to the provider,
+        // The reconciler's shape: write VISIBLE = 0, then release the id
-        // then release the id app-side. The provider's notification only arrives
+        // app-side. The provider's notification arrives afterwards, so the
-        // afterwards (it is dispatched through the main looper), so the release
+        // release must not be read against the pre-write snapshot.
-        // must not be read against the snapshot from before the write — that
-        // would flash exactly the events being hidden back into every view.
         val prefs = newPrefs(tempDir)
         prefs.addPendingDisabledCalendarIds(setOf(2L))
         val fake = FakeCalendarDataSource().apply {

app/src/test/java/de/jeanlucmakiola/calendula/domain/RecurrenceOccurrencesTest.kt

@@ -53,13 +53,29 @@ class RecurrenceOccurrencesTest {
             byDays = setOf(DayOfWeek.FRIDAY, DayOfWeek.MONDAY),
         ).upcomingOccurrences(date(2026, 7, 30), limit = 4)
 
-        // Thursday start: the Monday of that week is already past, so the first
+        // The Thursday start is an occurrence in its own right (RFC 5545 puts
-        // hit is Friday 31 Jul, then Mon/Fri of the following weeks.
+        // DTSTART in the set), then Friday 31 Jul and Mon/Fri of the next week.
         assertThat(occurrences).containsExactly(
+            date(2026, 7, 30),
             date(2026, 7, 31),
             date(2026, 8, 3),
             date(2026, 8, 7),
-            date(2026, 8, 10),
+        ).inOrder()
+    }
+
+    @Test
+    fun `the start counts once even when it is also one of the picks`() {
+        // Thursday start with Thursday picked: the seeded DTSTART and the rule's
+        // own hit are the same date and must not both be listed.
+        val occurrences = SimpleRecurrence(
+            RecurrenceFreq.Weekly,
+            byDays = setOf(DayOfWeek.THURSDAY),
+        ).upcomingOccurrences(date(2026, 7, 30), limit = 3)
+
+        assertThat(occurrences).containsExactly(
+            date(2026, 7, 30),
+            date(2026, 8, 6),
+            date(2026, 8, 13),
         ).inOrder()
     }