Fix drag-to-reschedule for events spanning midnight (#253) (#257)

Dragging an event that crosses midnight now works from either half.

- The tail of an overnight event can be picked up and dragged; the drop takes the clip offset back off, so the event lands where its own start belongs, and the second half can be dragged earlier as well as later.
- Timed blocks are cut square at midnight instead of being rounded off, and a month row draws an event crossing into the next week as one bar rather than two unrelated pills.
- Both halves are previewed while dragging, whichever one is held, and the floating copy carries the time range once.
- A moved chip is seated from its own bar's first column, a clipped-tail drop is confirmed against the slice the grid actually draws, and both halves stay ghosted until the write lands.
- The drop's arithmetic is wall clock throughout, so a DST transition between the event's start and the midnight its tail is cut at no longer shifts the write by an hour.
- A refused drop ticks `abandoned`, so a held copy is let go by one signal instead of by every call site.

Closes #253

Co-authored-by: Jean-Luc Makiola <business@jeanlucmakiola.de>
Reviewed-on: https://codeberg.org/jlmakiola/calendula/pulls/257

.gitattributes

@@ -5,3 +5,4 @@
 *.jpg binary
 *.gif binary
 *.webp binary
+app/src/test/resources/ics/*.ics -text

.gitea/workflows/release.yaml

@@ -551,12 +551,11 @@ jobs:
     env:
       VERSION: ${{ needs.detect.outputs.version }}
       VERSION_CODE: ${{ needs.detect.outputs.version_code }}
-      # Where the bundle lands. `internal` by default so a release reaches
-      # testers rather than the public, and promotion to production stays a
-      # deliberate human action in the Play Console — the same posture as
-      # holding UI releases for on-device review. Override with the PLAY_TRACK
-      # repo variable once the flow is trusted.
-      PLAY_TRACK: ${{ vars.PLAY_TRACK || 'internal' }}
+      # Where the bundle lands. `production` — the release itself is already the
+      # gate (a bumped versionName only reaches main after on-device review), so
+      # a second manual promotion in the Play Console bought nothing but delay.
+      # Override with the PLAY_TRACK repo variable to stage a release instead.
+      PLAY_TRACK: ${{ vars.PLAY_TRACK || 'production' }}
       PLAY_RELEASE_STATUS: ${{ vars.PLAY_RELEASE_STATUS || 'completed' }}
       # Set PLAY_DRY_RUN=true to validate the edit against the API and discard
       # it instead of committing — used to rehearse the first upload.

CHANGELOG.md

@@ -7,6 +7,200 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+- **A deleted occurrence no longer comes back when the series is re-timed.**
+  Delete a single occurrence of a repeating event, then change the time of the
+  whole series, and the occurrence you had removed reappeared. Doing it the
+  other way round — "This and all following events" — lost every removal in the
+  part of the series being changed. Removals now travel with the event: they
+  keep their place in the series across a time change, a move to a different
+  day, a timezone change and a switch to or from an all-day event, and they
+  carry over when a series is split. Repeating events on your device's own
+  calendars are affected, including the birthday and anniversary calendars
+  Calendula creates from your contacts ([#248]).
+- **Home-screen widgets now turn the page at midnight.** Both the month and the
+  agenda widget kept highlighting yesterday as "today" — and the agenda kept
+  greying out the wrong events as already past — until you paged the month back
+  and forth or removed and re-added the widget. Calendula now wakes itself at the
+  day boundary and redraws, and re-arms after a reboot, a clock change or a
+  flight into another timezone. Paging the month widget forward and back also
+  stops quietly pinning it to that month, so it follows the date again instead of
+  being stranded on the month you happened to be looking at ([#228]).
+- **"Only this event" now actually saves your edit.** On some calendars —
+  including Google ones that still show as on-device, and any local calendar —
+  editing a single occurrence of a repeating event did nothing at all: the scope
+  dialog closed, the edit screen stayed put, and saving again just repeated it.
+  Android can only attach a single-occurrence change to its series once the
+  calendar has been synced at least once, so on those calendars the change had
+  nowhere to go. Calendula now removes that one occurrence from the series and
+  saves the edit as its own event instead, which is what you see either way. A
+  save that does fail also says so for longer, rather than flashing past
+  ([#234]).
+- **A failed import no longer costs you the whole file.** One event the calendar
+  refuses used to abort the entire import with nothing on screen but "couldn't
+  read this file". Events are now added one at a time: anything rejected is
+  counted and shown, and the rest still arrive. A faulty repeat rule in the file
+  is repaired instead of being handed on ([#225]).
+- **All-day reminders survive a backup and an import.** They fire at the hour you
+  chose, not at midnight UTC — the same rule the app already applied to all-day
+  events you create yourself — and an export no longer leaves them out of the
+  file entirely. An imported yearly birthday fires at the right hour too, even
+  though the file dates it back to the year of birth ([#225]).
+- **Birthdays and anniversaries imported from Fossify Calendar now show up.**
+  Fossify writes the ones it mirrors from your contacts as events that start and
+  end on the same day, which the calendar read as lasting no time at all: they
+  imported without complaint and then appeared nowhere. Any all-day event that
+  ends where it starts, or carries no end at all, is now a one-day event
+  ([#225]).
+- **A backup no longer brings back occurrences you had deleted.** Remove a single
+  occurrence of a repeating event, back up, restore — and it was there again,
+  because the removals never made it into the file. They travel with the series
+  now, so a restored calendar looks the way you left it ([#225]).
+
+### Added
+- **More of an imported `.ics` survives the trip**: tasks come across as events
+  rather than being dropped in silence, deleted occurrences of a repeating event
+  stay deleted, a calendar named like the one the file came from is preselected,
+  and event colours are carried over — matched to the closest colour your
+  calendar's account offers, so a migrated calendar still reads at a glance
+  ([#225]).
+
+## [2.19.3] — 2026-08-22
+
+### Added
+- **Czech, Japanese and Russian**, all three contributed as community
+  translations through
+  [Calendula's Weblate](https://weblate.dev.jeanlucmakiola.de/projects/calendula/).
+  They are early — Czech covers about a third of the app, Russian a fifth,
+  Japanese has just started — so untranslated parts still show in English until
+  they fill out. Pick any of them under Settings → Language or in Android's
+  per-app language settings. Thanks to James Trivette (Czech), ame0011
+  (Japanese), and chip and Pablo (Russian); help finishing them is very welcome.
+
+### Changed
+- **Brazilian Portuguese is now complete**, covering the whole app. Thanks to
+  bkrz for carrying it the rest of the way.
+
+## [2.19.2] — 2026-08-17
+
+### Changed
+- **A meeting you declined is now struck through** wherever it appears — month,
+  week, day, agenda, search and both widgets — and no longer schedules a
+  reminder. Declining an invitation in Google Calendar left the event looking
+  like any other in Calendula, and it still notified you about a meeting you had
+  said no to. It stays visible rather than disappearing: the organiser still
+  expects an answer from you, and the slot is still spoken for ([#180]).
+
+### Fixed
+- **Tapping an event in month view opens the event**, not the day it sits on.
+  Every month style is affected — page, rolling, seamless weeks — and until now
+  the only way to reach an event from the month was to open its day first and
+  find it again there. Tapping anywhere else in the cell still opens the day
+  ([#187]).
+- **An edit made to an event now shows the moment you re-open it.** Adding a
+  description to an event and opening it again showed the sheet as it was before
+  the save, because the detail was only re-read when a different occurrence was
+  opened ([#196]).
+- **The month widget's arrows stopped working after a couple of taps.** The grid
+  was serialised as roughly 740 views, and one update ran to half a megabyte —
+  more than the launcher's buffer takes. The third update overran it, and Android
+  responded by dropping the whole widget host, which killed updates for *every*
+  widget on the home screen, ours and other apps', until the launcher rebound.
+  The grid now draws 192 views, and a resized widget reflows to its new size
+  instead of clipping ([#214]).
+- Tapping a widget's refresh or month arrows redraws that widget by its own id
+  instead of asking Android to update all of them, which does nothing in a
+  process the tap has just woken from cold ([#18]).
+- **Jump-to-today in seamless weeks lands on the current week** instead of
+  leaving a sliver of the previous row on screen ([#191]).
+- Day and week view no longer run their events flush against the right edge
+  ([#192]).
+
+## [2.19.1] — 2026-08-11
+
+### Added
+- **Drag to reschedule can be turned off.** Settings → Views → *Drag to
+  reschedule*, on by default. Off, no event can be picked up in the month, week
+  or day view — for anyone who kept moving appointments by accident while
+  scrolling ([#173]).
+- An early Brazilian Portuguese translation. Calendula has started speaking
+  Brazilian Portuguese, contributed as a community translation through
+  [Calendula's Weblate](https://weblate.dev.jeanlucmakiola.de/projects/calendula/).
+  About a third of the app is covered, so the rest still shows in English — you
+  can pick it under Settings → Language or in Android's per-app language
+  settings. Thanks to
+  [bkrz](https://weblate.dev.jeanlucmakiola.de/user/bkrz/) for getting it
+  started; help finishing it is very welcome.
+
+### Fixed
+- **The language picker forgot which language was picked.** Android hands the
+  applied language back with its script filled in — Simplified Chinese goes in
+  as `zh-CN` and comes out as `zh-Hans-CN` — so after a restart no entry in
+  Settings → Language showed as selected, and the row above it named the
+  language the long way round. Only languages that imply a script were
+  affected.
+
+## [2.19.0] — 2026-08-10
+
+### Added
+- **Drag an event to reschedule it.** Press and hold an event in the month,
+  week or day view and drop it on another time or day — the only way to move an
+  appointment used to be opening it and editing its start and end by hand. The
+  block follows your finger, the timeline scrolls when you carry it to an edge,
+  and the event's length is preserved: a 90-minute meeting dropped on 09:00 ends
+  at 10:30. In week and day view the drop snaps to 15-minute steps; in month
+  view it moves the event to the day you dropped it on and leaves the time
+  alone. A confirmation names the new slot and offers **Undo** wherever the move
+  can be taken back in one step. Events you can't edit — read-only calendars, and
+  birthdays and anniversaries mirrored from your contacts — can't be picked up.
+  Rescheduling isn't pointer-only: a screen reader gets a **Move…** action on
+  every event that can be moved ([#68]).
+- Dragging a **recurring** event asks what it should apply to, the same *this
+  event / this and following / all events* choice a save does. Where moving the
+  whole series would change which weekday it falls on, the rule is rewritten to
+  match — a weekly Monday event dropped on a Wednesday becomes a weekly
+  Wednesday event. Where it can't be rewritten safely, the prompt says so and
+  offers to move just the one occurrence, rather than quietly leaving the
+  series behind ([#68]).
+- **Delete several search results at once.** Long-press a hit in search to enter
+  selection mode, tap the rest (or **Select all**), and delete the lot in one
+  action — finding and removing, say, every leftover event with the same title
+  no longer means opening them one at a time. Recurring hits in the batch ask
+  once for the whole selection instead of once each, results on read-only
+  calendars can't be selected, and the deletion is confirmed before it runs
+  ([#80]).
+
+### Changed
+- **First launch is now a short wizard** instead of a single permission screen.
+  It counts its steps, each one can be stepped back out of, and beyond granting
+  calendar access it offers two things worth deciding once: turning on automatic
+  backup — chosen inline, folder picker and all, since events that live only on
+  the phone are lost with it — and choosing which view Calendula opens on, with
+  a live preview of the month, week, day and agenda layouts rather than four
+  names in a list. Both are skippable, everything chosen is changeable in
+  Settings afterwards, and the backup step is offered only where nothing
+  writable is being synced anywhere. Existing installs are not re-onboarded —
+  revoking and re-granting the calendar permission later does not restart the
+  wizard ([#163]).
+- The one-time notice about calendars switched off for this device is now a step
+  in the flow rather than a dialog thrown over the app on first open.
+
+### Fixed
+- Removed the deprecated `statusBarColor` / `navigationBarColor` theme
+  attributes the Play Console flags on Android 15 and up, where they no longer
+  do anything. The launch backdrop now picks its status-bar icons from the
+  light/dark resource instead, so they stay legible over it either way
+  ([#123]).
+
+## [2.18.1] — 2026-08-06
+
+### Fixed
+- Tapping an empty slot in week or day view creates the event at the hour you
+  tapped, after the timeline has been zoomed. Pinching the day taller or shorter
+  — or changing **Hour height** in Settings — left the tap still being measured
+  against the old spacing, so the new event landed at some other hour entirely
+  ([#148]).
+
 ## [2.18.0] — 2026-07-31
 
 ### Added
@@ -1323,3 +1517,19 @@ automatically, with zero telemetry and no internet permission.
 [#57]: https://codeberg.org/jlmakiola/calendula/issues/57
 [#56]: https://codeberg.org/jlmakiola/calendula/issues/56
 [#114]: https://codeberg.org/jlmakiola/calendula/issues/114
+[#148]: https://codeberg.org/jlmakiola/calendula/issues/148
+[#68]: https://codeberg.org/jlmakiola/calendula/issues/68
+[#80]: https://codeberg.org/jlmakiola/calendula/issues/80
+[#123]: https://codeberg.org/jlmakiola/calendula/issues/123
+[#163]: https://codeberg.org/jlmakiola/calendula/issues/163
+[#173]: https://codeberg.org/jlmakiola/calendula/issues/173
+[#180]: https://codeberg.org/jlmakiola/calendula/issues/180
+[#187]: https://codeberg.org/jlmakiola/calendula/issues/187
+[#191]: https://codeberg.org/jlmakiola/calendula/issues/191
+[#192]: https://codeberg.org/jlmakiola/calendula/issues/192
+[#196]: https://codeberg.org/jlmakiola/calendula/issues/196
+[#214]: https://codeberg.org/jlmakiola/calendula/issues/214
+[#225]: https://codeberg.org/jlmakiola/calendula/issues/225
+[#228]: https://codeberg.org/jlmakiola/calendula/issues/228
+[#234]: https://codeberg.org/jlmakiola/calendula/issues/234
+[#248]: https://codeberg.org/jlmakiola/calendula/issues/248

README.md

@@ -18,6 +18,8 @@ Reads, writes, and reminds — on top of the system calendar, with zero network
 <p>
 <a href="https://f-droid.org/packages/de.jeanlucmakiola.calendula/"><img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png" alt="Get it on F-Droid" height="56"></a>
 &nbsp;
+<a href="https://play.google.com/store/apps/details?id=de.jeanlucmakiola.calendula"><img src="https://play.google.com/intl/en_us/badges/static/images/badges/en_badge_web_generic.png" alt="Get it on Google Play" height="56"></a>
+&nbsp;
 <a href="https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://codeberg.org/jlmakiola/calendula"><img src="https://github.com/ImranR98/Obtainium/blob/main/assets/graphics/badge_obtainium.png?raw=true" alt="Get it on Obtainium" height="56"></a>
 &nbsp;
 <a href="https://ko-fi.com/jeanlucmakiola"><img src="https://storage.ko-fi.com/cdn/brandasset/v2/support_me_on_kofi_badge_beige.png" alt="Support me on Ko-fi" height="56"></a>
@@ -86,7 +88,7 @@ Pick whichever channel you already use — they all install the same app:
 | [Official F-Droid](#f-droid-recommended) | On F-Droid's build schedule | Recommended; no extra setup |
 | [Self-hosted F-Droid repo](#self-hosted-f-droid-repo-fastest-updates) | Minutes after a release | Fastest; needs the repo added once |
 | [Codeberg release / Obtainium](#codeberg-release--obtainium) | Per release | Plain APK download, or automated by Obtainium |
-| [Google Play](#google-play-coming-soon) | — | Coming soon |
+| [Google Play](#google-play) | Per release | Signed with Google's key — see below |
 | [Build from source](#build-from-source) | Whenever you build | Full control |
 
 ### F-Droid (recommended)
@@ -131,18 +133,14 @@ or do it by hand: *Add App* → paste `https://codeberg.org/jlmakiola/calendula`
 → *Add*. Either way, Obtainium tracks the releases and prompts you when a new
 one appears.
 
-### Google Play (coming soon)
+### Google Play
 
-Calendula is on its way to Google Play as an additional channel. It isn't live
-yet — this section gets a link once it is. Play builds will be signed with
-Google's key rather than mine, so switching between Play and any other channel
-will require an uninstall.
+Calendula is live on Google Play:
+**[play.google.com/store/apps/details?id=de.jeanlucmakiola.calendula](https://play.google.com/store/apps/details?id=de.jeanlucmakiola.calendula)**.
 
-> **Testers wanted.** Play requires a round of closed testing before the app can
-> go public, and I'm still looking for testers. If you'd like to help, email
-> **[business@jeanlucmakiola.de](mailto:business@jeanlucmakiola.de)** with the
-> Google account address you want to use — that address is what I need to add you
-> to the closed test.
+Play builds are signed with Google's key rather than mine, so switching between
+Play and any other channel requires an uninstall (and with it, a fresh start for
+app settings — your events live in the system calendar and are unaffected).
 
 ### Build from source
 
@@ -151,7 +149,7 @@ The build is a plain Gradle build with no proprietary dependencies — see
 
 <sub>Official F-Droid, the self-hosted repo, and the Codeberg releases all share
 the same signing key, so you can switch freely between them without
-reinstalling.</sub>
+reinstalling. Google Play is the exception — see above.</sub>
 
 ## 📚 Documentation
 

app/build.gradle.kts

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

app/proguard-rules.pro

@@ -50,3 +50,9 @@
 # the real names also survives app updates, which would otherwise renumber the
 # obfuscated name and orphan the stored mapping.
 -keep class * extends androidx.glance.appwidget.GlanceAppWidget
+
+# Belt and braces one level up: the two receivers are nearly as alike, and the
+# provider map is keyed off the receiver component too. Redundant today (AGP's
+# manifest-derived rules cover them), but #89 cost a release to diagnose and the
+# guarantee should not rest on a component staying in the manifest.
+-keep class * extends androidx.glance.appwidget.GlanceAppWidgetReceiver

app/src/androidTest/java/de/jeanlucmakiola/calendula/ui/onboarding/PermissionScreenTest.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 import androidx.compose.ui.test.assertIsDisplayed
 import androidx.compose.ui.test.junit4.createComposeRule

app/src/main/AndroidManifest.xml

@@ -330,9 +330,13 @@
         </receiver>
 
         <!-- Keeps both widgets fresh: the calendar provider broadcasts
-             PROVIDER_CHANGED on any data change (our writes and external sync),
-             and the system broadcasts the date/time ones at midnight / clock
-             changes so "today" highlighting rolls over. -->
+             PROVIDER_CHANGED on any data change (our writes and external sync).
+             The day boundary arrives as the app's own ROLLOVER alarm (#228), by
+             explicit PendingIntent, so it needs no filter here; DATE_CHANGED is
+             a free extra only, since Android 8+ withholds it from manifest
+             receivers. The four below re-arm that alarm: TIME_SET /
+             TIMEZONE_CHANGED move the boundary, boot / package-replace wipe it.
+             Exported: the system broadcasts arrive from outside the app. -->
         <receiver
             android:name=".widget.WidgetUpdateReceiver"
             android:exported="true">
@@ -346,6 +350,8 @@
                 <action android:name="android.intent.action.DATE_CHANGED" />
                 <action android:name="android.intent.action.TIME_SET" />
                 <action android:name="android.intent.action.TIMEZONE_CHANGED" />
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
             </intent-filter>
         </receiver>
 

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

@@ -10,6 +10,7 @@ import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesScheduler
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesSyncWorker
 import de.jeanlucmakiola.calendula.data.reminders.ReminderMaintenanceScheduler
 import de.jeanlucmakiola.calendula.data.reminders.ReminderMaintenanceWorker
+import de.jeanlucmakiola.calendula.widget.WidgetRolloverScheduler
 import de.jeanlucmakiola.floret.crash.CrashConfig
 import de.jeanlucmakiola.floret.crash.CrashReporter
 import kotlinx.coroutines.CoroutineScope
@@ -44,6 +45,19 @@ class CalendulaApp : Application() {
         reconcileSpecialDates()
         reconcileCalendarVisibility()
         startReminderDelivery()
+        reconcileWidgetRollover()
+    }
+
+    /**
+     * Re-arm the widgets' midnight rollover from whatever is actually placed
+     * (#228). Idempotent, and it covers what no broadcast reaches — an alarm
+     * dropped by a force-stop is armed again the next time the app is opened.
+     * Off the main thread: a handful of binder calls on every process start.
+     */
+    private fun reconcileWidgetRollover() {
+        CoroutineScope(SupervisorJob() + Dispatchers.Default).launch {
+            WidgetRolloverScheduler.sync(this@CalendulaApp)
+        }
     }
 
     /**

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

@@ -70,6 +70,34 @@ internal fun nextYearlyOccurrence(month: Int, day: Int, today: LocalDate): Local
     return LocalDate.of(today.year, month, day)
 }
 
+/**
+ * The date an **imported** all-day event's reminder offset is sampled at.
+ *
+ * A one-off fires once, on its own date. A series' `DTSTART` is only an anchor
+ * and may be ancient — Fossify writes a year-less contact birthday at 1970, a
+ * year whose rules predate DST across most of Europe, and a real birth year is
+ * usually older still — so sampling there skews every modern occurrence by the
+ * offset delta (the same trap [nextYearlyOccurrence] exists for). A yearly
+ * series is therefore sampled at its next occurrence of the anchor's month/day,
+ * which shares the season; any other series at [today], which its upcoming
+ * occurrences are near.
+ *
+ * The decode side ([fromProviderAllDayMinutes]) only asks which local *day* the
+ * encoded instant falls on, so it still reads the lead time back correctly from
+ * the anchor's own date.
+ */
+internal fun importedAllDayReminderDate(
+    startDate: LocalDate,
+    recurrenceRule: String?,
+    today: LocalDate,
+): LocalDate = when {
+    recurrenceRule.isNullOrBlank() -> startDate
+    recurrenceRule.contains("FREQ=YEARLY", ignoreCase = true) ->
+        nextYearlyOccurrence(startDate.monthValue, startDate.dayOfMonth, today)
+    startDate.isBefore(today) -> today
+    else -> startDate
+}
+
 /**
  * Recover the semantic whole-day lead time from a raw all-day reminder
  * [rawMinutes] — the inverse of [toProviderAllDayMinutes], for the form and the

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

@@ -27,12 +27,15 @@ import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.curatedForPicker
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.EventSearch
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
+import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.contacts.MANAGED_UID_PREFIX
 import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
+import de.jeanlucmakiola.calendula.domain.ics.semanticReminderMinutes
 import de.jeanlucmakiola.calendula.domain.rruleTruncatedAt
 import kotlinx.datetime.toJavaLocalDate
 import java.time.Instant
@@ -62,12 +65,14 @@ interface CalendarDataSource {
     fun eventDetail(eventId: Long, allDayReminderTimeMinutes: Int): EventDetail?
 
     /**
-     * Master/one-off events whose title, description or location contains
-     * [query] (case-insensitive), across all calendars, newest first. Reads the
-     * Events table directly so the search is unbounded in time; exception rows
-     * are excluded (see [SearchProjection]). [query] is assumed non-blank.
+     * Master/one-off events that may match [query], across all calendars: every
+     * whitespace-separated token has to appear in the title, description or
+     * location. Reads the Events table directly so the search is unbounded in
+     * time; exception rows are excluded (see [SearchProjection]). A deliberate
+     * superset — [EventSearch] makes the final call and orders the hits.
+     * [query] is assumed non-blank.
      */
-    fun searchEvents(query: String): List<EventInstance>
+    fun searchEvents(query: String): List<SearchCandidate>
 
     /**
      * The event-colour palette the calendar's account publishes
@@ -80,14 +85,25 @@ interface CalendarDataSource {
      */
     fun eventColorPalette(calendarId: Long): List<EventColorOption>
 
+    /**
+     * The same palette **uncurated** — every key the account publishes, in
+     * provider order. Curation is a display concession (it folds look-alikes and
+     * drops the neutrals outright from an oversized palette), so matching a
+     * colour that came from outside the account has to run against the full set:
+     * those keys are all the calendar accepts. See [eventColorPalette].
+     */
+    fun publishedEventColors(calendarId: Long): List<EventColorOption>
+
     /**
      * Every master/one-off event of the writable local calendars, mapped for a
      * whole-calendar `.ics` backup. Modified-occurrence and cancelled-exception
      * rows are excluded (see [EventExportProjection]). When [calendarIds] is
      * given, only those calendars are exported (still intersected with the
      * eligible set); `null` exports every eligible calendar.
+     * [allDayReminderTimeMinutes]: needed to write all-day reminders as whole-day
+     * lead times rather than raw provider offsets (see [toIcsEvent]).
      */
-    fun exportableEvents(calendarIds: Set<Long>? = null): List<IcsEvent>
+    fun exportableEvents(calendarIds: Set<Long>?, allDayReminderTimeMinutes: Int): List<IcsEvent>
 
     /**
      * The non-empty `Events.UID_2445` values present in [calendarId] — used to
@@ -97,10 +113,19 @@ interface CalendarDataSource {
 
     /**
      * Insert a parsed `.ics` event into [calendarId], preserving its UID (or
-     * minting one when absent); returns the new `Events._ID`. Reminders are
-     * written as the file's raw lead minutes (METHOD_ALERT).
+     * minting one when absent); returns the new `Events._ID`.
+     *
+     * [colorPalette] is the target account's published event colours
+     * ([publishedEventColors]), looked up once per import;
+     * [allDayReminderTimeMinutes] is the user's preferred all-day firing time,
+     * applied exactly as a hand-created event's is.
      */
-    fun insertImportedEvent(event: ParsedIcsEvent, calendarId: Long): Long
+    fun insertImportedEvent(
+        event: ParsedIcsEvent,
+        calendarId: Long,
+        allDayReminderTimeMinutes: Int,
+        colorPalette: List<EventColorOption>,
+    ): Long
 
     /**
      * Create a new device-only (`ACCOUNT_TYPE_LOCAL`) calendar the app owns;
@@ -228,10 +253,15 @@ interface CalendarDataSource {
     ): Long
 
     /**
-     * Change a single occurrence of a recurring event by inserting a
-     * modified-occurrence exception at [beginMillis] (the occurrence's
-     * `Instances.BEGIN`) carrying [form]'s values; returns the exception
-     * row's `Events._ID`. [allDayReminderTimeMinutes]: see [insertEvent].
+     * Change a single occurrence of a recurring event at [beginMillis] (the
+     * occurrence's `Instances.BEGIN`) to [form]'s values; returns the
+     * `Events._ID` of the row now holding them.
+     *
+     * A series with a `_sync_id` gets a modified-occurrence exception. One
+     * without gets the occurrence excluded from the parent via EXDATE plus a
+     * standalone event carrying the edits — an exception cannot link to its
+     * parent there (Codeberg #234, the same constraint as [deleteOccurrence]).
+     * [allDayReminderTimeMinutes]: see [insertEvent].
      */
     fun updateOccurrence(
         eventId: Long,
@@ -585,20 +615,23 @@ class AndroidCalendarDataSource @Inject constructor(
         )?.use { c -> c.mapAllNotNull { CursorColumnReader(c).toEventInstance() } } ?: emptyList()
     }
 
-    override fun searchEvents(query: String): List<EventInstance> {
+    override fun searchEvents(query: String): List<SearchCandidate> {
         ensureObserversRegistered()
-        val trimmed = query.trim()
-        if (trimmed.isEmpty()) return emptyList()
-        // Escape the SQL LIKE wildcards so a literal % or _ in the query matches
-        // itself instead of acting as a wildcard.
-        val escaped = trimmed
-            .replace("\\", "\\\\")
-            .replace("%", "\\%")
-            .replace("_", "\\_")
-        val like = "%$escaped%"
-        val match = "${CalendarContract.Events.TITLE} LIKE ? ESCAPE '\\' OR " +
+        val tokens = EventSearch.tokenize(query).take(MAX_SEARCH_TOKENS)
+        if (tokens.isEmpty()) return emptyList()
+        // Only a pre-filter: EventSearch re-checks every token, including the
+        // ones the cap above dropped.
+        val patterns = tokens.map { likePatterns(it) }
+        val match = patterns.joinToString(" AND ") { variants ->
+            variants.joinToString(" OR ", prefix = "(", postfix = ")") {
+                "${CalendarContract.Events.TITLE} LIKE ? ESCAPE '\\' OR " +
                     "${CalendarContract.Events.DESCRIPTION} LIKE ? ESCAPE '\\' OR " +
                     "${CalendarContract.Events.EVENT_LOCATION} LIKE ? ESCAPE '\\'"
+            }
+        }
+        val args = patterns
+            .flatMap { variants -> variants.flatMap { pattern -> List(3) { pattern } } }
+            .toTypedArray()
         val selection = "($match) AND " +
             "${CalendarContract.Events.DELETED} = 0 AND " +
             "${CalendarContract.Events.ORIGINAL_ID} IS NULL"
@@ -606,19 +639,17 @@ class AndroidCalendarDataSource @Inject constructor(
             CalendarContract.Events.CONTENT_URI,
             SearchProjection.COLUMNS,
             selection,
-            arrayOf(like, like, like),
+            args,
             CalendarContract.Events.DTSTART + " DESC",
         )?.use { c ->
             val reader = CursorColumnReader(c)
-            val out = ArrayList<EventInstance>(c.count)
+            val out = ArrayList<SearchCandidate>(c.count)
             while (c.moveToNext()) {
+                val description = reader.getString(SearchProjection.IDX_DESCRIPTION)
                 val base = reader.toSearchResult() ?: continue
-                // A recurring master's DTSTART is the series start; show its
-                // nearest occurrence instead so the date is the one the user
-                // actually cares about (and sorting reflects it).
-                val recurring = !reader.getString(SearchProjection.IDX_RRULE).isNullOrEmpty() ||
-                    !reader.getString(SearchProjection.IDX_RDATE).isNullOrEmpty()
-                out += if (recurring) {
+                // A recurring master's DTSTART is the series start; date the row
+                // by its nearest occurrence instead.
+                val event = if (base.isRecurring) {
                     nearestOccurrenceMillis(base.eventId)?.let { (begin, end) ->
                         base.copy(
                             start = begin.toKotlinInstantFromEpochMillis(),
@@ -628,11 +659,44 @@ class AndroidCalendarDataSource @Inject constructor(
                 } else {
                     base
                 }
+                // The raw title, so matching can't catch on the placeholder an
+                // untitled event is drawn with.
+                out += SearchCandidate(
+                    event = event,
+                    description = description,
+                    title = reader.getString(SearchProjection.IDX_TITLE),
+                )
             }
             out
         } ?: emptyList()
     }
 
+    /**
+     * One token as the `LIKE` patterns to OR together. SQLite folds case for
+     * ASCII only, so a token with cased non-ASCII letters is also queried lower-,
+     * upper- and title-cased, which is how "ärzte" reaches "Ärzte". Wildcarding
+     * those letters away instead would make "москва" `%______%` — a full scan.
+     */
+    private fun likePatterns(token: String): List<String> {
+        if (token.none { it.code > 127 && (it.isUpperCase() || it.isLowerCase()) }) {
+            return listOf(likePattern(token))
+        }
+        val lower = token.lowercase()
+        return listOf(token, lower, token.uppercase(), lower.replaceFirstChar(Char::uppercaseChar))
+            .distinct()
+            .map(::likePattern)
+    }
+
+    private fun likePattern(token: String): String {
+        val sb = StringBuilder("%")
+        for (c in token) {
+            // A literal wildcard from the query matches itself.
+            if (c == '%' || c == '_' || c == '\\') sb.append('\\')
+            sb.append(c)
+        }
+        return sb.append('%').toString()
+    }
+
     /**
      * The occurrence of [eventId] nearest to now: the soonest upcoming one
      * within [OCCURRENCE_WINDOW_MILLIS] ahead, else the most recent past one
@@ -683,7 +747,10 @@ class AndroidCalendarDataSource @Inject constructor(
         }
     }
 
-    override fun eventColorPalette(calendarId: Long): List<EventColorOption> {
+    override fun eventColorPalette(calendarId: Long): List<EventColorOption> =
+        publishedEventColors(calendarId).curatedForPicker()
+
+    override fun publishedEventColors(calendarId: Long): List<EventColorOption> {
         val account = calendarAccount(calendarId) ?: return emptyList()
         return resolver.query(
             CalendarContract.Colors.CONTENT_URI,
@@ -701,11 +768,13 @@ class AndroidCalendarDataSource @Inject constructor(
             c.mapAll { EventColorOption(key = it.getString(0).orEmpty(), argb = it.getInt(1)) }
         }
             ?.filter { it.key.isNotEmpty() }
-            ?.curatedForPicker()
             ?: emptyList()
     }
 
-    override fun exportableEvents(calendarIds: Set<Long>?): List<IcsEvent> {
+    override fun exportableEvents(
+        calendarIds: Set<Long>?,
+        allDayReminderTimeMinutes: Int,
+    ): List<IcsEvent> {
         // Only the local calendars the app owns and can write — synced calendars
         // already have a backup (their server). Exclude the managed special-dates
         // mirror calendars: their events are derived from contacts, not authored
@@ -740,6 +809,7 @@ class AndroidCalendarDataSource @Inject constructor(
                 reader.toIcsEvent(
                     reminderMinutes = queryReminders(eventId).map { it.minutes },
                     calendarName = names[calendarId],
+                    allDayReminderTimeMinutes = allDayReminderTimeMinutes,
                 )
             }
         } ?: emptyList()
@@ -748,55 +818,64 @@ class AndroidCalendarDataSource @Inject constructor(
     override fun existingUids(calendarId: Long): Set<String> = resolver.query(
         CalendarContract.Events.CONTENT_URI,
         arrayOf(CalendarContract.Events.UID_2445),
+        // DELETED rows linger until a sync adapter purges them; counting those
+        // as present would make a re-import skip everything the user has since
+        // deleted, reporting "all duplicates" and importing nothing.
         "${CalendarContract.Events.CALENDAR_ID} = ? AND " +
-            "${CalendarContract.Events.UID_2445} IS NOT NULL",
+            "${CalendarContract.Events.UID_2445} IS NOT NULL AND " +
+            "${CalendarContract.Events.DELETED} = 0",
         arrayOf(calendarId.toString()),
         null,
     )?.use { c ->
         buildSet { while (c.moveToNext()) c.getString(0)?.takeIf { it.isNotEmpty() }?.let(::add) }
     } ?: emptySet()
 
-    override fun insertImportedEvent(event: ParsedIcsEvent, calendarId: Long): Long {
-        val startMillis = event.start.toEpochMillis()
-        val endMillis = event.end.toEpochMillis()
-        val values = ContentValues().apply {
-            put(CalendarContract.Events.CALENDAR_ID, calendarId)
+    override fun insertImportedEvent(
+        event: ParsedIcsEvent,
+        calendarId: Long,
+        allDayReminderTimeMinutes: Int,
+        colorPalette: List<EventColorOption>,
+    ): Long {
+        val values = buildImportedEventValues(
+            event = event,
+            calendarId = calendarId,
             // Preserve the file's UID so a re-import dedups against it; mint one
             // only when the source event carried none.
-            put(
-                CalendarContract.Events.UID_2445,
-                event.uid?.takeIf { it.isNotBlank() } ?: "${UUID.randomUUID()}@calendula",
+            uid = event.uid?.takeIf { it.isNotBlank() } ?: "${UUID.randomUUID()}@calendula",
+            palette = colorPalette,
         )
-            put(CalendarContract.Events.TITLE, event.summary.trim())
-            put(CalendarContract.Events.ALL_DAY, if (event.isAllDay) 1 else 0)
-            put(CalendarContract.Events.DTSTART, startMillis)
-            if (event.recurrenceRule == null) {
-                put(CalendarContract.Events.DTEND, endMillis)
-            } else {
-                put(CalendarContract.Events.RRULE, event.recurrenceRule)
-                put(
-                    CalendarContract.Events.DURATION,
-                    importDuration(startMillis, endMillis, event.isAllDay),
-                )
-            }
-            // All-day rows live at UTC midnights (the file already encodes them so);
-            // timed rows keep the event's own zone.
-            put(CalendarContract.Events.EVENT_TIMEZONE, if (event.isAllDay) "UTC" else event.zoneId)
-            put(CalendarContract.Events.AVAILABILITY, event.availability.toProviderValue())
-            put(CalendarContract.Events.STATUS, event.status.toProviderStatus())
-            event.location?.trim()?.takeIf { it.isNotEmpty() }
-                ?.let { put(CalendarContract.Events.EVENT_LOCATION, it) }
-            event.description?.trim()?.takeIf { it.isNotEmpty() }
-                ?.let { put(CalendarContract.Events.DESCRIPTION, it) }
-        }
-        val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values)
+        val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values.toContentValues())
             ?: throw WriteFailedException("import event into calendar id=$calendarId")
         val eventId = ContentUris.parseId(uri)
-        // Raw lead minutes straight from the file's VALARMs (best-effort, like insertEvent).
-        event.reminderMinutes.distinct().filter { it >= 0 }.forEach { minutes ->
+        val zone = ZoneId.systemDefault()
+        // An all-day reminder is stored the same way a hand-created one is, so it
+        // fires at the time the user picked rather than at UTC midnight — sampled
+        // where it will actually fire, not at an ancient recurrence anchor
+        // (see [importedAllDayReminderDate]).
+        val reminderDate = if (event.isAllDay) {
+            importedAllDayReminderDate(
+                startDate = Instant.ofEpochMilli(event.start.toEpochMilliseconds())
+                    .atZone(ZoneOffset.UTC).toLocalDate(),
+                recurrenceRule = event.recurrenceRule,
+                today = LocalDate.now(zone),
+            )
+        } else {
+            null
+        }
+        event.semanticReminderMinutes().forEach { minutes ->
+            val providerMinutes = if (reminderDate != null) {
+                toProviderAllDayMinutes(
+                    semanticMinutes = minutes,
+                    startDate = reminderDate,
+                    zone = zone,
+                    timeOfDayMinutes = allDayReminderTimeMinutes,
+                )
+            } else {
+                minutes
+            }
             val reminder = ContentValues().apply {
                 put(CalendarContract.Reminders.EVENT_ID, eventId)
-                put(CalendarContract.Reminders.MINUTES, minutes)
+                put(CalendarContract.Reminders.MINUTES, providerMinutes)
                 put(CalendarContract.Reminders.METHOD, CalendarContract.Reminders.METHOD_ALERT)
             }
             if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder) == null) {
@@ -806,18 +885,6 @@ class AndroidCalendarDataSource @Inject constructor(
         return eventId
     }
 
-    /** Provider DURATION for an imported recurring row: whole days / seconds. */
-    private fun importDuration(startMillis: Long, endMillis: Long, isAllDay: Boolean): String {
-        val span = (endMillis - startMillis).coerceAtLeast(0)
-        return if (isAllDay) "P${span / 86_400_000L}D" else "P${span / 1_000L}S"
-    }
-
-    private fun EventStatus.toProviderStatus(): Int = when (this) {
-        EventStatus.Confirmed -> CalendarContract.Events.STATUS_CONFIRMED
-        EventStatus.Tentative -> CalendarContract.Events.STATUS_TENTATIVE
-        EventStatus.Cancelled -> CalendarContract.Events.STATUS_CANCELED
-    }
-
     /** The account a calendar belongs to, for scoping a `Colors` lookup. */
     private fun calendarAccount(calendarId: Long): CalendarAccount? = resolver.query(
         ContentUris.withAppendedId(CalendarContract.Calendars.CONTENT_URI, calendarId),
@@ -938,10 +1005,12 @@ class AndroidCalendarDataSource @Inject constructor(
         updated: EventForm,
         allDayReminderTimeMinutes: Int,
     ) {
+        val row = querySeriesRow(eventId)
         val values = buildEventUpdateValues(
             original = original,
             updated = updated,
-            seriesDtStartMillis = querySeriesRow(eventId).dtStartMillis,
+            seriesDtStartMillis = row.dtStartMillis,
+            seriesExdate = row.exdate,
             zone = ZoneId.systemDefault(),
         )
         if (values.isNotEmpty()) {
@@ -1156,6 +1225,13 @@ class AndroidCalendarDataSource @Inject constructor(
         form: EventForm,
         allDayReminderTimeMinutes: Int,
     ): Long {
+        val row = querySeriesRow(eventId)
+        // Stricter than deleteOccurrence's bare _sync_id check: EXDATE only means
+        // something on a row that recurs, so a non-recurring one keeps the
+        // exception path rather than getting a recurrence set written onto it.
+        if (row.syncId == null && !row.rrule.isNullOrBlank()) {
+            return detachOccurrence(eventId, beginMillis, row, form, allDayReminderTimeMinutes)
+        }
         // The provider clones the series row and applies these values on top.
         val values = buildOccurrenceExceptionValues(
             form = form,
@@ -1174,6 +1250,89 @@ class AndroidCalendarDataSource @Inject constructor(
         return exceptionId
     }
 
+    /**
+     * "Edit only this event" on a series with **no `_sync_id`**: drop the
+     * occurrence from the parent with EXDATE and insert the edited values as a
+     * standalone event on the same calendar.
+     *
+     * A modified exception attaches to its parent only through `ORIGINAL_SYNC_ID`,
+     * exactly like the cancelled one [deleteOccurrence] documents; with no
+     * `_sync_id` the link never forms and the edit is lost (Codeberg #234).
+     * EXDATE plus a standalone row needs no link — what a detached instance
+     * degrades to without a `RECURRENCE-ID` to carry it.
+     *
+     * The detached row keeps no stored link back to its series, so: it no longer
+     * travels with it ([moveEvent] copies the master and its `ORIGINAL_ID`
+     * children, and this is neither); its EXDATE hole is an absolute instant, so
+     * re-timing the whole series brings the occurrence back beside the copy (a
+     * #47 delete resurrects the same way); and it is built from the form, not
+     * cloned, so `ORGANIZER`, `STATUS` and the attendee rows [reconcileAttendees]
+     * preserves are dropped — the same limitation as [moveEvent].
+     *
+     * Insert first, so a failure leaves the series untouched
+     * ([updateEventFromOccurrence]'s discipline); roll the new row back if the
+     * EXDATE update then fails, since it would be a visible duplicate. The
+     * reverse order risks the worse outcome — an excluded occurrence with no
+     * replacement, i.e. an edit that quietly deletes.
+     */
+    private fun detachOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        row: SeriesRow,
+        form: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ): Long {
+        // Already detached (or deleted) from a stale screen still pointing at the
+        // parent: the EXDATE merge would fold the repeat away and still report a
+        // changed row, quietly leaving a *second* standalone copy.
+        if (exdateContains(row.exdate, beginMillis, isAllDay = row.allDay != 0)) {
+            throw NoSuchEventException(eventId)
+        }
+        // Reminders, guests and colour come along like any new event, and so does
+        // a fresh UID — the detached row is a separate event now, and sharing the
+        // parent's would collide with it in .ics restore dedup.
+        val detachedId = insertEvent(form.toDetachedOccurrence(), allDayReminderTimeMinutes)
+        val values = buildOccurrenceExdateValues(
+            existingExdate = row.exdate,
+            occurrenceMillis = beginMillis,
+            dtStartMillis = row.dtStartMillis,
+            rrule = row.rrule,
+            duration = row.duration,
+            timezone = row.timezone,
+            allDay = row.allDay,
+        )
+        // Rows touched, not occurrences excluded — 1 whenever the series row still
+        // exists. It catches the row disappearing under us, not an EXDATE the
+        // provider's expansion fails to match.
+        val updatedRows = try {
+            resolver.update(
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+                values.toContentValues(), null, null,
+            )
+        } catch (t: Throwable) {
+            rollBackDetached(detachedId)
+            throw t
+        }
+        if (updatedRows == 0) {
+            rollBackDetached(detachedId)
+            throw WriteFailedException(
+                "exdate occurrence for edit, event id=$eventId begin=$beginMillis",
+            )
+        }
+        return detachedId
+    }
+
+    /**
+     * Undo the standalone row [detachOccurrence] inserted before its EXDATE
+     * update failed. Best effort: the caller is already throwing, and the worst
+     * case is the duplicate we were avoiding — never a lost occurrence.
+     */
+    private fun rollBackDetached(detachedId: Long) {
+        runCatching { deleteEvent(detachedId) }.onFailure {
+            Log.w(TAG, "Failed to roll back detached occurrence $detachedId", it)
+        }
+    }
+
     override fun updateEventFromOccurrence(
         eventId: Long,
         beginMillis: Long,
@@ -1190,10 +1349,66 @@ class AndroidCalendarDataSource @Inject constructor(
         }
         // Insert the new series first: if it fails, the original is untouched.
         val newEventId = insertEvent(updated, allDayReminderTimeMinutes)
+        carrySplitExdate(newEventId, row, beginMillis, original, updated)
         truncateSeries(eventId, row, beginMillis)
         return newEventId
     }
 
+    /**
+     * Carry the [parent]'s exclusions for occurrences past [beginMillis] onto the
+     * series [newEventId] that now owns them, re-timed by the shift the split
+     * applied ([shiftedExdate]/[exdateAfter]). [insertEvent] builds the new row
+     * from the form, which knows nothing about them, so without this every
+     * occurrence the user had deleted from the tail of the series comes back.
+     *
+     * The whole time/recurrence set rides along with EXDATE for the reason
+     * [buildOccurrenceExdateValues] documents: on its own the provider does not
+     * read an EXDATE write as a recurrence change, and leaves the instances it
+     * expanded on insert standing.
+     *
+     * A failure rolls the new series back and throws, so the split fails whole
+     * rather than landing with the exclusions quietly dropped — the parent is
+     * still untruncated at this point, so the event is left exactly as it was.
+     */
+    private fun carrySplitExdate(
+        newEventId: Long,
+        parent: SeriesRow,
+        beginMillis: Long,
+        original: EventForm,
+        updated: EventForm,
+    ) {
+        // Dropping the recurrence in the same save leaves a one-off tail, and an
+        // exclusion means nothing on a row that doesn't recur.
+        if (updated.rrule.isNullOrBlank()) return
+        val carried = shiftedExdate(
+            existingExdate = exdateAfter(parent.exdate, beginMillis, original.isAllDay),
+            original = original,
+            updated = updated,
+            zone = ZoneId.systemDefault(),
+        ) ?: return
+        val row = querySeriesRow(newEventId)
+        val values = ContentValues().apply {
+            put(CalendarContract.Events.EXDATE, carried)
+            put(CalendarContract.Events.DTSTART, row.dtStartMillis)
+            put(CalendarContract.Events.RRULE, row.rrule)
+            put(CalendarContract.Events.DURATION, row.duration)
+            put(CalendarContract.Events.EVENT_TIMEZONE, row.timezone)
+            put(CalendarContract.Events.ALL_DAY, row.allDay)
+        }
+        try {
+            val rows = resolver.update(
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, newEventId),
+                values, null, null,
+            )
+            if (rows == 0) {
+                throw WriteFailedException("carry exdate onto split series id=$newEventId")
+            }
+        } catch (t: Throwable) {
+            runCatching { deleteEvent(newEventId) }
+            throw t
+        }
+    }
+
     override fun deleteEventFromOccurrence(eventId: Long, beginMillis: Long) {
         val row = querySeriesRow(eventId)
         // From the first occurrence on = the whole series; also the fallback
@@ -1593,5 +1808,12 @@ class AndroidCalendarDataSource @Inject constructor(
          * next fires beyond it falls back to its series-start date.
          */
         const val OCCURRENCE_WINDOW_MILLIS = 2L * 365 * 24 * 60 * 60 * 1000
+
+        /**
+         * Tokens the SQL pre-filter is built from. Bounds the statement for a
+         * pasted paragraph; the ranker still requires every token, so a capped
+         * search returns fewer rows to check, never more hits.
+         */
+        const val MAX_SEARCH_TOKENS = 8
     }
 }

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

@@ -5,6 +5,7 @@ import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
@@ -17,11 +18,11 @@ interface CalendarRepository {
     suspend fun eventDetail(eventId: Long): EventDetail
 
     /**
-     * Events whose title, description or location contains [query], with hidden
-     * calendars removed and newest first. Empty when [query] is blank. Searches
-     * the whole history/future (see [CalendarDataSource.searchEvents]).
+     * Candidate matches for [query] with hidden calendars removed; empty when
+     * [query] is blank. Searches the whole history/future and leaves matching
+     * and ranking to [de.jeanlucmakiola.calendula.domain.EventSearch].
      */
-    suspend fun searchEvents(query: String): List<EventInstance>
+    suspend fun searchEvents(query: String): List<SearchCandidate>
 
     /**
      * The event-colour palette a calendar's account publishes; empty when it

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
+import android.util.Log
 import de.jeanlucmakiola.floret.time.toEpochMillis
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
@@ -9,6 +10,7 @@ import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import kotlinx.coroutines.CoroutineDispatcher
@@ -25,6 +27,7 @@ import kotlinx.coroutines.flow.merge
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.withContext
 import java.util.concurrent.atomic.AtomicLong
 import kotlin.time.Instant
@@ -162,13 +165,13 @@ class CalendarRepositoryImpl @Inject constructor(
             ?: throw NoSuchEventException(eventId)
     }
 
-    override suspend fun searchEvents(query: String): List<EventInstance> = withContext(io) {
+    override suspend fun searchEvents(query: String): List<SearchCandidate> = withContext(io) {
         if (query.isBlank()) return@withContext emptyList()
         val excluded = prefs.hiddenCalendarIds.first() +
             prefs.pendingDisabledCalendarIds.first() +
             invisibleCalendarIds()
         dataSource.searchEvents(query)
-            .let { if (excluded.isEmpty()) it else it.filterNot { e -> e.calendarId in excluded } }
+            .let { if (excluded.isEmpty()) it else it.filterNot { c -> c.event.calendarId in excluded } }
     }
 
     override suspend fun eventColorPalette(calendarId: Long): List<EventColorOption> =
@@ -209,26 +212,43 @@ class CalendarRepositoryImpl @Inject constructor(
         }
 
     override suspend fun exportEvents(calendarIds: Set<Long>?) =
-        withContext(io) { dataSource.exportableEvents(calendarIds) }
+        withContext(io) { dataSource.exportableEvents(calendarIds, allDayReminderTimeMinutes()) }
 
     override suspend fun importEvents(
         targetCalendarId: Long,
         events: List<ParsedIcsEvent>,
     ): IcsImportSummary = withContext(io) {
         val existing = dataSource.existingUids(targetCalendarId)
+        // Both are per-calendar, not per-event: looking them up once keeps a
+        // thousand-event restore to two extra queries. The palette is the
+        // uncurated one — an imported colour is matched against every key the
+        // account accepts, not the subset the picker shows.
+        val palette = dataSource.publishedEventColors(targetCalendarId)
+        val allDayMinutes = allDayReminderTimeMinutes()
         var imported = 0
         var skipped = 0
+        var failed = 0
         for (event in events) {
             // A known UID means the event is already in this calendar — skip,
             // keeping a restore idempotent (no overwrite this pass).
             if (event.uid != null && event.uid in existing) {
                 skipped++
-            } else {
-                dataSource.insertImportedEvent(event, targetCalendarId)
+                continue
+            }
+            try {
+                dataSource.insertImportedEvent(event, targetCalendarId, allDayMinutes, palette)
                 imported++
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                // One event the provider won't take must not cost the user the
+                // rest of the file — foreign exports do carry rows it rejects
+                // outright (a malformed RRULE throws straight out of insert).
+                failed++
+                Log.w(TAG, "Skipped an unimportable event", e)
             }
         }
-        IcsImportSummary(imported = imported, skippedDuplicate = skipped)
+        IcsImportSummary(imported = imported, skippedDuplicate = skipped, failed = failed)
     }
 
     override suspend fun createEvent(form: EventForm): Long = withContext(io) {
@@ -287,6 +307,10 @@ class CalendarRepositoryImpl @Inject constructor(
     ) = withContext(io) {
         dataSource.deleteEventFromOccurrence(eventId, beginMillis)
     }
+
+    private companion object {
+        const val TAG = "CalendarRepository"
+    }
 }
 
 private fun <T> Flow<Unit>.reQuery(block: suspend () -> T): Flow<T> = flow {

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

@@ -125,6 +125,7 @@ internal fun ColumnReader.toEventDetailCore(
         selfStatus = mapAttendeeStatus(getInt(EventDetailProjection.IDX_SELF_ATTENDEE_STATUS)),
         eventColor = eventColor,
         eventColorKey = eventColorKey,
+        isException = !isNull(EventDetailProjection.IDX_ORIGINAL_ID),
     )
 }
 

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

@@ -3,13 +3,20 @@ package de.jeanlucmakiola.calendula.data.calendar
 import android.provider.CalendarContract
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
+import de.jeanlucmakiola.calendula.domain.nearestTo
 import kotlinx.datetime.toJavaLocalDate
 import kotlinx.datetime.toJavaLocalDateTime
 import java.time.Duration
 import java.time.Instant
 import java.time.ZoneId
 import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
+import java.time.format.ResolverStyle
+import java.time.LocalDate as JavaLocalDate
 import java.time.LocalDateTime as JavaLocalDateTime
 
 /** Provider-ready DTSTART / DTEND / EVENT_TIMEZONE for an event write. */
@@ -134,18 +141,21 @@ internal fun buildEventInsertValues(
  *
  * Time fields travel together (the provider validates them as a unit):
  * - unchanged times, all-day flag and rrule → no time columns at all;
- * - non-recurring result → DTSTART/DTEND, DURATION and RRULE cleared;
+ * - non-recurring result → DTSTART/DTEND, DURATION, RRULE and EXDATE cleared;
  * - recurring result → the *series* DTSTART moves by the same **wall-clock**
  *   shift the user applied to the displayed occurrence and is re-resolved in the
  *   event's zone ([seriesDtStartMillis] is the row's current DTSTART), DURATION
- *   replaces DTEND, RRULE is written. This keeps past occurrences intact when
- *   someone edits a later occurrence's time, and keeps the anchor's time-of-day
- *   stable across a DST boundary or a zone change between the two.
+ *   replaces DTEND, RRULE is written, and the row's exclusions
+ *   ([seriesExdate], the current EXDATE) travel with the anchor. This keeps past
+ *   occurrences intact when someone edits a later occurrence's time, and keeps
+ *   the anchor's time-of-day stable across a DST boundary or a zone change
+ *   between the two.
  */
 internal fun buildEventUpdateValues(
     original: EventForm,
     updated: EventForm,
     seriesDtStartMillis: Long,
+    seriesExdate: String?,
     zone: ZoneId,
 ): Map<String, Any?> = buildMap {
     if (updated.title.trim() != original.title.trim()) {
@@ -185,6 +195,10 @@ internal fun buildEventUpdateValues(
         put(CalendarContract.Events.DTEND, newTimes.dtEndMillis)
         put(CalendarContract.Events.RRULE, null)
         put(CalendarContract.Events.DURATION, null)
+        // The exclusions named occurrences of a series that no longer exists.
+        // Left behind they are dormant rather than harmless: adding a recurrence
+        // back later would punch the old holes into the new one.
+        put(CalendarContract.Events.EXDATE, null)
     } else {
         // Move the series anchor by the *wall-clock* shift the user applied to the
         // displayed occurrence, then re-resolve it in the event's (possibly new)
@@ -206,6 +220,14 @@ internal fun buildEventUpdateValues(
         put(CalendarContract.Events.DTEND, null)
         put(CalendarContract.Events.RRULE, updated.rrule)
         put(CalendarContract.Events.DURATION, newTimes.toRfc2445Duration(updated.isAllDay))
+        // An EXDATE stamp is an absolute instant, so it excludes an occurrence
+        // only while the series keeps generating one at exactly that instant. The
+        // anchor has just moved, so every occurrence regenerates elsewhere and a
+        // stamp left behind matches none of them — the occurrence the user deleted
+        // comes back. Move the stamps the same way the anchor moved.
+        shiftedExdate(seriesExdate, original, updated, zone)
+            ?.takeIf { it != seriesExdate }
+            ?.let { put(CalendarContract.Events.EXDATE, it) }
     }
 }
 
@@ -243,6 +265,21 @@ internal fun buildOccurrenceExceptionValues(
     putAll(eventColorColumns(form.colorKey, form.color))
 }
 
+/**
+ * The form as a **detached occurrence**: the same edited values, with the
+ * series rule dropped so [buildEventInsertValues] writes a standalone one-off
+ * row (DTSTART + DTEND, no RRULE/DURATION) at the occurrence's own times.
+ *
+ * The "edit only this event" shape for a series with **no `_sync_id`**, where an
+ * exception row can't attach to its parent at all (Codeberg #234).
+ *
+ * The exception path gets the rule dropped for free — the provider clears the
+ * RRULE it cloned when an exception carries DTSTART + DURATION
+ * ([buildOccurrenceExceptionValues]). Here nothing is cloned, so it is stripped
+ * by hand; leaving it on would insert a second *series* overlapping the first.
+ */
+internal fun EventForm.toDetachedOccurrence(): EventForm = copy(rrule = null)
+
 /**
  * Raw provider snapshot of a master/one-off Events row, enough to re-insert it
  * verbatim on another calendar (a calendar move is copy+delete — `CALENDAR_ID`
@@ -420,11 +457,7 @@ internal fun buildOccurrenceExdateValues(
     allDay: Int,
 ): Map<String, Any?> {
     val stamp = formatExdateStamp(occurrenceMillis, isAllDay = allDay != 0)
-    val existing = existingExdate?.split(',')
-        ?.map { it.trim() }
-        ?.filter { it.isNotEmpty() }
-        .orEmpty()
-    val merged = (existing + stamp).distinct().joinToString(",")
+    val merged = (exdateStamps(existingExdate) + stamp).distinct().joinToString(",")
     return mapOf(
         CalendarContract.Events.EXDATE to merged,
         CalendarContract.Events.DTSTART to dtStartMillis,
@@ -435,22 +468,139 @@ internal fun buildOccurrenceExdateValues(
     )
 }
 
+/**
+ * Whether [existingExdate] already excludes the occurrence at [occurrenceMillis]
+ * — i.e. it has already been dropped from the series, deleted or detached.
+ *
+ * Guards the detach path against running twice from a stale screen: the EXDATE
+ * merge folds the repeat away silently and the update still reports one row
+ * changed, so a second save would leave a second standalone copy.
+ */
+internal fun exdateContains(
+    existingExdate: String?,
+    occurrenceMillis: Long,
+    isAllDay: Boolean,
+): Boolean {
+    val stamp = formatExdateStamp(occurrenceMillis, isAllDay)
+    return existingExdate?.split(',')?.any { it.trim() == stamp } == true
+}
+
+/**
+ * [existingExdate] with every stamp re-timed by the same **wall-clock** shift the
+ * series anchor takes from [original] to [updated] — the exclusions' half of the
+ * anchor move [buildEventUpdateValues] performs, and what carries them onto the
+ * new series when "this and following" splits one.
+ *
+ * A stamp is an absolute instant, so it keeps naming its occurrence only if it
+ * moves exactly as the occurrence does: shifted in wall clock and re-resolved in
+ * the event's (possibly new) zone. A millisecond delta would instead bake in the
+ * offset that happened to apply at the edited occurrence — an hour off for any
+ * exclusion on the far side of a DST boundary. All-day-ness is read from
+ * [original] and written from [updated], so the `VALUE=DATE` and date-time forms
+ * convert into each other when the event switches.
+ *
+ * Null when there is nothing to carry: no stamps, or a stamp in a form Calendula
+ * never writes (a `TZID=`-parameterised or floating one from a sync adapter). Those
+ * are left exactly as they are rather than guessed at — a stale stamp excludes
+ * nothing, but a mangled one could exclude the wrong occurrence.
+ */
+internal fun shiftedExdate(
+    existingExdate: String?,
+    original: EventForm,
+    updated: EventForm,
+    zone: ZoneId,
+): String? {
+    val stamps = exdateStamps(existingExdate)
+    if (stamps.isEmpty()) return null
+    val fromZone = original.writeZone(zone)
+    val toZone = updated.writeZone(zone)
+    val wallClockShift = Duration.between(original.anchorLocal(), updated.anchorLocal())
+    return stamps
+        .map { stamp ->
+            val local = parseExdateStamp(stamp, original.isAllDay, fromZone) ?: return null
+            formatExdateStamp(local.plus(wallClockShift), updated.isAllDay, toZone)
+        }
+        .distinct()
+        .joinToString(",")
+}
+
+/**
+ * The stamps of [existingExdate] naming occurrences after [beginMillis] — the ones
+ * that belong to the *new* series once "this and following" splits a recurring
+ * event there. The parent keeps the full list; its stamps past the split point are
+ * simply inert once it stops generating those occurrences.
+ *
+ * The occurrence at [beginMillis] itself is never carried. It is the one the user
+ * is editing, so it exists by definition, and honouring a stale exclusion for it
+ * would swallow the edit whole.
+ *
+ * Null when nothing qualifies, or when a stamp can't be read (see [shiftedExdate]).
+ */
+internal fun exdateAfter(existingExdate: String?, beginMillis: Long, isAllDay: Boolean): String? {
+    val stamps = exdateStamps(existingExdate)
+    if (stamps.isEmpty()) return null
+    return stamps
+        .filter { stamp ->
+            val utc = parseExdateStamp(stamp, isAllDay, ZoneOffset.UTC) ?: return null
+            utc.toInstant(ZoneOffset.UTC).toEpochMilli() > beginMillis
+        }
+        .takeIf { it.isNotEmpty() }
+        ?.joinToString(",")
+}
+
+/** The individual stamps of an EXDATE column value; it is a comma-separated list. */
+private fun exdateStamps(exdate: String?): List<String> = exdate
+    ?.split(',')
+    ?.map { it.trim() }
+    ?.filter { it.isNotEmpty() }
+    .orEmpty()
+
 /**
  * One EXDATE entry for the occurrence starting at [occurrenceMillis]. Both forms
  * are UTC: the provider stores an all-day DTSTART at UTC midnight, so its date
  * reads off the UTC calendar day.
  */
-private fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String {
-    val utc = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC)
-    return if (isAllDay) {
-        "%04d%02d%02d".format(utc.year, utc.monthValue, utc.dayOfMonth)
-    } else {
-        "%04d%02d%02dT%02d%02d%02dZ".format(
-            utc.year, utc.monthValue, utc.dayOfMonth,
-            utc.hour, utc.minute, utc.second,
+private fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String =
+    formatExdateStamp(
+        local = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC).toLocalDateTime(),
+        isAllDay = isAllDay,
+        zone = ZoneOffset.UTC,
     )
+
+/**
+ * One EXDATE entry for the occurrence whose wall clock in [zone] is [local]. An
+ * all-day entry keeps only the date (its time-of-day is the anchor's, not the
+ * occurrence's); a timed one is resolved in [zone] and written as a UTC instant.
+ */
+private fun formatExdateStamp(local: JavaLocalDateTime, isAllDay: Boolean, zone: ZoneId): String =
+    if (isAllDay) {
+        local.toLocalDate().format(ALL_DAY_EXDATE)
+    } else {
+        local.atZone(zone).withZoneSameInstant(ZoneOffset.UTC).format(TIMED_EXDATE)
     }
-}
+
+/**
+ * [stamp] as the wall clock it names in [zone] — the inverse of
+ * [formatExdateStamp]. Null for anything but the two forms Calendula writes, so a
+ * caller can tell "not ours, leave it alone" from a value it may safely re-time.
+ */
+private fun parseExdateStamp(stamp: String, isAllDay: Boolean, zone: ZoneId): JavaLocalDateTime? =
+    runCatching {
+        if (isAllDay) {
+            JavaLocalDate.parse(stamp, ALL_DAY_EXDATE).atStartOfDay()
+        } else {
+            JavaLocalDateTime.parse(stamp, TIMED_EXDATE)
+                .atZone(ZoneOffset.UTC).withZoneSameInstant(zone).toLocalDateTime()
+        }
+    }.getOrNull()
+
+/** `VALUE=DATE` EXDATE form, for an all-day series. */
+private val ALL_DAY_EXDATE: DateTimeFormatter =
+    DateTimeFormatter.ofPattern("uuuuMMdd").withResolverStyle(ResolverStyle.STRICT)
+
+/** UTC date-time EXDATE form, for a timed series. */
+private val TIMED_EXDATE: DateTimeFormatter =
+    DateTimeFormatter.ofPattern("uuuuMMdd'T'HHmmss'Z'").withResolverStyle(ResolverStyle.STRICT)
 
 /**
  * The `EVENT_COLOR` / `EVENT_COLOR_KEY` columns for a colour selection. A
@@ -499,3 +649,73 @@ internal fun AccessLevel.toProviderValue(): Int = when (this) {
     AccessLevel.Private -> CalendarContract.Events.ACCESS_PRIVATE
     AccessLevel.Public -> CalendarContract.Events.ACCESS_PUBLIC
 }
+
+/**
+ * The `Events` row for a `.ics` event being imported into [calendarId].
+ *
+ * A recurring row carries RRULE + DURATION (and any EXDATE) with no DTEND; a
+ * one-off carries DTEND. All-day rows live at UTC midnights, exactly as the
+ * parser hands them over.
+ *
+ * [palette] is the target account's published event colours. A calendar that
+ * publishes one rejects a raw `EVENT_COLOR`, so an imported colour — which is
+ * an arbitrary ARGB from a foreign app — is snapped to the nearest key it does
+ * accept; accounts with no palette take the raw value (see [eventColorColumns]).
+ */
+internal fun buildImportedEventValues(
+    event: ParsedIcsEvent,
+    calendarId: Long,
+    uid: String,
+    palette: List<EventColorOption>,
+): Map<String, Any?> = buildMap {
+    val startMillis = event.start.toEpochMilliseconds()
+    val endMillis = event.end.toEpochMilliseconds()
+    put(CalendarContract.Events.CALENDAR_ID, calendarId)
+    put(CalendarContract.Events.UID_2445, uid)
+    put(CalendarContract.Events.TITLE, event.summary.trim())
+    put(CalendarContract.Events.ALL_DAY, if (event.isAllDay) 1 else 0)
+    put(CalendarContract.Events.DTSTART, startMillis)
+    if (event.recurrenceRule == null) {
+        put(CalendarContract.Events.DTEND, endMillis)
+    } else {
+        put(CalendarContract.Events.RRULE, event.recurrenceRule)
+        put(
+            CalendarContract.Events.DURATION,
+            importDuration(startMillis, endMillis, event.isAllDay),
+        )
+        event.exDates.takeIf { it.isNotEmpty() }
+            ?.let { put(CalendarContract.Events.EXDATE, it.joinToString(",")) }
+    }
+    // All-day rows live at UTC midnights (the file already encodes them so);
+    // timed rows keep the event's own zone.
+    put(CalendarContract.Events.EVENT_TIMEZONE, if (event.isAllDay) "UTC" else event.zoneId)
+    put(CalendarContract.Events.AVAILABILITY, event.availability.toProviderValue())
+    put(CalendarContract.Events.STATUS, event.status.toProviderStatus())
+    event.location?.trim()?.takeIf { it.isNotEmpty() }
+        ?.let { put(CalendarContract.Events.EVENT_LOCATION, it) }
+    event.description?.trim()?.takeIf { it.isNotEmpty() }
+        ?.let { put(CalendarContract.Events.DESCRIPTION, it) }
+    event.color?.let { color ->
+        val key = palette.nearestTo(color)?.key
+        putAll(eventColorColumns(colorKey = key, color = if (key == null) color else null))
+    }
+}
+
+/**
+ * Provider `DURATION` for an imported recurring row: whole days for an all-day
+ * series, seconds otherwise. An all-day series is never shorter than a day —
+ * the provider expands a zero-length one into no instances at all, so the
+ * series would vanish (which is what a literal read of the Fossify family's
+ * inclusive DTEND used to produce; see "Importing foreign .ics" in
+ * docs/ARCHITECTURE.md).
+ */
+private fun importDuration(startMillis: Long, endMillis: Long, isAllDay: Boolean): String {
+    val span = (endMillis - startMillis).coerceAtLeast(0)
+    return if (isAllDay) "P${(span / 86_400_000L).coerceAtLeast(1)}D" else "P${span / 1_000L}S"
+}
+
+private fun EventStatus.toProviderStatus(): Int = when (this) {
+    EventStatus.Confirmed -> CalendarContract.Events.STATUS_CONFIRMED
+    EventStatus.Tentative -> CalendarContract.Events.STATUS_TENTATIVE
+    EventStatus.Cancelled -> CalendarContract.Events.STATUS_CANCELED
+}

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

@@ -5,6 +5,9 @@ import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.deriveIcsUid
 import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
+import java.time.Instant
+import java.time.ZoneId
+import java.time.ZoneOffset
 
 /**
  * Map one Events row (read through [EventExportProjection]) into an [IcsEvent]
@@ -12,14 +15,23 @@ import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
  * [calendarName] the display name of its calendar (emitted as
  * `X-CALENDULA-CALENDAR`). Pure given a [ColumnReader] — JVM-tested with
  * MapColumnReader.
+ *
+ * An all-day row's raw offset has the firing time of day encoded into it and is
+ * normally *negative* (see [AllDayReminderEncoding]); written out literally it
+ * would be dropped as a trigger that fires after the event, losing the reminder.
+ * [allDayReminderTimeMinutes] and [zone] decode it back to the whole-day lead
+ * time the file should carry, which an import re-encodes for its own device.
  */
 internal fun ColumnReader.toIcsEvent(
     reminderMinutes: List<Int>,
     calendarName: String?,
+    allDayReminderTimeMinutes: Int,
+    zone: ZoneId = ZoneId.systemDefault(),
 ): IcsEvent {
     val eventId = getLong(EventExportProjection.IDX_ID)
     val dtStart = getLong(EventExportProjection.IDX_DTSTART)
     val rrule = getString(EventExportProjection.IDX_RRULE)?.takeIf { it.isNotBlank() }
+    val isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0
 
     // Recurring rows store DURATION instead of DTEND; reconstruct the end from it
     // so the writer can render DTEND. A missing/blank both means a zero-length event.
@@ -40,16 +52,44 @@ internal fun ColumnReader.toIcsEvent(
         summary = getString(EventExportProjection.IDX_TITLE).orEmpty(),
         start = dtStart.toKotlinInstantFromEpochMillis(),
         end = end.toKotlinInstantFromEpochMillis(),
-        isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0,
+        isAllDay = isAllDay,
         zoneId = getString(EventExportProjection.IDX_EVENT_TIMEZONE)?.takeIf { it.isNotBlank() }
             ?: "UTC",
         recurrenceRule = rrule,
+        exDates = if (rrule == null) {
+            emptyList()
+        } else {
+            exportExDates(getString(EventExportProjection.IDX_EXDATE), isAllDay)
+        },
         location = getString(EventExportProjection.IDX_LOCATION),
         description = getString(EventExportProjection.IDX_DESCRIPTION),
-        reminderMinutes = reminderMinutes,
+        reminderMinutes = if (isAllDay) {
+            val startDate = Instant.ofEpochMilli(dtStart).atZone(ZoneOffset.UTC).toLocalDate()
+            reminderMinutes.map {
+                fromProviderAllDayMinutes(it, startDate, zone, allDayReminderTimeMinutes)
+            }
+        } else {
+            reminderMinutes
+        },
         status = status,
         availability = mapAvailability(getInt(EventExportProjection.IDX_AVAILABILITY)),
         calendarName = calendarName,
     )
 }
 
+/**
+ * The row's `EXDATE` as the writer wants it: one stamp per entry, empties
+ * dropped.
+ *
+ * An all-day exclusion names a calendar day, and sync adapters are inconsistent
+ * about whether they write it as a bare `yyyyMMdd` or pad it to a midnight
+ * stamp; the time part is dropped so the exported value is the day either way.
+ * Calendula's own writes ([buildOccurrenceExdateValues]) are already bare.
+ */
+internal fun exportExDates(exdate: String?, isAllDay: Boolean): List<String> = exdate
+    ?.split(',')
+    ?.map { it.trim() }
+    ?.filter { it.isNotEmpty() }
+    ?.map { if (isAllDay) it.substringBefore('T') else it }
+    ?.distinct()
+    .orEmpty()

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

@@ -1,6 +1,7 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
+import android.provider.CalendarContract
 import android.util.Log
 import de.jeanlucmakiola.calendula.domain.EventInstance
 
@@ -38,5 +39,7 @@ internal fun ColumnReader.toEventInstance(): EventInstance? {
         isAllDay = getInt(InstanceProjection.IDX_ALL_DAY) != 0,
         color = color,
         location = getString(InstanceProjection.IDX_LOCATION),
+        isDeclined = getInt(InstanceProjection.IDX_SELF_ATTENDEE_STATUS) ==
+            CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED,
     )
 }

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

@@ -52,6 +52,7 @@ internal object InstanceProjection {
         CalendarContract.Instances.EVENT_COLOR,
         CalendarContract.Instances.CALENDAR_COLOR,
         CalendarContract.Instances.EVENT_LOCATION,
+        CalendarContract.Instances.SELF_ATTENDEE_STATUS,
     )
 
     const val IDX_INSTANCE_ID = 0
@@ -64,6 +65,7 @@ internal object InstanceProjection {
     const val IDX_EVENT_COLOR = 7
     const val IDX_CALENDAR_COLOR = 8
     const val IDX_LOCATION = 9
+    const val IDX_SELF_ATTENDEE_STATUS = 10
 }
 
 internal object EventDetailProjection {
@@ -89,6 +91,9 @@ internal object EventDetailProjection {
         // Recurring rows carry DURATION instead of DTEND; the detail screen
         // needs it to render a series opened without a named occurrence.
         CalendarContract.Events.DURATION,
+        // Non-null on a modified-occurrence exception row; "no RRULE" alone
+        // can't tell an exception from a master (#68).
+        CalendarContract.Events.ORIGINAL_ID,
     )
 
     const val IDX_EVENT_ID = 0
@@ -110,15 +115,18 @@ internal object EventDetailProjection {
     const val IDX_SELF_ATTENDEE_STATUS = 16
     const val IDX_EVENT_COLOR_KEY = 17
     const val IDX_DURATION = 18
+    const val IDX_ORIGINAL_ID = 19
 }
 
 /**
  * Master/one-off Events rows for a whole-calendar backup. Unlike
  * [EventDetailProjection] this reads `UID_2445` (to keep a row's identity across
- * backups) and `DURATION` (recurring rows carry it instead of DTEND). Modified-
+ * backups) and `DURATION` (recurring rows carry it instead of DTEND), plus
+ * `EXDATE` so a series exports the occurrences deleted from it. Modified-
  * occurrence and cancelled-exception rows are filtered out by the query
- * (`ORIGINAL_ID IS NULL`), so RECURRENCE-ID overrides and EXDATEs aren't
- * exported yet — a documented v1 limit (import skips them too).
+ * (`ORIGINAL_ID IS NULL`), so RECURRENCE-ID overrides aren't exported — a
+ * documented v1 limit (import skips them too). EXDATE is unaffected by that
+ * filter: it lives on the master row, not on an exception of its own.
  */
 internal object EventExportProjection {
     val COLUMNS: Array<String> = arrayOf(
@@ -131,6 +139,7 @@ internal object EventExportProjection {
         CalendarContract.Events.ALL_DAY,
         CalendarContract.Events.EVENT_TIMEZONE,
         CalendarContract.Events.RRULE,
+        CalendarContract.Events.EXDATE,
         CalendarContract.Events.EVENT_LOCATION,
         CalendarContract.Events.DESCRIPTION,
         CalendarContract.Events.STATUS,
@@ -147,11 +156,12 @@ internal object EventExportProjection {
     const val IDX_ALL_DAY = 6
     const val IDX_EVENT_TIMEZONE = 7
     const val IDX_RRULE = 8
-    const val IDX_LOCATION = 9
-    const val IDX_DESCRIPTION = 10
-    const val IDX_STATUS = 11
-    const val IDX_AVAILABILITY = 12
-    const val IDX_CALENDAR_ID = 13
+    const val IDX_EXDATE = 9
+    const val IDX_LOCATION = 10
+    const val IDX_DESCRIPTION = 11
+    const val IDX_STATUS = 12
+    const val IDX_AVAILABILITY = 13
+    const val IDX_CALENDAR_ID = 14
 }
 
 /**
@@ -176,6 +186,9 @@ internal object SearchProjection {
         // display its nearest occurrence, not the series-start DTSTART.
         CalendarContract.Events.RRULE,
         CalendarContract.Events.RDATE,
+        // Excerpted, not just filtered on: a hit has to show what it matched.
+        CalendarContract.Events.DESCRIPTION,
+        CalendarContract.Events.SELF_ATTENDEE_STATUS,
     )
 
     const val IDX_ID = 0
@@ -190,6 +203,8 @@ internal object SearchProjection {
     const val IDX_LOCATION = 9
     const val IDX_RRULE = 10
     const val IDX_RDATE = 11
+    const val IDX_DESCRIPTION = 12
+    const val IDX_SELF_ATTENDEE_STATUS = 13
 }
 
 /**

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
+import android.provider.CalendarContract
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
@@ -40,5 +41,9 @@ internal fun ColumnReader.toSearchResult(): EventInstance? {
         isAllDay = getInt(SearchProjection.IDX_ALL_DAY) != 0,
         color = color,
         location = getString(SearchProjection.IDX_LOCATION),
+        isRecurring = !getString(SearchProjection.IDX_RRULE).isNullOrEmpty() ||
+            !getString(SearchProjection.IDX_RDATE).isNullOrEmpty(),
+        isDeclined = getInt(SearchProjection.IDX_SELF_ATTENDEE_STATUS) ==
+            CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED,
     )
 }

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

@@ -301,6 +301,19 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[TODAY_BUTTON_IN_TOOLBAR_KEY] = enabled }
     }
 
+    /**
+     * Whether events can be dragged to another slot in the calendar views (#68,
+     * #173). Defaults to ON. Off means no block registers a drag gesture at all;
+     * rescheduling then goes through the edit form.
+     */
+    val dragToReschedule: Flow<Boolean> = store.data.map { prefs ->
+        prefs[DRAG_TO_RESCHEDULE_KEY] ?: true
+    }
+
+    suspend fun setDragToReschedule(enabled: Boolean) {
+        store.edit { it[DRAG_TO_RESCHEDULE_KEY] = enabled }
+    }
+
     /**
      * How far ahead the in-app Agenda screen shows events (v2.11). Defaults to
      * [AgendaRange.Month] — a month of upcoming events. Independent of the
@@ -550,8 +563,87 @@ class SettingsPrefs @Inject constructor(
         prefs[REMINDER_ONBOARDING_KEY] ?: false
     }
 
-    suspend fun setReminderOnboardingDone() {
-        store.edit { it[REMINDER_ONBOARDING_KEY] = true }
+    /** Cleared, not just set: the wizard's back button re-asks a step (#163). */
+    suspend fun setReminderOnboardingDone(done: Boolean = true) {
+        store.edit { it[REMINDER_ONBOARDING_KEY] = done }
+    }
+
+    /**
+     * Whether this install is a fresh one still owing the wizard's optional
+     * steps (#163). Armed on any launch that holds the calendar permission and
+     * has not finished the reminder step, and cleared again by
+     * [finishOnboardingWizard], so an existing user who revokes and re-grants
+     * the permission isn't re-onboarded.
+     */
+    val onboardingWizardArmed: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_WIZARD_ARMED_KEY] ?: false
+    }
+
+    suspend fun armOnboardingWizard() {
+        store.edit { prefs ->
+            if (prefs[REMINDER_ONBOARDING_KEY] != true) prefs[ONBOARDING_WIZARD_ARMED_KEY] = true
+        }
+    }
+
+    /** Whether the wizard's backup step has been answered (or skipped). */
+    val onboardingBackupDone: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_BACKUP_KEY] ?: false
+    }
+
+    suspend fun setOnboardingBackupDone(done: Boolean = true) {
+        store.edit { it[ONBOARDING_BACKUP_KEY] = done }
+    }
+
+    /** Whether the wizard's default-view step has been answered (or skipped). */
+    val onboardingViewDone: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_VIEW_KEY] ?: false
+    }
+
+    suspend fun setOnboardingViewDone(done: Boolean = true) {
+        store.edit { it[ONBOARDING_VIEW_KEY] = done }
+    }
+
+    /** Whether the wizard's month-style step has been answered (or skipped). */
+    val onboardingMonthStyleDone: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_MONTH_STYLE_KEY] ?: false
+    }
+
+    suspend fun setOnboardingMonthStyleDone(done: Boolean = true) {
+        store.edit { it[ONBOARDING_MONTH_STYLE_KEY] = done }
+    }
+
+    /**
+     * Whether the wizard's calendar-visibility notice has been read. Separate
+     * from [CalendarPrefs.visibilityNoticePending], which says whether this
+     * install has anything to announce at all.
+     */
+    val onboardingVisibilityDone: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_VISIBILITY_KEY] ?: false
+    }
+
+    suspend fun setOnboardingVisibilityDone(done: Boolean = true) {
+        store.edit { it[ONBOARDING_VISIBILITY_KEY] = done }
+    }
+
+    /** Whether the wizard's closing screen has been seen. */
+    val onboardingDoneShown: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ONBOARDING_DONE_KEY] ?: false
+    }
+
+    suspend fun setOnboardingDoneShown(shown: Boolean = true) {
+        store.edit { it[ONBOARDING_DONE_KEY] = shown }
+    }
+
+    /**
+     * Close the wizard for good: the closing screen has been seen and the
+     * install stops counting as fresh, so a later revoke-and-re-grant is only
+     * the permission screen. One edit, so the plan can't see it half-closed.
+     */
+    suspend fun finishOnboardingWizard() {
+        store.edit { prefs ->
+            prefs[ONBOARDING_DONE_KEY] = true
+            prefs[ONBOARDING_WIZARD_ARMED_KEY] = false
+        }
     }
 
     /**
@@ -866,6 +958,7 @@ class SettingsPrefs @Inject constructor(
         internal val MONTH_VIEW_STYLE_KEY = stringPreferencesKey("month_view_style")
         internal val TIMELINE_SCALE_KEY = stringPreferencesKey("timeline_scale")
         internal val TODAY_BUTTON_IN_TOOLBAR_KEY = booleanPreferencesKey("today_button_in_toolbar")
+        internal val DRAG_TO_RESCHEDULE_KEY = booleanPreferencesKey("drag_to_reschedule")
         internal val DEFAULT_VIEW_KEY = stringPreferencesKey("default_view")
         internal val QUICK_SWITCH_VIEWS_KEY = stringPreferencesKey("quick_switch_views")
         internal val DRAWER_VIEW_ORDER_KEY = stringPreferencesKey("drawer_view_order")
@@ -882,6 +975,14 @@ class SettingsPrefs @Inject constructor(
         internal const val MAX_EVENT_DURATION = 1_440
         internal val REMINDERS_ENABLED_KEY = booleanPreferencesKey("reminders_enabled")
         internal val REMINDER_ONBOARDING_KEY = booleanPreferencesKey("reminder_onboarding_done")
+        internal val ONBOARDING_WIZARD_ARMED_KEY = booleanPreferencesKey("onboarding_wizard_armed")
+        internal val ONBOARDING_BACKUP_KEY = booleanPreferencesKey("onboarding_backup_done")
+        internal val ONBOARDING_VIEW_KEY = booleanPreferencesKey("onboarding_view_done")
+        internal val ONBOARDING_MONTH_STYLE_KEY =
+            booleanPreferencesKey("onboarding_month_style_done")
+        internal val ONBOARDING_VISIBILITY_KEY =
+            booleanPreferencesKey("onboarding_visibility_done")
+        internal val ONBOARDING_DONE_KEY = booleanPreferencesKey("onboarding_done_shown")
         internal val ALLOW_COLOR_UNSUPPORTED_KEY =
             booleanPreferencesKey("allow_color_unsupported_calendars")
         internal val DEFAULT_REMINDER_KEY = stringPreferencesKey("default_reminder_minutes")

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

@@ -44,9 +44,16 @@ class ProviderReminderInstanceSource @Inject constructor(
         // `visible` is the flag the app's one visibility model writes (#75).
         // The status clause mirrors CalendarDataSource.instances: NULL means
         // "normal", so a bare `!= CANCELED` would drop every ordinary event.
+        // An invitation the user declined is answered — it stays on the calendar
+        // struck through, but it plans nothing (#180). NULL again means "no
+        // answer recorded", which is not a "no".
         val selection = "${CalendarContract.Calendars.VISIBLE} = 1 AND " +
             "(${CalendarContract.Instances.STATUS} IS NULL OR " +
-            "${CalendarContract.Instances.STATUS} != ${CalendarContract.Events.STATUS_CANCELED})"
+            "${CalendarContract.Instances.STATUS} != " +
+            "${CalendarContract.Events.STATUS_CANCELED}) AND " +
+            "(${CalendarContract.Instances.SELF_ATTENDEE_STATUS} IS NULL OR " +
+            "${CalendarContract.Instances.SELF_ATTENDEE_STATUS} != " +
+            "${CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED})"
         return context.contentResolver.query(
             uri, OCCURRENCE_PROJECTION, selection, null, null,
         )?.use { c ->

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

@@ -44,6 +44,14 @@ val CalendarSource.hasVisibilitySwitch: Boolean
 val CalendarSource.isEventTarget: Boolean
     get() = canModifyContents && isVisibleInSystem && !isManaged && !isNotSynced
 
+/**
+ * Whether this calendar's events may have their times rewritten by a drag (#68).
+ * Deliberately not [isEventTarget]: a managed event stays editable (reminders,
+ * notes) yet must never move, since the next contacts sync would put it back.
+ */
+val CalendarSource.allowsEventMove: Boolean
+    get() = canModifyContents && !isManaged
+
 /** Every state worth naming on this calendar's row, in reading order. */
 fun CalendarSource.stateLabels(): List<CalendarStateLabel> = buildList {
     if (isManaged) add(CalendarStateLabel.MANAGED)

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

@@ -110,3 +110,17 @@ private const val CURATION_TRIGGER_SIZE = 36
  * apart that two swatches never read as the same colour in the grid.
  */
 private const val MIN_DISTANCE = 0.025f
+
+/**
+ * The palette entry closest to [argb], or null when the account publishes no
+ * palette (its calendars then take a raw `EVENT_COLOR` instead).
+ *
+ * Used to land a colour that came from outside the account — an imported `.ics`
+ * carries an arbitrary ARGB, while a palette calendar only accepts one of its
+ * own keys. Distance is measured in Oklab, so the match is the one that looks
+ * closest rather than the one that is closest in RGB coordinates.
+ */
+fun List<EventColorOption>.nearestTo(argb: Int): EventColorOption? {
+    val target = oklchOf(argb)
+    return minByOrNull { oklchOf(it.argb).distanceTo(target) }
+}

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

@@ -0,0 +1,256 @@
+package de.jeanlucmakiola.calendula.domain
+
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.number
+import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
+
+/** An event with the free text the search may have matched it on. */
+data class SearchCandidate(
+    val event: EventInstance,
+    val description: String? = null,
+    /** Null when the event has none: [EventInstance.title] is then a display
+     *  placeholder, which the query must not catch on. */
+    val title: String? = event.title,
+)
+
+/** A matched run inside one of a hit's texts, for highlighting. */
+data class MatchSpan(val start: Int, val end: Int)
+
+/** The part of a description a token matched, elided to what fits a row. */
+data class DescriptionSnippet(
+    val text: String,
+    val spans: List<MatchSpan>,
+)
+
+/** One result: the event, plus where the query matched it. */
+data class SearchHit(
+    val event: EventInstance,
+    val titleSpans: List<MatchSpan> = emptyList(),
+    val locationSpans: List<MatchSpan> = emptyList(),
+    val descriptionSnippet: DescriptionSnippet? = null,
+    /** Already over, so the row can say so. Finished-today counts. */
+    val isPast: Boolean = false,
+)
+
+/** One month's worth of hits, as the results list draws them under a header. */
+data class SearchMonth(
+    val year: Int,
+    /** 1–12, so the UI can build the month's first day for a localized label. */
+    val monthNumber: Int,
+    val hits: List<SearchHit>,
+)
+
+/** A finished search: a calendar of hits, plus the description-only ones. */
+data class SearchResults(
+    val months: List<SearchMonth>,
+    val inDescriptions: List<SearchHit>,
+) {
+    val isEmpty: Boolean get() = months.isEmpty() && inDescriptions.isEmpty()
+
+    /** Every hit, whichever section it sits in — for select-all and delete. */
+    val allHits: List<SearchHit> get() = months.flatMap { it.hits } + inDescriptions
+}
+
+/**
+ * Turning a typed query into the results list.
+ *
+ * An event has to carry *every* whitespace-separated token, each in any of
+ * title / location / description; case is folded in Kotlin rather than by SQL's
+ * ASCII-only `LIKE`, so "ärzte" finds "Ärzte".
+ *
+ * Results are a calendar, not a ranking: months from the current one, then
+ * forwards, then backwards, and inside a month what is still to come before
+ * what has passed. The day is the boundary, not the moment. A hit the query
+ * only reached through its description is held back in
+ * [SearchResults.inDescriptions] rather than dated among the real ones.
+ */
+object EventSearch {
+
+    /** Characters of description kept around the match in a row's snippet. */
+    private const val SNIPPET_LENGTH = 96
+
+    /** Characters of lead-in shown before the match, when there is room. */
+    private const val SNIPPET_LEAD = 24
+
+    private val WHITESPACE = Regex("\\s+")
+
+    /** Shared with the data layer so its SQL pre-filter tokenises identically. */
+    fun tokenize(query: String): List<String> =
+        query.trim().split(WHITESPACE).filter { it.isNotEmpty() }
+
+    /**
+     * Search [candidates] for [query], dropping any that don't carry every token.
+     * [now] marks a hit as over, [todayStart] is where it stops being current.
+     * [zone] places each event on the calendar through the span rule, so an
+     * all-day event keeps its own day whichever side of UTC we are on (#82).
+     */
+    fun search(
+        candidates: List<SearchCandidate>,
+        query: String,
+        now: Instant,
+        todayStart: Instant,
+        zone: TimeZone,
+    ): SearchResults {
+        val tokens = tokenize(query)
+        if (tokens.isEmpty()) return SearchResults(emptyList(), emptyList())
+
+        val today = todayStart.toLocalDateTime(zone).date
+        val matched = candidates.mapNotNull { candidate -> match(candidate, tokens, now, zone) }
+        val upcoming = { m: Matched -> m.event.spanLastDay(zone) >= today }
+        val order = compareBy<Matched> { if (upcoming(it)) 0 else 1 }
+            .thenComparator { a, b ->
+                // What is left reads forwards; what is behind us reads backwards
+                // from today, nearest first.
+                if (upcoming(a)) {
+                    a.event.dayStart(zone).compareTo(b.event.dayStart(zone))
+                } else {
+                    b.event.dayStart(zone).compareTo(a.event.dayStart(zone))
+                }
+            }
+
+        val (inDescriptions, dated) = matched.sortedWith(order).partition { it.descriptionOnly }
+        return SearchResults(
+            months = groupByMonth(dated, zone, todayStart),
+            inDescriptions = inDescriptions.map { it.hit },
+        )
+    }
+
+    /** Months from the current one, then forwards, then backwards. */
+    private fun groupByMonth(
+        dated: List<Matched>,
+        zone: TimeZone,
+        todayStart: Instant,
+    ): List<SearchMonth> {
+        val currentKey = monthKey(todayStart.toLocalDateTime(zone).date)
+        return dated
+            .groupBy { monthKey(it.event.spanFirstDay(zone)) }
+            .entries
+            .sortedWith(
+                compareBy<Map.Entry<Int, List<Matched>>> {
+                    when {
+                        it.key == currentKey -> 0
+                        it.key > currentKey -> 1
+                        else -> 2
+                    }
+                }.thenComparator { a, b ->
+                    if (a.key > currentKey) a.key.compareTo(b.key) else b.key.compareTo(a.key)
+                },
+            )
+            .map { (key, entries) ->
+                SearchMonth(
+                    year = key / 12,
+                    monthNumber = key % 12 + 1,
+                    hits = entries.map { it.hit },
+                )
+            }
+    }
+
+    /** Year and month as one comparable number. */
+    private fun monthKey(date: LocalDate): Int = date.year * 12 + (date.month.number - 1)
+
+    private fun match(
+        candidate: SearchCandidate,
+        tokens: List<String>,
+        now: Instant,
+        zone: TimeZone,
+    ): Matched? {
+        val title = candidate.title?.takeIf { it.isNotBlank() }
+        val location = candidate.event.location?.takeIf { it.isNotBlank() }
+        // Collapsed so a multi-line description matches the way it is drawn.
+        val description = candidate.description
+            ?.replace(WHITESPACE, " ")
+            ?.trim()
+            ?.takeIf { it.isNotEmpty() }
+
+        // Mid-word counts: "termin" has to keep finding "Zahnarzttermin".
+        val present = { token: String ->
+            title?.contains(token, ignoreCase = true) == true ||
+                location?.contains(token, ignoreCase = true) == true ||
+                description?.contains(token, ignoreCase = true) == true
+        }
+        if (!tokens.all(present)) return null
+
+        val descriptionSpans = description?.let { spansIn(it, tokens) }.orEmpty()
+        val titleSpans = title?.let { spansIn(it, tokens) }.orEmpty()
+        val locationSpans = location?.let { spansIn(it, tokens) }.orEmpty()
+        return Matched(
+            hit = SearchHit(
+                event = candidate.event,
+                titleSpans = titleSpans,
+                locationSpans = locationSpans,
+                descriptionSnippet = description
+                    ?.takeIf { descriptionSpans.isNotEmpty() }
+                    ?.let { snippet(it, descriptionSpans) },
+                isPast = candidate.event.dayEnd(zone) < now,
+            ),
+            // Nothing in the name or the place caught the query: it is only here
+            // for something in its notes.
+            descriptionOnly = titleSpans.isEmpty() && locationSpans.isEmpty(),
+        )
+    }
+
+    /** Every occurrence of every token in [text], merged where they overlap. */
+    private fun spansIn(text: String, tokens: List<String>): List<MatchSpan> {
+        val raw = mutableListOf<MatchSpan>()
+        for (token in tokens) {
+            var index = text.indexOf(token, startIndex = 0, ignoreCase = true)
+            while (index >= 0) {
+                raw += MatchSpan(index, index + token.length)
+                index = text.indexOf(token, startIndex = index + 1, ignoreCase = true)
+            }
+        }
+        if (raw.isEmpty()) return emptyList()
+        val sorted = raw.sortedBy { it.start }
+        val merged = mutableListOf(sorted.first())
+        for (span in sorted.drop(1)) {
+            val last = merged.last()
+            if (span.start <= last.end) {
+                merged[merged.lastIndex] = MatchSpan(last.start, maxOf(last.end, span.end))
+            } else {
+                merged += span
+            }
+        }
+        return merged
+    }
+
+    /**
+     * A window of [description] around its first match, elided at both ends,
+     * with the spans rebased onto it and any falling outside dropped.
+     */
+    private fun snippet(description: String, spans: List<MatchSpan>): DescriptionSnippet {
+        if (description.length <= SNIPPET_LENGTH) {
+            return DescriptionSnippet(description, spans)
+        }
+        val first = spans.first().start
+        val start = (first - SNIPPET_LEAD).coerceIn(0, (description.length - SNIPPET_LENGTH))
+        val end = (start + SNIPPET_LENGTH).coerceAtMost(description.length)
+        val prefix = if (start > 0) "…" else ""
+        val suffix = if (end < description.length) "…" else ""
+        val text = prefix + description.substring(start, end) + suffix
+        val shift = prefix.length - start
+        val rebased = spans
+            .filter { it.start >= start && it.end <= end }
+            .map { MatchSpan(it.start + shift, it.end + shift) }
+        return DescriptionSnippet(text, rebased)
+    }
+
+    private data class Matched(val hit: SearchHit, val descriptionOnly: Boolean) {
+        val event: EventInstance get() = hit.event
+    }
+
+    /**
+     * The event's first day as an instant in [zone]. An all-day event sits at
+     * UTC midnight, so its raw start would rank it on a day it isn't drawn on.
+     */
+    private fun EventInstance.dayStart(zone: TimeZone): Instant =
+        if (isAllDay) spanFirstDay(zone).atStartOfDayIn(zone) else start
+
+    /** The moment the event's last day is over in [zone], exclusive. */
+    private fun EventInstance.dayEnd(zone: TimeZone): Instant =
+        if (isAllDay) spanLastDay(zone).plus(1, DateTimeUnit.DAY).atStartOfDayIn(zone) else end
+}

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

@@ -0,0 +1,53 @@
+package de.jeanlucmakiola.calendula.domain
+
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
+
+/**
+ * The zone this form's wall-clock times mean, matching what the data layer
+ * resolves them in at write time: the form's own pinned zone, else [deviceZone].
+ */
+fun EventForm.resolvedZone(deviceZone: TimeZone): TimeZone =
+    timezone?.let { runCatching { TimeZone.of(it) }.getOrNull() } ?: deviceZone
+
+/**
+ * The form moved so it starts at [newStart], keeping its **instant** duration —
+ * a recurring event's length travels to the provider as `DURATION`, so keeping
+ * wall clock instead would rewrite the series' length across a DST boundary.
+ *
+ * All-day events are date-anchored — use [shiftedByDays]; this returns them
+ * untouched.
+ */
+fun EventForm.shiftedTo(newStart: Instant, deviceZone: TimeZone): EventForm {
+    if (isAllDay) return this
+    val zone = resolvedZone(deviceZone)
+    val span = end.toInstant(zone) - start.toInstant(zone)
+    return copy(
+        start = newStart.toLocalDateTime(zone),
+        end = (newStart + span).toLocalDateTime(zone),
+    )
+}
+
+/**
+ * The form moved [days] calendar days, keeping its time of day and its span.
+ * All-day events are pure date arithmetic; a timed one preserves its **instant**
+ * duration, for the same reason [shiftedTo] does.
+ */
+fun EventForm.shiftedByDays(days: Int, deviceZone: TimeZone): EventForm {
+    if (days == 0) return this
+    val newStart = LocalDateTime(start.date.plus(days, DateTimeUnit.DAY), start.time)
+    if (isAllDay) {
+        return copy(
+            start = newStart,
+            end = LocalDateTime(end.date.plus(days, DateTimeUnit.DAY), end.time),
+        )
+    }
+    val zone = resolvedZone(deviceZone)
+    val span = end.toInstant(zone) - start.toInstant(zone)
+    return copy(start = newStart, end = (newStart.toInstant(zone) + span).toLocalDateTime(zone))
+}

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

@@ -62,6 +62,18 @@ data class EventInstance(
     val isAllDay: Boolean,
     val color: Int,
     val location: String?,
+    /**
+     * Only search results, which read the series master, fill this in — the
+     * Instances query already yields one row per occurrence.
+     */
+    val isRecurring: Boolean = false,
+    /**
+     * This device user answered "no" to the invitation
+     * (`Events.SELF_ATTENDEE_STATUS`). The event stays on the calendar — it is
+     * still an appointment someone expects an answer about — but every surface
+     * strikes it through, and it plans no reminders (#180).
+     */
+    val isDeclined: Boolean = false,
 )
 
 /**
@@ -124,6 +136,12 @@ data class EventDetail(
     val eventColor: Int? = null,
     /** The event's `Events.EVENT_COLOR_KEY` (a calendar-palette key), or null. */
     val eventColorKey: String? = null,
+    /**
+     * True when this row is a modified occurrence of a series (`ORIGINAL_ID` is
+     * set) rather than a master, so a reschedule takes the plain whole-row path
+     * whatever [rrule] a sync adapter left on it.
+     */
+    val isException: Boolean = false,
 )
 
 /**

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

@@ -138,7 +138,7 @@ fun SimpleRecurrence.toRRule(zone: TimeZone = TimeZone.currentSystemDefault()):
     }
 }
 
-private val RRULE_DAY_CODES: Map<DayOfWeek, String> = mapOf(
+internal val RRULE_DAY_CODES: Map<DayOfWeek, String> = mapOf(
     DayOfWeek.MONDAY to "MO",
     DayOfWeek.TUESDAY to "TU",
     DayOfWeek.WEDNESDAY to "WE",

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

@@ -0,0 +1,48 @@
+package de.jeanlucmakiola.calendula.domain
+
+import kotlinx.datetime.LocalDate
+
+/**
+ * [rrule] re-anchored from an occurrence on [oldStart] to one on [newStart].
+ *
+ * `Events.RRULE` is written verbatim while DTSTART moves, so `FREQ=WEEKLY;BYDAY=MO`
+ * would keep naming Monday after the anchor became a Wednesday and the series
+ * would not move at all — `BYDAY` is re-derived from [newStart].
+ *
+ * Only weekly `BYDAY` is realigned, and only for a whole-day move: the rule has
+ * to agree with the series *anchor*, and weekday arithmetic is the only kind
+ * that survives the same wall-clock shift unchanged. Everything else returns
+ * null, as do rules one moved occurrence can't resolve (`BYDAY=MO,WE`, `2TH`,
+ * `BYSETPOS`). The accepted parts are a subset of [parseSimpleRecurrence], so
+ * anything realignable is also a rule [problems] can check the `UNTIL` of.
+ */
+fun realignRecurrence(rrule: String, oldStart: LocalDate, newStart: LocalDate): String? {
+    if (oldStart == newStart) return rrule
+    val prefix = if (rrule.startsWith("RRULE:")) "RRULE:" else ""
+    val parts = rrule.removePrefix("RRULE:").split(';').filter { it.isNotBlank() }
+    if (parts.isEmpty()) return null
+    var weekly = false
+    val rebuilt = parts.map { part ->
+        val eq = part.indexOf('=')
+        if (eq <= 0) return null
+        val key = part.substring(0, eq).uppercase()
+        val value = part.substring(eq + 1).trim()
+        when (key) {
+            "FREQ" -> {
+                weekly = value.equals("WEEKLY", ignoreCase = true)
+                part
+            }
+            "BYDAY" -> {
+                val old = RRULE_DAY_CODES[oldStart.dayOfWeek] ?: return null
+                if (!value.equals(old, ignoreCase = true)) return null
+                "BYDAY=${RRULE_DAY_CODES.getValue(newStart.dayOfWeek)}"
+            }
+            "INTERVAL", "COUNT", "UNTIL", "WKST" -> part
+            else -> return null
+        }
+    }
+    // BYDAY is only simple on a weekly rule, matching parseSimpleRecurrence.
+    if (!weekly && parts.any { it.substringBefore('=').trim().uppercase() == "BYDAY" }) return null
+    if (parts.none { it.substringBefore('=').trim().uppercase() == "FREQ" }) return null
+    return prefix + rebuilt.joinToString(";")
+}

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsColor.kt

@@ -0,0 +1,80 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+/** Opaque alpha, forced onto any colour that arrives without one. */
+private const val OPAQUE_ALPHA = 0xFF000000.toInt()
+
+/**
+ * Resolve a colour value out of a foreign `.ics` to an opaque ARGB int.
+ *
+ * Three encodings are in the wild and all appear in the files Calendula is
+ * asked to import:
+ *  - a CSS3 colour name, which is what RFC 7986 `COLOR` is defined as
+ *    (`COLOR:tomato`);
+ *  - a raw signed Android colour int, which the Simple Calendar / Fossify
+ *    family writes in its `X-…-COLOR` extensions (`X-FOSSIFY-EVENT-COLOR:-2818048`);
+ *  - `#rrggbb` / `#aarrggbb` hex, used by assorted other producers.
+ *
+ * Anything else — including the literal `null` Fossify emits when its calendar
+ * lookup misses — resolves to null.
+ */
+fun parseIcsColorValue(raw: String?): Int? {
+    val value = raw?.trim().orEmpty()
+    if (value.isEmpty()) return null
+
+    if (value.startsWith("#")) {
+        val hex = value.substring(1)
+        val parsed = hex.toLongOrNull(16)?.toInt() ?: return null
+        return when (hex.length) {
+            6 -> parsed or OPAQUE_ALPHA
+            8 -> parsed
+            else -> null
+        }
+    }
+    value.toIntOrNull()?.let { return if (it ushr 24 == 0) it or OPAQUE_ALPHA else it }
+    return cssColors[value.lowercase()]
+}
+
+/** The CSS3 extended colour keywords, the value space of RFC 7986 `COLOR`. */
+private val cssColors: Map<String, Int> by lazy {
+    CSS3_TABLE.split(' ').associate { entry ->
+        val name = entry.substringBefore('=')
+        name to (entry.substringAfter('=').toInt(16) or OPAQUE_ALPHA)
+    }
+}
+
+private const val CSS3_TABLE =
+        "aliceblue=f0f8ff antiquewhite=faebd7 aqua=00ffff aquamarine=7fffd4 " +
+        "azure=f0ffff beige=f5f5dc bisque=ffe4c4 black=000000 blanchedalmond=ffebcd " +
+        "blue=0000ff blueviolet=8a2be2 brown=a52a2a burlywood=deb887 cadetblue=5f9ea0 " +
+        "chartreuse=7fff00 chocolate=d2691e coral=ff7f50 cornflowerblue=6495ed " +
+        "cornsilk=fff8dc crimson=dc143c cyan=00ffff darkblue=00008b darkcyan=008b8b " +
+        "darkgoldenrod=b8860b darkgray=a9a9a9 darkgreen=006400 darkgrey=a9a9a9 " +
+        "darkkhaki=bdb76b darkmagenta=8b008b darkolivegreen=556b2f darkorange=ff8c00 " +
+        "darkorchid=9932cc darkred=8b0000 darksalmon=e9967a darkseagreen=8fbc8f " +
+        "darkslateblue=483d8b darkslategray=2f4f4f darkslategrey=2f4f4f darkturquoise=00ced1 " +
+        "darkviolet=9400d3 deeppink=ff1493 deepskyblue=00bfff dimgray=696969 " +
+        "dimgrey=696969 dodgerblue=1e90ff firebrick=b22222 floralwhite=fffaf0 " +
+        "forestgreen=228b22 fuchsia=ff00ff gainsboro=dcdcdc ghostwhite=f8f8ff " +
+        "gold=ffd700 goldenrod=daa520 gray=808080 green=008000 greenyellow=adff2f " +
+        "grey=808080 honeydew=f0fff0 hotpink=ff69b4 indianred=cd5c5c indigo=4b0082 " +
+        "ivory=fffff0 khaki=f0e68c lavender=e6e6fa lavenderblush=fff0f5 lawngreen=7cfc00 " +
+        "lemonchiffon=fffacd lightblue=add8e6 lightcoral=f08080 lightcyan=e0ffff " +
+        "lightgoldenrodyellow=fafad2 lightgray=d3d3d3 lightgreen=90ee90 lightgrey=d3d3d3 " +
+        "lightpink=ffb6c1 lightsalmon=ffa07a lightseagreen=20b2aa lightskyblue=87cefa " +
+        "lightslategray=778899 lightslategrey=778899 lightsteelblue=b0c4de " +
+        "lightyellow=ffffe0 lime=00ff00 limegreen=32cd32 linen=faf0e6 magenta=ff00ff " +
+        "maroon=800000 mediumaquamarine=66cdaa mediumblue=0000cd mediumorchid=ba55d3 " +
+        "mediumpurple=9370db mediumseagreen=3cb371 mediumslateblue=7b68ee " +
+        "mediumspringgreen=00fa9a mediumturquoise=48d1cc mediumvioletred=c71585 " +
+        "midnightblue=191970 mintcream=f5fffa mistyrose=ffe4e1 moccasin=ffe4b5 " +
+        "navajowhite=ffdead navy=000080 oldlace=fdf5e6 olive=808000 olivedrab=6b8e23 " +
+        "orange=ffa500 orangered=ff4500 orchid=da70d6 palegoldenrod=eee8aa " +
+        "palegreen=98fb98 paleturquoise=afeeee palevioletred=db7093 papayawhip=ffefd5 " +
+        "peachpuff=ffdab9 peru=cd853f pink=ffc0cb plum=dda0dd powderblue=b0e0e6 " +
+        "purple=800080 rebeccapurple=663399 red=ff0000 rosybrown=bc8f8f royalblue=4169e1 " +
+        "saddlebrown=8b4513 salmon=fa8072 sandybrown=f4a460 seagreen=2e8b57 " +
+        "seashell=fff5ee sienna=a0522d silver=c0c0c0 skyblue=87ceeb slateblue=6a5acd " +
+        "slategray=708090 slategrey=708090 snow=fffafa springgreen=00ff7f " +
+        "steelblue=4682b4 tan=d2b48c teal=008080 thistle=d8bfd8 tomato=ff6347 " +
+        "turquoise=40e0d0 violet=ee82ee wheat=f5deb3 white=ffffff whitesmoke=f5f5f5 " +
+        "yellow=ffff00 yellowgreen=9acd32"

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsEvent.kt

@@ -22,6 +22,12 @@ data class IcsEvent(
     val zoneId: String,
     /** Bare RRULE value (no `RRULE:` prefix), or null for a one-off event. */
     val recurrenceRule: String? = null,
+    /**
+     * Occurrences deleted from the series, in the provider's `EXDATE` shape —
+     * `yyyyMMdd` for an all-day series, a UTC `yyyyMMddTHHmmssZ` stamp
+     * otherwise. Empty for a one-off event.
+     */
+    val exDates: List<String> = emptyList(),
     val location: String? = null,
     val description: String? = null,
     /** Reminder lead times in minutes before start (raw provider offsets). */

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsParser.kt

@@ -7,14 +7,25 @@ import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.number
 import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.math.ceil
 import kotlin.time.Instant
 
+/** Milliseconds in a calendar day; all-day times are UTC midnights, so this is exact. */
+private const val DAY_MILLIS = 86_400_000L
+private const val MINUTES_PER_DAY = 1_440
+
 /**
  * A `VEVENT` parsed from an `.ics` file — the read-side mirror of [IcsEvent],
  * but [uid] is nullable (an incoming event may carry none; the insert layer
  * then assigns one). Times are absolute instants; [isAllDay]/[zoneId] mirror
  * how the writer encoded them.
+ *
+ * [reminderMinutes] holds raw lead times as the file's `VALARM`s expressed
+ * them — minutes *before* start, so a negative entry means "after start".
+ * [semanticReminderMinutes] turns those into the lead times Calendula models.
  */
 data class ParsedIcsEvent(
     val uid: String?,
@@ -30,8 +41,45 @@ data class ParsedIcsEvent(
     val status: EventStatus = EventStatus.Confirmed,
     val availability: Availability = Availability.Busy,
     val calendarName: String? = null,
+    /** Opaque ARGB the source file gave this event, if any (see [parseIcsColorValue]). */
+    val color: Int? = null,
+    /** Excluded occurrences, already in the provider's `EXDATE` shape. */
+    val exDates: List<String> = emptyList(),
+    /** True when this came from a `VTODO` rather than a `VEVENT`. */
+    val isTask: Boolean = false,
 )
 
+/**
+ * [reminderMinutes] mapped onto Calendula's model: a lead time in minutes before
+ * the event, never negative.
+ *
+ * For a timed event the raw lead time already is that, and a trigger that fires
+ * *after* the start models no lead time at all — it is dropped rather than
+ * clamped, which would invent a reminder at the start the file never asked for
+ * (a legal `TRIGGER:PT30M` follow-up alarm is the case). All-day reminders are
+ * whole days before the event, fired at the user's configured time of day (see
+ * `AllDayReminderEncoding`), so a raw offset counts the whole days its trigger
+ * lands *earlier than* the event's UTC midnight — i.e. it rounds **up**.
+ *
+ * Rounding to the nearest day instead would lose a day for every producer whose
+ * all-day notifications fire after noon: a file's raw offset is
+ * `days × 1440 − timeOfDay`, so "1 day before at 18:00" arrives as
+ * `TRIGGER:-PT6H` (raw 360) and would read as "on the day". Rounding up also
+ * lands Fossify's encoding correctly — it writes "on the day at 09:00" as a
+ * *positive* `TRIGGER:P0DT9H0M0S`, nine hours after the UTC midnight, which
+ * ceils to zero days before.
+ */
+fun ParsedIcsEvent.semanticReminderMinutes(): List<Int> = reminderMinutes
+    .mapNotNull { raw ->
+        if (isAllDay) {
+            ceil(raw.toDouble() / MINUTES_PER_DAY).toInt().coerceAtLeast(0) * MINUTES_PER_DAY
+        } else {
+            raw.takeIf { it >= 0 }
+        }
+    }
+    .distinct()
+    .sorted()
+
 /** Things the parser dropped rather than failing — surfaced in the import report. */
 enum class IcsParseWarning {
     /** A `RECURRENCE-ID` override occurrence (not modelled; only masters import). */
@@ -45,6 +93,12 @@ enum class IcsParseWarning {
 
     /** A `TZID` couldn't be resolved against the device tz database (used local zone). */
     UnknownTimezone,
+
+    /** `VTODO` components were imported as events — Calendula has no task model. */
+    TasksImportedAsEvents,
+
+    /** A malformed `RRULE` was repaired or dropped (see [sanitizeRrule]). */
+    RecurrenceRuleRepaired,
 }
 
 data class IcsParseResult(
@@ -52,8 +106,16 @@ data class IcsParseResult(
     val warnings: Set<IcsParseWarning>,
 )
 
-/** Outcome of a bulk `.ics` import into one calendar. */
-data class IcsImportSummary(val imported: Int, val skippedDuplicate: Int)
+/**
+ * Outcome of a bulk `.ics` import into one calendar. [failed] counts events the
+ * provider rejected — the import continues past them, so a single unusable
+ * event can't cost the user the rest of the file.
+ */
+data class IcsImportSummary(
+    val imported: Int,
+    val skippedDuplicate: Int,
+    val failed: Int = 0,
+)
 
 /**
  * Hand-rolled RFC 5545 reader, the inverse of [IcsWriter]. Pure and
@@ -62,6 +124,9 @@ data class IcsImportSummary(val imported: Int, val skippedDuplicate: Int)
  * (`RECURRENCE-ID`, attendees, unresolved `TZID`) are reported as [warnings]
  * rather than silently dropped. `VTIMEZONE` blocks are skipped — a `TZID` is
  * resolved against the OS tz database instead ([deviceZone] is the fallback).
+ *
+ * `VTODO` components are read as all-day/timed events: Calendula models no
+ * tasks, and dropping them would silently lose half of some exports.
  */
 class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault()) {
 
@@ -69,42 +134,55 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         val lines = unfoldLines(text)
         val events = mutableListOf<ParsedIcsEvent>()
         val warnings = mutableSetOf<IcsParseWarning>()
-        var calendarName: String? = null
+        // Scanned up front rather than in document order: an X-WR-CALNAME after
+        // the first VEVENT still names the calendar every event came from.
+        val calendarName = lines.asSequence()
+            .mapNotNull(::parseContentLine)
+            .firstOrNull { it.name == "X-WR-CALNAME" }
+            ?.let { unescapeText(it.value).trim().ifEmpty { null } }
 
         var i = 0
         while (i < lines.size) {
             val line = parseContentLine(lines[i])
             if (line == null) { i++; continue }
+            val component = when {
+                line.isBegin("VEVENT") -> "VEVENT"
+                line.isBegin("VTODO") -> "VTODO"
+                else -> null
+            }
             when {
-                line.isBegin("VEVENT") -> {
-                    val end = indexOfEnd(lines, i + 1, "VEVENT")
-                    parseVevent(lines.subList(i + 1, end), calendarName, warnings)
-                        ?.let(events::add)
+                component != null -> {
+                    val end = indexOfEnd(lines, i + 1, component)
+                    parseComponent(
+                        body = lines.subList(i + 1, end),
+                        fileCalendarName = calendarName,
+                        warnings = warnings,
+                        isTask = component == "VTODO",
+                    )?.let(events::add)
                     i = end + 1
                 }
                 line.isBegin("VTIMEZONE") -> {
                     // Skipped wholesale; TZIDs resolve against the OS tz database.
                     i = indexOfEnd(lines, i + 1, "VTIMEZONE") + 1
                 }
-                line.name == "X-WR-CALNAME" -> {
-                    calendarName = unescapeText(line.value).trim().ifEmpty { null }
-                    i++
-                }
                 else -> i++
             }
         }
+        if (events.any { it.isTask }) warnings.add(IcsParseWarning.TasksImportedAsEvents)
         return IcsParseResult(events, warnings)
     }
 
-    private fun parseVevent(
+    private fun parseComponent(
         body: List<String>,
         fileCalendarName: String?,
         warnings: MutableSet<IcsParseWarning>,
+        isTask: Boolean,
     ): ParsedIcsEvent? {
         var uid: String? = null
         var summary = ""
         var dtStart: IcsDateTime? = null
         var dtEnd: IcsDateTime? = null
+        var due: IcsDateTime? = null
         var duration: String? = null
         var rrule: String? = null
         var location: String? = null
@@ -112,7 +190,11 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         var status = EventStatus.Confirmed
         var availability = Availability.Busy
         var calendarName = fileCalendarName
+        var category: String? = null
+        var eventColor: Int? = null
+        var calendarColor: Int? = null
         val reminders = mutableListOf<Int>()
+        val exDateLines = mutableListOf<IcsContentLine>()
         var skipAsOverride = false
 
         var i = 0
@@ -129,9 +211,11 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
                 "UID" -> uid = line.value.trim().ifEmpty { null }
                 "SUMMARY" -> summary = unescapeText(line.value)
                 "DTSTART" -> dtStart = parseIcsDateTime(line, warnings)
+                "DUE" -> if (isTask) due = parseIcsDateTime(line, warnings)
                 "DTEND" -> dtEnd = parseIcsDateTime(line, warnings)
                 "DURATION" -> duration = line.value.trim()
                 "RRULE" -> rrule = line.value.trim().ifEmpty { null }
+                "EXDATE" -> exDateLines.add(line)
                 "LOCATION" -> location = unescapeText(line.value).ifEmpty { null }
                 "DESCRIPTION" -> description = unescapeText(line.value).ifEmpty { null }
                 "STATUS" -> status = mapIcsStatus(line.value)
@@ -142,6 +226,19 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
                 "ATTENDEE" -> warnings.add(IcsParseWarning.AttendeesIgnored)
                 "X-CALENDULA-CALENDAR" ->
                     calendarName = unescapeText(line.value).trim().ifEmpty { calendarName }
+                // Fossify names the source calendar per event; it never writes
+                // an X-WR-CALNAME, so this is the only calendar label its files
+                // carry. Elsewhere CATEGORIES is a plain tag list, so it only
+                // stands in where nothing named the calendar outright.
+                "CATEGORIES" -> category = singleCategory(line.value) ?: category
+                // Per-event colour, most specific encoding first (see parseIcsColorValue).
+                "X-FOSSIFY-EVENT-COLOR", "X-SMT-EVENT-COLOR" ->
+                    eventColor = parseIcsColorValue(line.value) ?: eventColor
+                "COLOR" -> eventColor = eventColor ?: parseIcsColorValue(line.value)
+                // The *calendar's* colour. Kept as a fallback so a migration that
+                // folds several source calendars into one keeps them apart visually.
+                "X-FOSSIFY-CATEGORY-COLOR", "X-SMT-CATEGORY-COLOR", "CATEGORY_COLOR" ->
+                    calendarColor = parseIcsColorValue(line.value) ?: calendarColor
             }
             i++
         }
@@ -150,37 +247,125 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
             warnings.add(IcsParseWarning.ModifiedOccurrenceSkipped)
             return null
         }
+        // Most producers give a VTODO only a DUE, which is then the moment the
+        // task sits at. One that carries a DTSTART too means the span between
+        // them, so DUE stands in for the end it has no DTEND for. Resolved after
+        // the sweep rather than inside it: property order isn't guaranteed, and
+        // a DUE ahead of the DTSTART would otherwise be taken for the start.
+        if (isTask && due != null) {
+            if (dtStart == null) dtStart = due else if (dtEnd == null) dtEnd = due
+        }
         val start = dtStart ?: run {
             warnings.add(IcsParseWarning.EventWithoutStartSkipped)
             return null
         }
-        val end = dtEnd
-            ?: duration?.let {
-                start.copy(
-                    instant = Instant.fromEpochMilliseconds(
-                        start.instant.toEpochMilliseconds() + parseRfc2445DurationMillis(it),
-                    ),
-                )
-            }
-            ?: start
+        val recurrence = sanitizeRrule(rrule)
+        if (recurrence.repaired) warnings.add(IcsParseWarning.RecurrenceRuleRepaired)
+        val end = resolveEnd(start, dtEnd, duration)
         return ParsedIcsEvent(
             uid = uid,
             summary = summary,
             start = start.instant,
-            end = end.instant,
+            end = end,
             isAllDay = start.isAllDay,
             zoneId = start.zoneId,
-            recurrenceRule = rrule,
+            recurrenceRule = recurrence.rule,
             location = location,
             description = description,
             reminderMinutes = reminders.distinct(),
             status = status,
             availability = availability,
-            calendarName = calendarName,
+            calendarName = calendarName ?: category,
+            color = eventColor ?: calendarColor,
+            exDates = if (recurrence.rule == null) {
+                emptyList()
+            } else {
+                normalizeExDates(exDateLines, start)
+            },
+            isTask = isTask,
         )
     }
 
-    /** A VALARM's lead time in minutes before start, or null if not a usable relative trigger. */
+    /**
+     * The event's end instant.
+     *
+     * All-day events get two RFC 5545 §3.6.1 rules applied that a literal read
+     * would miss: a `DATE`-valued `DTSTART` with no `DTEND` lasts one day, and —
+     * since the provider expands a zero-length all-day series into no instances
+     * at all — an all-day event may never end at or before it starts.
+     */
+    private fun resolveEnd(
+        start: IcsDateTime,
+        dtEnd: IcsDateTime?,
+        duration: String?,
+    ): Instant {
+        val explicit = dtEnd?.instant ?: duration?.let {
+            Instant.fromEpochMilliseconds(
+                start.instant.toEpochMilliseconds() + parseRfc2445DurationMillis(it),
+            )
+        }
+        if (!start.isAllDay) return explicit ?: start.instant
+        return explicit?.takeIf { it > start.instant } ?: start.instant.plusDays(1)
+    }
+
+    /**
+     * `EXDATE` values in the shape `Events.EXDATE` wants: `yyyyMMdd` for an
+     * all-day series, a UTC `yyyyMMddTHHmmssZ` stamp otherwise.
+     *
+     * Fossify stores its excluded occurrences as bare day codes and writes them
+     * out that way even for timed series, where the property is then ambiguous.
+     * Such a value is resolved against the series' own time of day, which is
+     * what it meant — its repetitions never move within the day.
+     *
+     * An all-day exclusion names a calendar day, so a zone-qualified DATE-TIME
+     * still means the day it spells out; resolving it to an instant first and
+     * reading *that* back in UTC would roll a midnight east of UTC onto the day
+     * before and exclude an occurrence that doesn't exist.
+     */
+    private fun normalizeExDates(lines: List<IcsContentLine>, start: IcsDateTime): List<String> {
+        if (lines.isEmpty()) return emptyList()
+        val startZone = runCatching { TimeZone.of(start.zoneId) }.getOrNull() ?: deviceZone
+        val startTime = start.instant.toLocalDateTime(startZone).time
+        return lines
+            .flatMap { line -> line.value.split(',').map { line to it.trim() } }
+            .mapNotNull { (line, token) ->
+                when {
+                    token.isEmpty() -> null
+                    start.isAllDay -> parseBasicDate(token.substringBefore('T'))?.let(::dayCode)
+                    token.contains('T') -> parseExDateTime(token, line, startZone)?.let(::utcStamp)
+                    else -> parseBasicDate(token)
+                        ?.let { utcStamp(LocalDateTime(it, startTime).toInstant(startZone)) }
+                }
+            }
+            .distinct()
+    }
+
+    /**
+     * [startZone] is the series' own zone, which a floating value (no `Z`, no
+     * `TZID`) has to be read in — RFC 5545 ties `EXDATE` to `DTSTART`'s form,
+     * and reading it in the device's zone instead would put the exclusion on an
+     * instant no occurrence has.
+     */
+    private fun parseExDateTime(
+        token: String,
+        line: IcsContentLine,
+        startZone: TimeZone,
+    ): Instant? {
+        val ldt = parseBasicDateTime(token.removeSuffix("Z")) ?: return null
+        val zone = when {
+            token.endsWith("Z") -> TimeZone.UTC
+            else -> line.params["TZID"]?.let { runCatching { TimeZone.of(it) }.getOrNull() }
+                ?: startZone
+        }
+        return ldt.toInstant(zone)
+    }
+
+    /**
+     * A `VALARM`'s offset from the event start, in minutes *before* it — so a
+     * trigger that fires after the start (which is how the Fossify family
+     * encodes "on the day at 09:00") comes back negative. Null when the trigger
+     * isn't a usable relative offset.
+     */
     private fun parseAlarmMinutes(body: List<String>): Int? {
         val trigger = body.asSequence()
             .mapNotNull { parseContentLine(it) }
@@ -189,8 +374,7 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         // Absolute (DATE-TIME) triggers can't be expressed as a lead time.
         if (trigger.params["VALUE"].equals("DATE-TIME", true)) return null
         val millis = parseRfc2445DurationMillis(trigger.value)
-        // Negative = before start (the normal case) → positive lead minutes.
-        return (-millis / 60_000L).toInt().coerceAtLeast(0)
+        return (-millis / 60_000L).toInt()
     }
 
     private fun parseIcsDateTime(line: IcsContentLine, warnings: MutableSet<IcsParseWarning>): IcsDateTime? {
@@ -218,6 +402,34 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         fun IcsContentLine.isBegin(component: String) =
             name == "BEGIN" && value.trim().equals(component, true)
 
+        fun Instant.plusDays(days: Int): Instant =
+            Instant.fromEpochMilliseconds(toEpochMilliseconds() + days * DAY_MILLIS)
+
+        fun dayCode(date: LocalDate): String =
+            "%04d%02d%02d".format(date.year, date.month.number, date.day)
+
+        fun utcStamp(instant: Instant): String = with(instant.toLocalDateTime(TimeZone.UTC)) {
+            "%04d%02d%02dT%02d%02d%02dZ".format(year, month.number, day, hour, minute, second)
+        }
+
+        /**
+         * A single-valued `CATEGORIES`, which is what the Fossify family writes
+         * for the source calendar's name. A multi-item list is a tag list and
+         * names no calendar, so it is ignored.
+         */
+        fun singleCategory(raw: String): String? {
+            var escaped = false
+            for (c in raw) {
+                when {
+                    escaped -> escaped = false
+                    c == '\\' -> escaped = true
+                    c == ',' -> return null
+                }
+            }
+            return unescapeText(raw).trim()
+                .takeIf { it.isNotEmpty() && !it.equals("null", true) }
+        }
+
         /** Index of the matching `END:<component>` at/after [from], or list end. */
         fun indexOfEnd(lines: List<String>, from: Int, component: String): Int {
             var i = from

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsRecurrence.kt

@@ -0,0 +1,132 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+private val VALID_FREQ = setOf(
+    "SECONDLY", "MINUTELY", "HOURLY", "DAILY", "WEEKLY", "MONTHLY", "YEARLY",
+)
+
+private val VALID_WEEKDAYS = setOf("SU", "MO", "TU", "WE", "TH", "FR", "SA")
+
+/**
+ * What `EventRecurrence` accepts in each numeric list part: a value range, plus
+ * whether `0` is legal. Its `parseNumberList` throws on a non-number, on an item
+ * outside the range *and* on a zero in the by-position parts, so checking only
+ * that an item is a number would still hand the provider a rule it rejects.
+ *
+ * `BYSETPOS` is the one part it leaves unbounded; `0` is dropped from it anyway
+ * because RFC 5545 §3.3.10 gives it no meaning.
+ */
+private val NUMERIC_LIST_PARTS = mapOf(
+    "BYSECOND" to NumericPart(0..59, zeroAllowed = true),
+    "BYMINUTE" to NumericPart(0..59, zeroAllowed = true),
+    "BYHOUR" to NumericPart(0..23, zeroAllowed = true),
+    "BYMONTHDAY" to NumericPart(-31..31, zeroAllowed = false),
+    "BYYEARDAY" to NumericPart(-366..366, zeroAllowed = false),
+    "BYWEEKNO" to NumericPart(-53..53, zeroAllowed = false),
+    "BYMONTH" to NumericPart(1..12, zeroAllowed = false),
+    "BYSETPOS" to NumericPart(Int.MIN_VALUE..Int.MAX_VALUE, zeroAllowed = false),
+)
+
+private class NumericPart(private val range: IntRange, private val zeroAllowed: Boolean) {
+    fun accepts(item: String): Boolean {
+        val n = item.toIntOrNull() ?: return false
+        return n in range && (zeroAllowed || n != 0)
+    }
+}
+
+/** `UNTIL` in RFC 5545 basic format; anything else fails at expansion time. */
+private val UNTIL_SHAPE = Regex("""\d{8}(T\d{6}Z?)?""")
+
+/**
+ * A foreign RRULE made safe to hand `CalendarContract`.
+ *
+ * [rule] is what survived, or null when there is nothing left to salvage.
+ * [repaired] is true only when a part was actually dropped — pure normalisation
+ * (case, a stray separator) doesn't count, so a conformant file is never
+ * reported to the user as faulty.
+ */
+data class SanitizedRrule(val rule: String?, val repaired: Boolean)
+
+/**
+ * Salvage a foreign RRULE.
+ *
+ * The provider validates every RRULE through `EventRecurrence.parse`, which
+ * **throws** on a malformed rule — and the throw surfaces from `insert`, not
+ * from a later read. One bad rule in an imported file would therefore abort the
+ * write it rides on. Producers do emit such rules: Fossify's exporter writes a
+ * bare `;BYDAY=` whenever a weekly event carries no weekday mask
+ * (`Parser.getByDay` interpolates an empty day string unconditionally), which is
+ * the state every weekly event it imported from elsewhere is left in.
+ *
+ * That parser has a fixed table of parts and throws on any name outside it, so
+ * this is a whitelist: an unrecognised part (RFC 7529 `RSCALE`, a vendor `X-`
+ * extension) and an unusable value are dropped rather than passed on to fail the
+ * whole event. Only a missing or unrecognised `FREQ` — without which there is no
+ * rule at all — gives up entirely.
+ */
+fun sanitizeRrule(raw: String?): SanitizedRrule {
+    val rule = raw?.trim()?.removePrefix("RRULE:")?.trim().orEmpty()
+    if (rule.isEmpty()) return SanitizedRrule(rule = null, repaired = false)
+
+    var freqSeen = false
+    var repaired = false
+    val parts = mutableListOf<String>()
+
+    /** The items [valid] accepts, uppercased and comma-joined; null if none survive. */
+    fun keepItems(value: String, valid: (String) -> Boolean): String? {
+        val items = value.split(',').map { it.trim().uppercase() }
+        val kept = items.filter(valid)
+        if (kept.size != items.size) repaired = true
+        return kept.takeIf { it.isNotEmpty() }?.joinToString(",")
+    }
+
+    for (part in rule.split(';')) {
+        // A stray separator ("FREQ=DAILY;") normalises away; nothing was lost.
+        // A part that carries text but no '=' ("FREQ=WEEKLY;BYDAY") is a part
+        // being dropped, so it falls through and marks the rule repaired.
+        if (part.isBlank()) continue
+        val key = part.substringBefore('=', "").trim().uppercase()
+        val value = if ('=' in part) part.substringAfter('=').trim() else ""
+        val kept = when {
+            key.isEmpty() || value.isEmpty() -> null
+            key == "FREQ" ->
+                value.uppercase().takeIf { it in VALID_FREQ }
+                    ?.also { freqSeen = true }
+                    ?.let { "FREQ=$it" }
+            // A non-positive or non-numeric INTERVAL/COUNT is rejected by the
+            // provider, and a COUNT of zero would expand to no occurrences.
+            key == "INTERVAL" -> value.toIntOrNull()?.takeIf { it > 0 }?.let { "INTERVAL=$it" }
+            key == "COUNT" -> value.toIntOrNull()?.takeIf { it > 0 }?.let { "COUNT=$it" }
+            key == "UNTIL" ->
+                value.uppercase().takeIf { UNTIL_SHAPE.matches(it) }?.let { "UNTIL=$it" }
+            key == "WKST" ->
+                value.uppercase().takeIf { it in VALID_WEEKDAYS }?.let { "WKST=$it" }
+            key == "BYDAY" -> keepItems(value, ::isWeekdayItem)?.let { "BYDAY=$it" }
+            key in NUMERIC_LIST_PARTS ->
+                keepItems(value, NUMERIC_LIST_PARTS.getValue(key)::accepts)?.let { "$key=$it" }
+            else -> null
+        }
+        if (kept == null) repaired = true else parts += kept
+    }
+    // `EventRecurrence.parse` ends with *two* global checks, not one: a missing
+    // FREQ throws, and so does an UNTIL that arrives together with a COUNT. A
+    // rule carrying both is malformed per RFC 5545 §3.3.10 but real producers
+    // emit it, and left alone it would throw straight out of `insert` — the very
+    // failure this function exists to prevent. UNTIL is kept: it bounds the
+    // series at an absolute date, so a stale COUNT can't over-generate past it.
+    if (parts.any { it.startsWith("UNTIL=") }) {
+        if (parts.removeAll { it.startsWith("COUNT=") }) repaired = true
+    }
+    return if (freqSeen) {
+        SanitizedRrule(rule = parts.joinToString(";"), repaired = repaired)
+    } else {
+        SanitizedRrule(rule = null, repaired = true)
+    }
+}
+
+/** A `BYDAY` item: a two-letter weekday, optionally preceded by an ordinal. */
+private fun isWeekdayItem(item: String): Boolean {
+    if (item.length < 2) return false
+    val ordinal = item.dropLast(2)
+    return item.takeLast(2) in VALID_WEEKDAYS &&
+        (ordinal.isEmpty() || ordinal.toIntOrNull() != null)
+}

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsWriter.kt

@@ -46,6 +46,7 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
         appendTimes(event)
         event.recurrenceRule?.takeIf { it.isNotBlank() }
             ?.let { add("RRULE:${it.removePrefix("RRULE:")}") }
+        appendExDates(event)
         event.location?.takeIf { it.isNotBlank() }
             ?.let { add("LOCATION:${escapeText(it)}") }
         event.description?.takeIf { it.isNotBlank() }
@@ -83,6 +84,20 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
         }
     }
 
+    /**
+     * The series' deleted occurrences. RFC 5545 ties `EXDATE`'s value type to
+     * `DTSTART`'s, so an all-day series needs the explicit `VALUE=DATE` — without
+     * it the bare day codes read as an invalid DATE-TIME. Only written for a
+     * recurring event: an exclusion names an occurrence, and a one-off has none.
+     */
+    private fun MutableList<String>.appendExDates(event: IcsEvent) {
+        if (event.recurrenceRule.isNullOrBlank()) return
+        val stamps = event.exDates.filter { it.isNotBlank() }.distinct()
+        if (stamps.isEmpty()) return
+        val prefix = if (event.isAllDay) "EXDATE;VALUE=DATE:" else "EXDATE:"
+        add(prefix + stamps.joinToString(","))
+    }
+
     private fun MutableList<String>.appendAlarm(minutes: Int, summary: String) {
         add("BEGIN:VALARM")
         add("ACTION:DISPLAY")

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/ParsedIcsForm.kt

@@ -13,6 +13,11 @@ import kotlinx.datetime.toLocalDateTime
  * calendar, exactly like a fresh create — the user confirms the target and
  * reviews everything before saving. Mirrors `EventDetail.toEditForm`'s all-day
  * handling (provider all-day times are UTC midnights with an exclusive end).
+ *
+ * [ParsedIcsEvent.color] is deliberately not carried over: picking the calendar
+ * is the first thing this form asks for, and that clears any colour (a raw ARGB
+ * is invalid on a calendar whose account publishes a palette). Bulk import,
+ * where the target is known up front, does keep it.
  */
 fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
     val (start, end) = if (isAllDay) {
@@ -31,7 +36,7 @@ fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
         end = end,
         location = location.orEmpty(),
         description = description.orEmpty(),
-        reminders = reminderMinutes.distinct().sorted(),
+        reminders = semanticReminderMinutes(),
         availability = availability,
         rrule = recurrenceRule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
     )

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

@@ -10,6 +10,7 @@ import androidx.compose.animation.slideOutHorizontally
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -27,6 +28,10 @@ import de.jeanlucmakiola.calendula.ui.calendars.BackupScreen
 import de.jeanlucmakiola.calendula.ui.calendars.CalendarsScreen
 import de.jeanlucmakiola.floret.identity.fadeThrough
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.EventMoveHost
+import de.jeanlucmakiola.calendula.ui.common.EventMoveScope
+import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
+import de.jeanlucmakiola.calendula.ui.common.RescheduleViewModel
 import de.jeanlucmakiola.calendula.ui.common.drillToDay
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.selectView
@@ -294,6 +299,34 @@ fun CalendarHost(
         }
     }
 
+    // Drag to reschedule (#68). Hosted here so one instance serves every view and
+    // survives view switches; the calendar surfaces read it out of LocalEventMove.
+    val reschedule: RescheduleViewModel = hiltViewModel()
+    val movableCalendarIds by reschedule.movableCalendarIds.collectAsStateWithLifecycle()
+    val onEditEvent: (EventInstance) -> Unit = { event ->
+        val key = longArrayOf(
+            event.eventId,
+            event.start.toEpochMilliseconds(),
+            event.end.toEpochMilliseconds(),
+        )
+        heldEditKey = key
+        editKey = key
+    }
+    // Off by preference (#173) switches off the gesture, not the scope: blocks
+    // register no drag, while the edit form and its TalkBack action stay put.
+    val dragToReschedule = viewModel.dragToReschedule.collectAsStateWithLifecycle().value
+    val moveScope = remember(movableCalendarIds, reschedule, dragToReschedule) {
+        EventMoveScope(
+            movableCalendarIds = movableCalendarIds,
+            dragEnabled = dragToReschedule,
+            move = reschedule::move,
+            inFlight = reschedule.inFlight,
+            undoStarted = reschedule.undoStarted,
+            abandoned = reschedule.abandoned,
+            edit = onEditEvent,
+        )
+    }
+
     val slideSpec = rememberCalendarSlideSpec()
 
     // Base-level back: pop the view stack while no overlay covers it (each overlay
@@ -311,6 +344,7 @@ fun CalendarHost(
         // navigation, so it fades through rather than sliding — paging *within* a
         // view keeps the directional slide. AnimatedContent keyed on the view type.
         val viewSwitch = fadeThrough()
+        CompositionLocalProvider(LocalEventMove provides moveScope) {
         AnimatedContent(
             targetState = view,
             transitionSpec = { viewSwitch },
@@ -367,6 +401,11 @@ fun CalendarHost(
                 )
             }
         }
+        }
+
+        // Scope prompt + confirmation/undo snackbar for a dropped event, declared
+        // right after the calendar views so later overlays cover it.
+        EventMoveHost(reschedule, modifier = Modifier.fillMaxSize())
 
         // Search overlay — below detail/edit in the Box so a tapped result's
         // detail screen draws on top, and closing it returns to the results.

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

@@ -53,4 +53,18 @@ class CalendarHostViewModel @Inject constructor(
             started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = false,
         )
+
+    /**
+     * Whether events may be dragged to another slot to reschedule them (#68, #173).
+     * Off until the stored value arrives, even though the preference itself defaults
+     * on: the wrong guess costs an enabled user a gesture for the few frames a cold
+     * start takes to read DataStore, but re-arms the one thing a disabled user
+     * switched off to be rid of.
+     */
+    val dragToReschedule: StateFlow<Boolean> = prefs.dragToReschedule
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = false,
+        )
 }

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

@@ -2,12 +2,15 @@ package de.jeanlucmakiola.calendula.ui
 
 import android.Manifest
 import android.content.pm.PackageManager
-import androidx.compose.animation.Crossfade
-import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
-import androidx.compose.material3.MaterialTheme
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.togetherWith
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
@@ -22,13 +25,22 @@ import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesScheduler
 import de.jeanlucmakiola.calendula.data.contacts.hasContactsPermission
-import de.jeanlucmakiola.calendula.ui.calendars.CalendarVisibilityNoticeDialog
-import de.jeanlucmakiola.calendula.ui.calendars.CalendarVisibilityNoticeViewModel
-import de.jeanlucmakiola.calendula.ui.permission.PermissionScreen
-import de.jeanlucmakiola.calendula.ui.permission.ReminderOnboardingScreen
-import de.jeanlucmakiola.calendula.ui.permission.ReminderOnboardingViewModel
+import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
+import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingStep
+import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingSteps
+import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingViewModel
+import de.jeanlucmakiola.calendula.ui.onboarding.onboardingSlideTransition
+import de.jeanlucmakiola.calendula.ui.onboarding.rememberOnboardingSlideSpec
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
+
+/** What the root is showing: a wizard step, the app, or neither yet. */
+private sealed interface RootTarget {
+    /** DataStore has not emitted yet — render nothing rather than the wrong screen. */
+    data object Loading : RootTarget
+    data object App : RootTarget
+    data class Step(val step: OnboardingStep) : RootTarget
+}
 
-@OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun RootScreen(
     modifier: Modifier = Modifier,
@@ -76,33 +88,63 @@ fun RootScreen(
         onDispose { lifecycle.removeObserver(obs) }
     }
 
-    // Cross-fade the one-time onboarding gates so granting permission / finishing
-    // onboarding eases into the next screen instead of snapping. A fade carries no
-    // spatial motion, so it stays appropriate under "remove animations" too.
-    val gateSpec = MaterialTheme.motionScheme.fastEffectsSpec<Float>()
-    Crossfade(targetState = hasPermission, animationSpec = gateSpec, label = "permissionGate") { granted ->
-        if (granted) {
-            // Second onboarding gate (v1.4, one-time): reminder notifications.
-            // Null until DataStore's first emission — render nothing for that
-            // frame instead of flashing the wrong screen.
-            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.
-            val visibilityNotice: CalendarVisibilityNoticeViewModel = hiltViewModel()
-            val noticePending by visibilityNotice.pending.collectAsStateWithLifecycle()
-            // Runs on entry however the permission was granted, including via
-            // Android's app-settings screen (caught by the ON_RESUME above).
-            LaunchedEffect(Unit) {
-                visibilityNotice.reconcile()
-                if (!grantedAtLaunch) reminderOnboarding.rearmAfterGrant()
+    val onboarding: OnboardingViewModel = hiltViewModel()
+    val plan by onboarding.plan.collectAsStateWithLifecycle()
+    // The grant is reported however it was taken, including via Android's
+    // app-settings screen (caught by the ON_RESUME above); arming the wizard
+    // hangs off that, not off the in-app callback.
+    LaunchedEffect(hasPermission) {
+        onboarding.setHasPermission(hasPermission)
+        if (hasPermission && !grantedAtLaunch) onboarding.onPermissionGranted()
     }
-            if (onboardingDone == true && noticePending) {
-                CalendarVisibilityNoticeDialog(onDismiss = visibilityNotice::dismiss)
+
+    // Arms the one-time explainer for the switch to the device's own calendar
+    // visibility (#75), which the wizard then carries as a step of its own.
+    LaunchedEffect(hasPermission) {
+        if (hasPermission) onboarding.reconcileCalendarVisibility()
     }
-            Crossfade(targetState = onboardingDone, animationSpec = gateSpec, label = "onboardingGate") { done ->
-                when (done) {
-                    true -> CalendarHost(
+
+    val current = plan
+    val target: RootTarget = when {
+        current == null -> RootTarget.Loading
+        current.current == null -> RootTarget.App
+        else -> RootTarget.Step(current.current)
+    }
+
+    // Which way the flow is moving, so a step-back slides back. The app sorts
+    // after every step, so finishing the wizard reads as one more move forward.
+    val ordinal = when (target) {
+        RootTarget.Loading -> Int.MIN_VALUE
+        RootTarget.App -> Int.MAX_VALUE
+        is RootTarget.Step -> current?.steps?.indexOf(target.step) ?: 0
+    }
+    var lastOrdinal by remember { mutableIntStateOf(ordinal) }
+    val slideDir = if (ordinal < lastOrdinal) -1 else 1
+    SideEffect { lastOrdinal = ordinal }
+
+    val slideSpec = rememberOnboardingSlideSpec()
+    val fadeSpec = rememberCalendarFadeSpec()
+    val reduceMotion = rememberReduceMotion()
+    AnimatedContent(
+        targetState = target,
+        transitionSpec = {
+            // Coming off the blank first frame is not a step change.
+            if (initialState == RootTarget.Loading) {
+                fadeIn(fadeSpec).togetherWith(fadeOut(fadeSpec))
+            } else {
+                onboardingSlideTransition(
+                    slideDir = slideDir,
+                    spec = slideSpec,
+                    fadeSpec = fadeSpec,
+                    reduceMotion = reduceMotion,
+                )
+            }
+        },
+        label = "onboardingGate",
+    ) { shown ->
+        when (shown) {
+            RootTarget.Loading -> Unit
+            RootTarget.App -> CalendarHost(
                 modifier = modifier,
                 requestedDetailKey = requestedDetailKey,
                 onDetailKeyConsumed = onDetailKeyConsumed,
@@ -116,18 +158,17 @@ fun RootScreen(
                 requestedEditKey = requestedEditKey,
                 onEditKeyConsumed = onEditKeyConsumed,
             )
-                    false -> ReminderOnboardingScreen(
-                        onFinished = reminderOnboarding::finish,
+            // Both halves of a transition read their position out of the live
+            // plan; the one the outgoing step was drawn with is already gone.
+            is RootTarget.Step -> current?.let { plan ->
+                OnboardingSteps(
+                    step = shown.step,
+                    plan = plan,
+                    viewModel = onboarding,
+                    onPermissionGranted = { hasPermission = true },
                     modifier = modifier,
                 )
-                    null -> {}
             }
         }
-        } else {
-            PermissionScreen(
-                onGranted = { hasPermission = true },
-                modifier = modifier,
-            )
-        }
     }
 }

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

@@ -24,11 +24,13 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
+import de.jeanlucmakiola.calendula.ui.common.declinedTitle
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
@@ -129,8 +131,8 @@ internal fun AgendaEventRow(
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     GroupedRow(
         modifier = if (dimmed) modifier.alpha(EventDimAlpha) else modifier,
-        title = title,
-        summary = agendaTimeSummary(event, day, zone),
+        title = declinedTitle(title, event.isDeclined),
+        summary = AnnotatedString(agendaTimeSummary(event, day, zone)),
         position = position,
         minHeight = 64.dp,
         leading = {

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

@@ -276,7 +276,7 @@ private fun AgendaRangeBanner(
 }
 
 @Composable
-private fun AgendaContent(
+internal fun AgendaContent(
     state: AgendaUiState,
     pastDisplay: PastEventDisplay,
     showToday: Boolean,

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

@@ -0,0 +1,64 @@
+package de.jeanlucmakiola.calendula.ui.agenda
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
+import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
+import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
+import de.jeanlucmakiola.calendula.ui.common.sampleAgendaEvents
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+
+/** How far ahead the agenda preview's stand-in window runs. */
+private const val PREVIEW_WINDOW_DAYS = 14
+
+/**
+ * A live, scaled-down Agenda view for the onboarding view chooser. Today and
+ * the day headers are real; only the events are stand-ins.
+ */
+@Composable
+internal fun AgendaViewPreview(
+    height: Dp,
+    modifier: Modifier = Modifier,
+) {
+    val zone = remember { TimeZone.currentSystemDefault() }
+    val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
+    val state = remember(today, zone) { sampleAgendaState(today, zone) }
+
+    ScaledViewPreview(height = height, modifier = modifier) {
+        AgendaContent(
+            state = state,
+            // Stand-in events are all upcoming, so the past-event preference
+            // cannot change what the preview shows — keep it at the default.
+            pastDisplay = PastEventDisplay.SHOW,
+            showToday = true,
+            onRetry = {},
+            onEventClick = {},
+            onOpenDay = {},
+            modifier = Modifier.fillMaxSize(),
+        )
+    }
+}
+
+/** Sample agenda state, grouped through the same helper the live view uses. */
+private fun sampleAgendaState(today: LocalDate, zone: TimeZone): AgendaUiState.Success {
+    val windowEnd = today.plus(PREVIEW_WINDOW_DAYS, DateTimeUnit.DAY)
+    return AgendaUiState.Success(
+        anchor = today,
+        today = today,
+        days = groupAgendaDays(today, windowEnd, sampleAgendaEvents(today, zone), zone),
+        range = AgendaRange.Custom(PREVIEW_WINDOW_DAYS),
+        rangeIsOverride = false,
+        rangeEnd = windowEnd,
+        // The range bar belongs to the screen, not the list — the preview shows
+        // the list only.
+        showRangeBar = false,
+        zone = zone,
+    )
+}

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

@@ -1,71 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.calendars
-
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.VisibilityOff
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.res.stringResource
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.data.calendar.CalendarVisibilityReconciler
-import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-/**
- * The one-time notice that Calendula now follows the device's per-calendar
- * visibility (#75), armed by `CalendarVisibilityReconciler`. The app does not
- * switch those calendars back on — that would un-hide them everywhere else too.
- */
-@HiltViewModel
-class CalendarVisibilityNoticeViewModel @Inject constructor(
-    private val prefs: CalendarPrefs,
-    private val reconciler: CalendarVisibilityReconciler,
-) : ViewModel() {
-
-    /**
-     * Reconcile whenever the app comes up with the calendar permission held,
-     * rather than off one grant route: a permission granted on Android's
-     * app-settings screen never reaches the permission screen's callback.
-     */
-    fun reconcile() {
-        viewModelScope.launch { reconciler.run() }
-    }
-
-    val pending: StateFlow<Boolean> = prefs.visibilityNoticePending
-        .map { it == true }
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = false,
-        )
-
-    fun dismiss() {
-        viewModelScope.launch { prefs.setVisibilityNoticePending(false) }
-    }
-}
-
-/** Plain informational dialog — one acknowledgement, nothing to decide. */
-@Composable
-fun CalendarVisibilityNoticeDialog(onDismiss: () -> Unit) {
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        icon = { Icon(Icons.Default.VisibilityOff, contentDescription = null) },
-        title = { Text(stringResource(R.string.calendars_visibility_notice_title)) },
-        text = { Text(stringResource(R.string.calendars_visibility_notice_message)) },
-        confirmButton = {
-            TextButton(onClick = onDismiss) {
-                Text(stringResource(R.string.dialog_ok))
-            }
-        },
-    )
-}

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

@@ -0,0 +1,75 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.core.FiniteAnimationSpec
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.core.snap
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
+
+/**
+ * A timed block's own time label, crossfaded rather than replaced — the block
+ * slides to its new slot, so the label shouldn't change in a single frame.
+ */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun BlockTimeLabel(label: String, color: Color, modifier: Modifier = Modifier) {
+    val spec: FiniteAnimationSpec<Float> = if (rememberReduceMotion()) {
+        snap()
+    } else {
+        MaterialTheme.motionScheme.fastEffectsSpec()
+    }
+    Crossfade(
+        targetState = label,
+        animationSpec = spec,
+        label = "block-time",
+        modifier = modifier,
+    ) { text ->
+        Text(
+            text = text,
+            style = MaterialTheme.typography.labelSmall,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+            color = color,
+        )
+    }
+}
+
+/** Where a timed block sits in its column, after tweening. */
+@Immutable
+data class BlockPlacement(val x: Dp, val y: Dp, val width: Dp, val height: Dp)
+
+/**
+ * A timed block's placement, tweened rather than jumped. Continuity comes from
+ * the caller keying each block by identity; a block composed for the first time
+ * starts at its target, so nothing flies in on the first frame.
+ *
+ * A pinch-zoom rewrites the hour height every pointer frame, and the gutter and
+ * grid lines follow it instantly — so the tween stands down for the gesture
+ * rather than leaving the blocks trailing the ruler they are measured against.
+ */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun animatedBlockPlacement(x: Dp, y: Dp, width: Dp, height: Dp): BlockPlacement {
+    val spec: FiniteAnimationSpec<Dp> = if (rememberReduceMotion() ||
+        LocalTimelineZoom.current.isPinching
+    ) {
+        snap()
+    } else {
+        MaterialTheme.motionScheme.fastSpatialSpec()
+    }
+    val animatedX by animateDpAsState(x, spec, label = "block-x")
+    val animatedY by animateDpAsState(y, spec, label = "block-y")
+    val animatedWidth by animateDpAsState(width, spec, label = "block-width")
+    val animatedHeight by animateDpAsState(height, spec, label = "block-height")
+    return BlockPlacement(animatedX, animatedY, animatedWidth, animatedHeight)
+}

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

@@ -0,0 +1,35 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.ui.unit.dp
+
+/** The corner radius every event chip keeps on each edge the event doesn't cross. */
+val EVENT_CHIP_CORNER = 4.dp
+
+/** An event chip that is cut on no edge — an all-day bar, a floating copy. */
+val EventChipShape = RoundedCornerShape(EVENT_CHIP_CORNER)
+
+/**
+ * A timed block's corners: square on whichever edge the event runs past, so a
+ * cut edge reads as "this carries on" rather than as the event's own end. The
+ * vertical counterpart of [monthBarShape].
+ */
+fun timedBlockShape(continuesBefore: Boolean, continuesAfter: Boolean): RoundedCornerShape =
+    RoundedCornerShape(
+        topStart = if (continuesBefore) 0.dp else EVENT_CHIP_CORNER,
+        topEnd = if (continuesBefore) 0.dp else EVENT_CHIP_CORNER,
+        bottomStart = if (continuesAfter) 0.dp else EVENT_CHIP_CORNER,
+        bottomEnd = if (continuesAfter) 0.dp else EVENT_CHIP_CORNER,
+    )
+
+/**
+ * A month/all-day bar's corners: square on whichever side the event runs past
+ * the row it is drawn in.
+ */
+fun monthBarShape(continuesLeft: Boolean, continuesRight: Boolean): RoundedCornerShape =
+    RoundedCornerShape(
+        topStart = if (continuesLeft) 0.dp else EVENT_CHIP_CORNER,
+        bottomStart = if (continuesLeft) 0.dp else EVENT_CHIP_CORNER,
+        topEnd = if (continuesRight) 0.dp else EVENT_CHIP_CORNER,
+        bottomEnd = if (continuesRight) 0.dp else EVENT_CHIP_CORNER,
+    )

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

@@ -0,0 +1,150 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.positionInRoot
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.platform.LocalViewConfiguration
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.dp
+
+/** How far the finger may wander during the hold — well under touch slop. */
+private val PICKUP_TOLERANCE = 6.dp
+
+/**
+ * Pick an event block up with a long press and drag it, without
+ * `detectDragGesturesAfterLongPress`: the stock detector cancels as soon as an
+ * ancestor consumes or the finger leaves the block, which a
+ * `MIN_EVENT_FRACTION`-tall block loses immediately. Movement before the timeout
+ * is deliberately not consumed, so a scroll starting on top of a block survives.
+ */
+@Composable
+fun rememberEventDragSource(
+    enabled: Boolean,
+    key: Any?,
+    onPickUp: (pointerInRoot: Offset, blockInRoot: Offset, size: IntSize) -> Unit,
+    onMove: (pointerInRoot: Offset) -> Unit,
+    onDrop: () -> Unit,
+    onCancel: () -> Unit,
+): Modifier = rememberDragSurface(
+    enabled = enabled,
+    key = key,
+    onPickUp = { _, pointerInRoot, nodeInRoot, size ->
+        onPickUp(pointerInRoot, nodeInRoot, size)
+        true
+    },
+    onMove = onMove,
+    onDrop = onDrop,
+    onCancel = onCancel,
+)
+
+/**
+ * The same pickup, for a surface that carries many draggable pieces rather than
+ * being one itself — the month grid, whose chips are covered by a full-bleed tap
+ * layer. [onPickUp] receives the press position local to this node and answers
+ * whether anything is there; false abandons the gesture.
+ */
+@Composable
+fun rememberDragSurface(
+    enabled: Boolean,
+    key: Any?,
+    onPickUp: (local: Offset, pointerInRoot: Offset, nodeInRoot: Offset, size: IntSize) -> Boolean,
+    onMove: (pointerInRoot: Offset) -> Unit,
+    onDrop: () -> Unit,
+    onCancel: () -> Unit,
+): Modifier {
+    if (!enabled) return Modifier
+    val holdMillis = LocalViewConfiguration.current.longPressTimeoutMillis
+    val tolerance = with(LocalDensity.current) { PICKUP_TOLERANCE.toPx() }
+    val coordinates = remember { arrayOfNulls<LayoutCoordinates>(1) }
+    val currentPickUp by rememberUpdatedState(onPickUp)
+    val currentMove by rememberUpdatedState(onMove)
+    val currentDrop by rememberUpdatedState(onDrop)
+    val currentCancel by rememberUpdatedState(onCancel)
+
+    return Modifier
+        .onGloballyPositioned { coordinates[0] = it }
+        .pointerInput(key) {
+            awaitEachGesture {
+                val down = awaitFirstDown(requireUnconsumed = false)
+                val origin = down.position
+                val heldStill = withTimeoutOrNull(holdMillis) {
+                    while (true) {
+                        val main = awaitPointerEvent()
+                        val change = main.changes.firstOrNull { it.id == down.id } ?: break
+                        if (!change.pressed) break
+                        if (main.changes.count { it.pressed } > 1) break
+                        if ((change.position - origin).getDistance() > tolerance) break
+                        // An ancestor's claim only becomes visible once the whole
+                        // main pass has run, so look again on the final pass.
+                        val final = awaitPointerEvent(PointerEventPass.Final)
+                        if (final.changes.any { it.isConsumed }) break
+                    }
+                } == null
+                if (!heldStill) return@awaitEachGesture
+
+                val layout = coordinates[0]?.takeIf { it.isAttached } ?: return@awaitEachGesture
+                val took = currentPickUp(
+                    down.position,
+                    layout.localToRoot(down.position),
+                    layout.positionInRoot(),
+                    layout.size,
+                )
+                if (!took) return@awaitEachGesture
+                var dropped = false
+                try {
+                    // Driven on the initial pass, which runs parent → child: an
+                    // ancestor that outranks us (the pinch) has already consumed
+                    // by the time we look, and descendants — the month grid's
+                    // full-bleed tap layer — see our consumption.
+                    while (true) {
+                        val event = awaitPointerEvent(PointerEventPass.Initial)
+                        val change = event.changes.firstOrNull { it.id == down.id } ?: break
+                        if (change.isConsumed) break
+                        if (!change.pressed) {
+                            change.consume()
+                            dropped = true
+                            break
+                        }
+                        if (event.changes.count { it.pressed } > 1) break
+                        change.consume()
+                        coordinates[0]?.takeIf { it.isAttached }
+                            ?.let { currentMove(it.localToRoot(change.position)) }
+                    }
+                } finally {
+                    // Also reached when the pointer node is disposed mid-drag —
+                    // a cancel, not a drop, and must never write.
+                    if (dropped) currentDrop() else currentCancel()
+                }
+            }
+        }
+}
+
+/** A lift on pickup, then a tick every time the drop target snaps to a new slot. */
+@Composable
+fun DragSnapHaptics(slot: Any?) {
+    val haptics = LocalHapticFeedback.current
+    val previous = remember { arrayOfNulls<Any>(1) }
+    LaunchedEffect(slot) {
+        val had = previous[0]
+        previous[0] = slot
+        when {
+            slot == null -> Unit
+            had == null -> haptics.performHapticFeedback(HapticFeedbackType.LongPress)
+            had != slot -> haptics.performHapticFeedback(HapticFeedbackType.SegmentTick)
+        }
+    }
+}

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

@@ -0,0 +1,144 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.floret.components.SnackChip
+import de.jeanlucmakiola.floret.components.SnackChipHeight
+import de.jeanlucmakiola.floret.components.SnackChipMargin
+import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.floret.locale.localizedDateFormatter
+import kotlinx.coroutines.delay
+import java.time.Instant
+import java.time.ZoneId
+import java.time.ZoneOffset
+import java.util.Locale
+
+/** How long the confirmation chip stays up, matching a short snackbar. */
+private const val CHIP_MILLIS = 4_000L
+
+/** How long an *undone* move stays up — shorter, since it offers nothing to act on. */
+private const val UNDONE_CHIP_MILLIS = 1_600L
+
+/** What the chip currently reads, kept past the outcome it was built from. */
+private data class ChipContent(val message: String, val undo: MoveUndo?)
+
+/** The FAB's own band at the bottom end, which the chip must not run into. */
+private val FAB_BAND = 88.dp
+
+/**
+ * The two surfaces a drag-and-drop reschedule needs on top of the calendar: the
+ * recurring-scope prompt, and the confirmation chip carrying Undo. None of the
+ * calendar screens sets a `snackbarHost`, so this hosts its own confirmation as
+ * a pill on the FAB's band, leaving the calendar visible behind it.
+ */
+@Composable
+fun EventMoveHost(viewModel: RescheduleViewModel, modifier: Modifier = Modifier) {
+    val prompt by viewModel.scopePrompt.collectAsStateWithLifecycle()
+    val outcome by viewModel.outcome.collectAsStateWithLifecycle()
+    val undoTick by viewModel.undoStarted.collectAsStateWithLifecycle()
+    val writeInFlight by viewModel.inFlight.collectAsStateWithLifecycle()
+    val locale = currentLocale()
+    val use24Hour = LocalUse24HourFormat.current
+
+    prompt?.let { pending ->
+        RecurringScopeDialog(
+            title = stringResource(R.string.event_move_recurring_title),
+            onSelect = viewModel::moveWithScope,
+            onDismiss = viewModel::cancelScope,
+            allowSeries = !pending.occurrenceOnly,
+            reason = stringResource(R.string.event_move_occurrence_only)
+                .takeIf { pending.occurrenceOnly },
+        )
+    }
+
+    val moved = outcome as? MoveOutcome.Moved
+    val movedLabel = moved?.let { formatMovedTo(it.startMillis, it.isAllDay, use24Hour, locale) }
+    val message = when (outcome) {
+        null -> null
+        is MoveOutcome.Moved -> stringResource(R.string.event_move_done, movedLabel.orEmpty())
+        MoveOutcome.Undone -> stringResource(R.string.event_move_undone)
+        MoveOutcome.WriteDenied -> stringResource(R.string.event_move_write_denied)
+        MoveOutcome.Gone -> stringResource(R.string.event_move_gone)
+        MoveOutcome.BlockedSeriesEnd -> stringResource(R.string.event_move_blocked_series_end)
+        MoveOutcome.Failed -> stringResource(R.string.event_move_failed)
+    }
+
+    // Held past the outcome being consumed so the chip has something to draw
+    // while it springs back out. Updated in composition rather than from an
+    // effect, which would land a frame late and open the chip on stale text.
+    val shown = remember { mutableStateOf(ChipContent("", null)) }
+    if (message != null && (shown.value.message != message || shown.value.undo != moved?.undo)) {
+        shown.value = ChipContent(message, moved?.undo)
+    }
+    val content = shown.value
+    // Restarted by the undo tick and held while a write is in flight: an undo
+    // tapped in the last moments of the window leaves the outcome at Moved on
+    // purpose, and this timer would otherwise fire mid-undo and close the chip
+    // just before the same chip has to say "undone".
+    LaunchedEffect(outcome, undoTick, writeInFlight) {
+        if (outcome == null || writeInFlight) return@LaunchedEffect
+        delay(if (outcome == MoveOutcome.Undone) UNDONE_CHIP_MILLIS else CHIP_MILLIS)
+        viewModel.consumeOutcome()
+    }
+
+    BoxWithConstraints(modifier = modifier.fillMaxSize()) {
+        val chipMaxWidth = maxWidth - FAB_BAND
+        // A FAB-height band at the bottom start with the FAB's own margin, so
+        // the chip lines up beside the bottom-end FAB.
+        Box(
+            modifier = Modifier
+                .align(Alignment.BottomStart)
+                .navigationBarsPadding()
+                .padding(start = SnackChipMargin, bottom = SnackChipMargin)
+                .height(SnackChipHeight),
+            contentAlignment = Alignment.CenterStart,
+        ) {
+            // The action goes away while a write runs: undo() refuses a second
+            // write anyway, so offering it would be a button that does nothing.
+            val undo = content.undo?.takeIf { !writeInFlight }
+            SnackChip(
+                visible = outcome != null,
+                message = content.message,
+                maxWidth = chipMaxWidth,
+                actionLabel = stringResource(R.string.event_move_undo).takeIf { undo != null },
+                onAction = undo?.let { { viewModel.undo(it) } },
+            )
+        }
+    }
+}
+
+/**
+ * "Fri, 7 Aug, 09:00" — the day, plus the time for a timed event. All-day events
+ * are read back on the UTC calendar day they are anchored to (#65, #82).
+ */
+private fun formatMovedTo(
+    startMillis: Long,
+    isAllDay: Boolean,
+    use24Hour: Boolean,
+    locale: Locale,
+): String {
+    val zone: ZoneId = if (isAllDay) ZoneOffset.UTC else ZoneId.systemDefault()
+    val skeleton = when {
+        isAllDay -> "EEEdMMM"
+        use24Hour -> "EEEdMMMHm"
+        else -> "EEEdMMMhm"
+    }
+    return localizedDateFormatter(locale, skeleton)
+        .format(Instant.ofEpochMilli(startMillis).atZone(zone))
+}

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

@@ -0,0 +1,145 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.CustomAccessibilityAction
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+
+/**
+ * Drag-to-reschedule wiring (#68), provided once at `CalendarHost` and read by
+ * whichever event block is being composed. Null means moving is off entirely and
+ * blocks register no drag gesture at all.
+ */
+@Immutable
+class EventMoveScope(
+    /**
+     * Calendars whose events may be moved. Nothing below the UI enforces this —
+     * the repository writes whatever it is handed — so this gate is load-bearing.
+     */
+    val movableCalendarIds: Set<Long>,
+    /**
+     * Whether the *gesture* is on (#173). Off gates the drag alone: [edit] and the
+     * TalkBack action below stay, since invoking a menu item can't cause the
+     * accidental drags the setting exists to stop.
+     */
+    val dragEnabled: Boolean,
+    /** False when the drop was refused outright, so nothing will be written. */
+    val move: (MoveRequest) -> Boolean,
+    /**
+     * True while a dropped event is being written, including the time its scope
+     * dialog is up. A flow rather than a value so this scope stays the same
+     * object across a move — every visible block reads it as a composition local.
+     */
+    val inFlight: StateFlow<Boolean>,
+    /** Ticks when an undo write begins — see `RescheduleViewModel.undoStarted`. */
+    val undoStarted: StateFlow<Int>,
+    /**
+     * Ticks when a drop ends with nothing landing — see
+     * `RescheduleViewModel.abandoned`. [move] answers before the write is
+     * resolved, so this is what tells a held copy to stop waiting.
+     */
+    val abandoned: StateFlow<Int>,
+    /** Open an event in the edit form — the pointer-free route to the same change. */
+    val edit: (EventInstance) -> Unit,
+) {
+    fun allows(event: EventInstance): Boolean = event.calendarId in movableCalendarIds
+}
+
+val LocalEventMove = compositionLocalOf<EventMoveScope?> { null }
+
+private val NEVER_IN_FLIGHT = MutableStateFlow(false)
+
+private val NEVER_UNDONE = MutableStateFlow(0)
+
+private val NEVER_ABANDONED = MutableStateFlow(0)
+
+/**
+ * Whether a dropped event is still being written — false wherever moving is off.
+ * The drag overlays hold a landed block on its target for this window.
+ */
+@Composable
+fun moveInFlight(): Boolean {
+    val flow = LocalEventMove.current?.inFlight ?: NEVER_IN_FLIGHT
+    return flow.collectAsStateWithLifecycle().value
+}
+
+/**
+ * How many drops have ended with nothing landing. Read as a plain count so a
+ * drag overlay can capture it at the moment of the drop and tell, later, whether
+ * *its own* drop was one of them.
+ */
+@Composable
+fun abandonedMoves(): Int {
+    val flow = LocalEventMove.current?.abandoned ?: NEVER_ABANDONED
+    return flow.collectAsStateWithLifecycle().value
+}
+
+/**
+ * Runs [onUndo] when an undo write begins, and never for one that began before
+ * this composable came on screen.
+ */
+@Composable
+fun OnUndoStarted(onUndo: () -> Unit) {
+    val flow = LocalEventMove.current?.undoStarted ?: NEVER_UNDONE
+    val tick by flow.collectAsStateWithLifecycle()
+    var seen by remember { mutableIntStateOf(tick) }
+    LaunchedEffect(tick) {
+        if (tick == seen) return@LaunchedEffect
+        seen = tick
+        onUndo()
+    }
+}
+
+/** Opacity the source block keeps while its floating copy travels. */
+const val GHOST_ALPHA: Float = 0.3f
+
+/**
+ * Opacity for a block whose copy is in flight: ghosted from the lift until the
+ * copy is handed back, then animated up rather than switched, so the block
+ * appears to travel to its new slot instead of vanishing and reappearing.
+ */
+@Composable
+fun ghostAlpha(lifted: Boolean): Float = animateFloatAsState(
+    targetValue = if (lifted) GHOST_ALPHA else 1f,
+    label = "ghost-alpha",
+).value
+
+/**
+ * Whether [event] can be picked up and dragged — its calendar allows moving and
+ * the gesture is switched on. Not the same question as [eventMoveAction], which
+ * survives the setting.
+ */
+@Composable
+fun eventDragAllowed(event: EventInstance): Boolean {
+    val move = LocalEventMove.current ?: return false
+    return move.dragEnabled && move.allows(event)
+}
+
+/**
+ * A TalkBack action that opens [event] in the edit form, so rescheduling isn't
+ * pointer-only. Null when this event can't be moved.
+ */
+@Composable
+fun eventMoveAction(event: EventInstance): CustomAccessibilityAction? {
+    val move = LocalEventMove.current ?: return null
+    if (!move.allows(event)) return null
+    val label = stringResource(R.string.event_move_action)
+    return remember(event.instanceId, label, move) {
+        CustomAccessibilityAction(label) {
+            move.edit(event)
+            true
+        }
+    }
+}

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

@@ -0,0 +1,127 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.foundation.ScrollState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.floret.locale.currentLocale
+
+/** Width of the hour gutter down the start edge of the day and week timelines. */
+val GUTTER_WIDTH = 48.dp
+
+/**
+ * Start inset for the gutter's content (week badge + hour labels) so it centres
+ * on the top bar's hamburger: with a 48dp gutter, 8dp lands the centre at 28dp,
+ * matching the icon button's centre.
+ */
+val GUTTER_CONTENT_START_INSET = 8.dp
+
+/**
+ * End inset for everything that lines up with the day columns — the week's day
+ * header, the all-day strip and the timeline itself. Without it the last column
+ * runs flush into the screen edge while the gutter gives the other side room
+ * (#192); 8dp mirrors [GUTTER_CONTENT_START_INSET].
+ */
+val TIMELINE_CONTENT_END_INSET = 8.dp
+
+private val BADGE_HEIGHT = 20.dp
+
+/** How far the fixed hour labels recede while a block is being dragged. */
+private const val DIMMED_HOUR_ALPHA = 0.3f
+
+/**
+ * The timeline's hour gutter. Scrolls in sync with the day columns through the
+ * shared [scrollState], and while [dragController] holds a lifted block it dims
+ * the hour labels and floats a badge with the drag's current start time at the
+ * row the block would land on.
+ */
+@Composable
+fun HourGutter(
+    scrollState: ScrollState,
+    hourHeight: Dp,
+    dragController: TimelineDragController,
+    modifier: Modifier = Modifier,
+) {
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
+    // Derived: the drag is rewritten every frame, its snapped start once a slot.
+    val dragStartMin by remember(dragController) {
+        derivedStateOf { dragController.drag?.startMin }
+    }
+    val hourAlpha by animateFloatAsState(
+        targetValue = if (dragStartMin != null) DIMMED_HOUR_ALPHA else 1f,
+        label = "hourLabelAlpha",
+    )
+
+    Box(
+        modifier = modifier
+            .width(GUTTER_WIDTH)
+            .padding(start = GUTTER_CONTENT_START_INSET)
+            .fillMaxHeight()
+            .verticalScroll(scrollState),
+    ) {
+        Column {
+            (0 until 24).forEach { h ->
+                Box(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(hourHeight),
+                ) {
+                    if (h > 0) {
+                        Text(
+                            text = formatHourLabel(h, use24Hour, locale),
+                            style = MaterialTheme.typography.labelSmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                                .copy(alpha = hourAlpha),
+                            modifier = Modifier
+                                .align(Alignment.TopCenter)
+                                .offset(y = (-6).dp),
+                        )
+                    }
+                }
+            }
+        }
+        dragStartMin?.let { startMin ->
+            val top = (hourHeight * (startMin / 60f) - BADGE_HEIGHT / 2).coerceAtLeast(0.dp)
+            Box(
+                modifier = Modifier
+                    .align(Alignment.TopCenter)
+                    .offset(y = top)
+                    .height(BADGE_HEIGHT)
+                    .background(MaterialTheme.colorScheme.primary, CircleShape)
+                    .padding(horizontal = 4.dp)
+                    // The dragged block already announces this time.
+                    .clearAndSetSemantics { },
+                contentAlignment = Alignment.Center,
+            ) {
+                Text(
+                    text = formatGutterTime(startMin, use24Hour, locale),
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onPrimary,
+                    maxLines = 1,
+                    softWrap = false,
+                )
+            }
+        }
+    }
+}

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

@@ -1,6 +1,10 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.style.TextDecoration
 import kotlin.time.Instant
 
 /**
@@ -14,3 +18,30 @@ val LocalDimCutoff = compositionLocalOf<Instant?> { null }
 
 /** Opacity applied to a completed/past event chip when it is dimmed. */
 const val EventDimAlpha = 0.4f
+
+/**
+ * How a declined invitation's title is struck through (#180) — the mark every
+ * surface uses to say "you answered no", chosen over hiding the event because it
+ * is still something the organiser expects you at. Null for everything else, so
+ * it drops straight into a `Text`'s `textDecoration`.
+ */
+fun declinedDecoration(isDeclined: Boolean): TextDecoration? =
+    if (isDeclined) TextDecoration.LineThrough else null
+
+/** [declinedDecoration] for the rows that take styled text rather than a `String`. */
+fun declinedTitle(title: String, isDeclined: Boolean): AnnotatedString = if (isDeclined) {
+    AnnotatedString(title, SpanStyle(textDecoration = TextDecoration.LineThrough))
+} else {
+    AnnotatedString(title)
+}
+
+/** [declinedTitle] over already-styled text, e.g. a search hit's marked runs. */
+fun declinedTitle(title: AnnotatedString, isDeclined: Boolean): AnnotatedString =
+    if (!isDeclined) {
+        title
+    } else {
+        buildAnnotatedString {
+            append(title)
+            addStyle(SpanStyle(textDecoration = TextDecoration.LineThrough), 0, title.length)
+        }
+    }

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

@@ -0,0 +1,169 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atTime
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Instant
+
+/**
+ * Stand-in events for the view previews. A preview has no business querying the
+ * provider for a thumbnail, so every chooser renders the same invented week.
+ *
+ * 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 views actually draw.
+ */
+private val SAMPLE_COLORS = listOf(
+    0xFF3F7BD4.toInt(),
+    0xFFCE5B4C.toInt(),
+    0xFF4E9A6A.toInt(),
+    0xFF8A63C7.toInt(),
+)
+
+private val SAMPLE_TITLES = listOf(
+    "Standup",
+    "Lunch",
+    "Review",
+    "Gym",
+    "Call",
+    "Workshop",
+    "Dentist",
+    "Trip",
+)
+
+/** Hands out [EventInstance]s with running ids and cycling sample titles/colours. */
+private class SampleEvents(private val zone: TimeZone) {
+    private var id = 0L
+
+    fun timed(
+        day: LocalDate,
+        hour: Int,
+        minute: Int = 0,
+        lengthMinutes: Int,
+        colorIndex: Int,
+    ): EventInstance {
+        val start = day.atTime(hour, minute).toInstant(zone)
+        return build(
+            start = start,
+            end = start + lengthMinutes.minutes,
+            isAllDay = false,
+            colorIndex = colorIndex,
+        )
+    }
+
+    fun allDay(from: LocalDate, days: Int, colorIndex: Int): EventInstance = build(
+        // All-day events sit at UTC midnights with an exclusive end.
+        start = from.atTime(0, 0).toInstant(TimeZone.UTC),
+        end = from.plus(days, DateTimeUnit.DAY).atTime(0, 0).toInstant(TimeZone.UTC),
+        isAllDay = true,
+        colorIndex = colorIndex,
+    )
+
+    private fun build(
+        start: Instant,
+        end: Instant,
+        isAllDay: Boolean,
+        colorIndex: Int,
+    ): EventInstance {
+        val next = ++id
+        return EventInstance(
+            instanceId = next,
+            eventId = next,
+            calendarId = 1L,
+            title = SAMPLE_TITLES[(next.toInt() - 1) % SAMPLE_TITLES.size],
+            start = start,
+            end = end,
+            isAllDay = isAllDay,
+            color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
+            location = null,
+        )
+    }
+}
+
+/**
+ * A month's worth of stand-ins, spread so most weeks carry something, with one
+ * multi-day bar bridging cells and a busy today for the split pane.
+ */
+internal fun sampleMonthEvents(
+    firstOfMonth: LocalDate,
+    today: LocalDate,
+    zone: TimeZone,
+): List<EventInstance> {
+    val sample = SampleEvents(zone)
+    return buildList {
+        add(sample.allDay(firstOfMonth.plus(9, DateTimeUnit.DAY), days = 3, colorIndex = 2))
+        add(sample.timed(firstOfMonth.plus(1, DateTimeUnit.DAY), 9, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(firstOfMonth.plus(4, DateTimeUnit.DAY), 14, lengthMinutes = 120, colorIndex = 1))
+        add(sample.timed(firstOfMonth.plus(7, DateTimeUnit.DAY), 11, lengthMinutes = 60, colorIndex = 3))
+        add(sample.timed(firstOfMonth.plus(15, DateTimeUnit.DAY), 10, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(firstOfMonth.plus(18, DateTimeUnit.DAY), 16, lengthMinutes = 60, colorIndex = 2))
+        add(sample.timed(firstOfMonth.plus(22, DateTimeUnit.DAY), 8, lengthMinutes = 120, colorIndex = 1))
+        add(sample.timed(firstOfMonth.plus(25, DateTimeUnit.DAY), 13, lengthMinutes = 60, colorIndex = 3))
+        // Today, so the split pane's list and the grid's dots both have content.
+        add(sample.timed(today, 9, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(today, 12, lengthMinutes = 60, colorIndex = 1))
+        add(sample.timed(today, 15, lengthMinutes = 120, colorIndex = 3))
+    }
+}
+
+/**
+ * Stand-ins for a timeline preview over [days]. [anchor] — the day the preview
+ * is centred on — gets the busy set, including one overlapping pair so the
+ * side-by-side lane layout shows; the rest of the week is sparser. A multi-day
+ * all-day bar is only added when there is more than one column to span.
+ */
+internal fun sampleTimelineEvents(
+    days: List<LocalDate>,
+    anchor: LocalDate,
+    zone: TimeZone,
+): List<EventInstance> {
+    val sample = SampleEvents(zone)
+    return buildList {
+        if (days.size > 1) {
+            add(sample.allDay(days[days.size / 2], days = 2, colorIndex = 2))
+        } else {
+            add(sample.allDay(anchor, days = 1, colorIndex = 2))
+        }
+        // The anchor day: enough to fill the column, with 09:30–11:00 running
+        // under 09:00–10:00 so the overlap resolves into two lanes.
+        add(sample.timed(anchor, 9, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(anchor, 9, minute = 30, lengthMinutes = 90, colorIndex = 1))
+        add(sample.timed(anchor, 13, lengthMinutes = 120, colorIndex = 3))
+        days.filterNot { it == anchor }.forEachIndexed { index, day ->
+            // Skip every third day so the week doesn't read as a solid block.
+            if (index % 3 == 2) return@forEachIndexed
+            add(
+                sample.timed(
+                    day = day,
+                    hour = 8 + (index * 3) % 9,
+                    lengthMinutes = if (index % 2 == 0) 60 else 90,
+                    colorIndex = index,
+                ),
+            )
+        }
+    }
+}
+
+/**
+ * Stand-ins for the agenda preview: a forward-looking fortnight where the first
+ * days are busy and later ones thin out, so the grouped-by-day list shows both
+ * a full day and the gaps between days.
+ */
+internal fun sampleAgendaEvents(today: LocalDate, zone: TimeZone): List<EventInstance> {
+    val sample = SampleEvents(zone)
+    return buildList {
+        add(sample.timed(today, 9, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(today, 12, minute = 30, lengthMinutes = 60, colorIndex = 1))
+        add(sample.timed(today, 16, lengthMinutes = 90, colorIndex = 3))
+        val tomorrow = today.plus(1, DateTimeUnit.DAY)
+        add(sample.allDay(tomorrow, days = 2, colorIndex = 2))
+        add(sample.timed(tomorrow, 10, lengthMinutes = 120, colorIndex = 1))
+        add(sample.timed(today.plus(3, DateTimeUnit.DAY), 14, lengthMinutes = 60, colorIndex = 0))
+        add(sample.timed(today.plus(6, DateTimeUnit.DAY), 11, lengthMinutes = 60, colorIndex = 3))
+        add(sample.timed(today.plus(10, DateTimeUnit.DAY), 18, lengthMinutes = 120, colorIndex = 2))
+    }
+}

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

@@ -0,0 +1,69 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.floret.components.OptionCard
+
+/**
+ * How far a write to a recurring event should reach: this occurrence, it and
+ * everything after (a series split), or the whole series. Shared by the edit
+ * screen's save and a drag-and-drop reschedule; one of the two carve-outs from
+ * the full-screen picker rule.
+ *
+ * [allowOccurrence] drops "only this event" (an exception row can't carry its own
+ * rule); [allowSeries] drops the two wider options, for a rule whose days can't
+ * be recalculated from one moved occurrence — [reason] then says why.
+ */
+@Composable
+fun RecurringScopeDialog(
+    title: String,
+    onSelect: (RecurringWriteScope) -> Unit,
+    onDismiss: () -> Unit,
+    allowOccurrence: Boolean = true,
+    allowSeries: Boolean = true,
+    reason: String? = null,
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(title) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                if (reason != null) {
+                    Text(
+                        text = reason,
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+                if (allowOccurrence) {
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_occurrence),
+                        onClick = { onSelect(RecurringWriteScope.ThisEvent) },
+                    )
+                }
+                if (allowSeries) {
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_following),
+                        onClick = { onSelect(RecurringWriteScope.ThisAndFollowing) },
+                    )
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_series),
+                        onClick = { onSelect(RecurringWriteScope.AllEvents) },
+                    )
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
+        },
+    )
+}

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

@@ -0,0 +1,483 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.domain.EventDetail
+import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.EventFormProblem
+import de.jeanlucmakiola.calendula.domain.RecurrenceEnd
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.allowsEventMove
+import de.jeanlucmakiola.calendula.domain.parseSimpleRecurrence
+import de.jeanlucmakiola.calendula.domain.problems
+import de.jeanlucmakiola.calendula.domain.realignRecurrence
+import de.jeanlucmakiola.calendula.domain.resolvedZone
+import de.jeanlucmakiola.calendula.domain.shiftedByDays
+import de.jeanlucmakiola.calendula.domain.shiftedTo
+import de.jeanlucmakiola.calendula.domain.toEditForm
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.coroutines.cancellation.CancellationException
+import kotlin.time.Instant
+import javax.inject.Inject
+
+private const val MILLIS_PER_MINUTE = 60_000
+private const val MINUTES_PER_DAY = 24 * 60
+
+/** Where a dragged event should land. */
+sealed interface MoveTarget {
+    /** A new start instant — a timeline drag, which moves time and day at once. */
+    data class Start(val instant: Instant) : MoveTarget
+
+    /**
+     * A whole-day shift, keeping the time of day — a month-grid or all-day drag.
+     * A delta rather than a target date, so the screen and this view model can't
+     * disagree by a day over which zone the event's first day is resolved in.
+     */
+    data class ByDays(val days: Int) : MoveTarget
+}
+
+/**
+ * One dropped event. [beginMillis]/[endMillis] are the dragged *occurrence's*
+ * own times (`Instances.BEGIN`/`END`), as the detail and edit screens pass them.
+ */
+data class MoveRequest(
+    val eventId: Long,
+    val beginMillis: Long,
+    val endMillis: Long,
+    val target: MoveTarget,
+)
+
+/**
+ * A recurring drop waiting for the user to pick how far it reaches.
+ * [occurrenceOnly] means a wider write would leave the rule and the series
+ * anchor disagreeing — either the rule names days one moved occurrence can't
+ * re-derive (`BYDAY=MO,WE`, `2TH`, …), or the shift wouldn't carry the anchor
+ * across the same midnights the occurrence crossed.
+ */
+data class MoveScopePrompt(val occurrenceOnly: Boolean)
+
+/** The inverse of a completed move, for the undo action. */
+data class MoveUndo(
+    val eventId: Long,
+    /** The form as it now stands (the moved state). */
+    val moved: EventForm,
+    /** The form as it stood before the move. */
+    val restored: EventForm,
+)
+
+sealed interface MoveOutcome {
+    /**
+     * Written. [startMillis] is where the dragged occurrence now begins, for the
+     * confirmation message; [undo] is null when the write has no clean inverse.
+     */
+    data class Moved(
+        val startMillis: Long,
+        val isAllDay: Boolean,
+        val undo: MoveUndo?,
+    ) : MoveOutcome
+
+    data object Undone : MoveOutcome
+
+    /** `WRITE_CALENDAR` was revoked between the drop and the provider call. */
+    data object WriteDenied : MoveOutcome
+
+    /** The event vanished (sync, another device) between the read and the write. */
+    data object Gone : MoveOutcome
+
+    /** The drop would push the series past its own `UNTIL`, generating nothing. */
+    data object BlockedSeriesEnd : MoveOutcome
+
+    data object Failed : MoveOutcome
+}
+
+/**
+ * Writes a drag-and-drop reschedule (#68) through the same repository calls the
+ * edit screen's save uses, so recurring writes, reminder reconciliation and
+ * attendee preservation behave identically. Hosted at `CalendarHost` so one
+ * instance serves every calendar view and survives view switches. The full
+ * prefilled form is carried through the write — a stripped one would wipe the
+ * reminders and attendees the occurrence-exception path reconciles.
+ */
+@HiltViewModel
+class RescheduleViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    private val _scopePrompt = MutableStateFlow<MoveScopePrompt?>(null)
+    val scopePrompt: StateFlow<MoveScopePrompt?> = _scopePrompt.asStateFlow()
+
+    private val _outcome = MutableStateFlow<MoveOutcome?>(null)
+    val outcome: StateFlow<MoveOutcome?> = _outcome.asStateFlow()
+
+    private var pending: PreparedMove? = null
+
+    private val _inFlight = MutableStateFlow(false)
+
+    /**
+     * True from the moment a drop is accepted until its write settles — the
+     * window the dropped block holds its landing position for.
+     */
+    val inFlight: StateFlow<Boolean> = _inFlight.asStateFlow()
+
+    private val _abandoned = MutableStateFlow(0)
+
+    /**
+     * Ticks when a drop ends with nothing on the target day: refused outright,
+     * refused before the write, written and failed, or its scope dialog
+     * dismissed. [move] answers before any of that is known, so without this
+     * signal the view that drew the drop held its copy out for the full settle
+     * timeout waiting for a grid that was never going to draw it (#253).
+     */
+    val abandoned: StateFlow<Int> = _abandoned.asStateFlow()
+
+    private val _undoStarted = MutableStateFlow(0)
+
+    /**
+     * Ticks the moment an undo write begins, before the provider has anything to
+     * re-read, so the view that drew the drop can carry its chip back rather than
+     * let it reappear on the old day.
+     */
+    val undoStarted: StateFlow<Int> = _undoStarted.asStateFlow()
+
+    /**
+     * Set from the moment a drop is accepted until its write settles. Two drops
+     * of the same recurring event inside that window would compute their shift
+     * from the same pre-move occurrence, and the shifts would compound.
+     */
+    private var busy = false
+        set(value) {
+            field = value
+            _inFlight.value = value
+        }
+
+    /**
+     * The calendars whose events may be dragged. Nothing below the UI guards
+     * this, so a block outside this set registers no drag gesture at all.
+     */
+    val movableCalendarIds: StateFlow<Set<Long>> = repository.calendars()
+        .map { calendars -> calendars.filter { it.allowsEventMove }.map { it.id }.toSet() }
+        .catch { emit(emptySet<Long>()) }
+        .flowOn(io)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = emptySet(),
+        )
+
+    /** Everything a drop needs, resolved before anything is written. */
+    private data class PreparedMove(
+        val request: MoveRequest,
+        val original: EventForm,
+        val updated: EventForm,
+        /** True for a series master with a rule — an exception row is not one. */
+        val isRecurring: Boolean,
+        /** False when the rule names days this move can't re-derive. */
+        val canRealign: Boolean,
+        /** The series row's DTSTART date after the move — what its `UNTIL` must clear. */
+        val newAnchorDate: LocalDate,
+    )
+
+    /**
+     * Take a drop, unless one is already being written. False means nothing will
+     * be written; [abandoned] ticks for that refusal too, so a held copy is let
+     * go by the one signal rather than by every caller remembering to.
+     */
+    fun move(request: MoveRequest): Boolean {
+        if (busy || _scopePrompt.value != null) {
+            _abandoned.value += 1
+            return false
+        }
+        busy = true
+        viewModelScope.launch {
+            val prepared = prepare(request)
+            if (prepared == null) {
+                _abandoned.value += 1
+                busy = false
+                return@launch
+            }
+            if (!prepared.isRecurring) {
+                write(prepared, RecurringWriteScope.AllEvents)
+                busy = false
+            } else {
+                // Still busy: the scope dialog is now the thing in flight.
+                pending = prepared
+                _scopePrompt.value = MoveScopePrompt(occurrenceOnly = !prepared.canRealign)
+            }
+        }
+        return true
+    }
+
+    /** Answer the scope dialog. */
+    fun moveWithScope(scope: RecurringWriteScope) {
+        val prepared = pending ?: return
+        // Guard against the dialog ever offering a scope the rule can't carry.
+        if (!prepared.canRealign && scope != RecurringWriteScope.ThisEvent) return
+        pending = null
+        _scopePrompt.value = null
+        viewModelScope.launch {
+            write(prepared, scope)
+            busy = false
+        }
+    }
+
+    /** Dismiss the scope dialog without writing. */
+    fun cancelScope() {
+        pending = null
+        busy = false
+        _scopePrompt.value = null
+        _abandoned.value += 1
+    }
+
+    /**
+     * Put a completed move back where it came from. The outcome stands until the
+     * inverse write reports back, so the one chip changes what it says rather
+     * than closing and reopening. False when another write is already running —
+     * the chip hides its action for that window, so this is the backstop.
+     */
+    fun undo(undo: MoveUndo): Boolean {
+        if (busy) return false
+        busy = true
+        _undoStarted.value += 1
+        viewModelScope.launch {
+            _outcome.value = try {
+                repository.updateEvent(undo.eventId, undo.moved, undo.restored)
+                MoveOutcome.Undone
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: SecurityException) {
+                MoveOutcome.WriteDenied
+            } catch (e: NoSuchEventException) {
+                MoveOutcome.Gone
+            } catch (e: Exception) {
+                MoveOutcome.Failed
+            }
+            busy = false
+        }
+        return true
+    }
+
+    /** Clear the outcome once the screen has shown it. */
+    fun consumeOutcome() {
+        _outcome.value = null
+    }
+
+    private suspend fun prepare(request: MoveRequest): PreparedMove? {
+        val detail = try {
+            repository.eventDetail(request.eventId)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: NoSuchEventException) {
+            _outcome.value = MoveOutcome.Gone
+            return null
+        } catch (e: Exception) {
+            _outcome.value = MoveOutcome.Failed
+            return null
+        }
+
+        val zone = TimeZone.currentSystemDefault()
+        val original = detail.toEditForm(request.beginMillis, request.endMillis, zone)
+        val shifted = when (val target = request.target) {
+            is MoveTarget.Start -> original.shiftedTo(target.instant, zone)
+            is MoveTarget.ByDays -> original.shiftedByDays(target.days, zone)
+        }
+        // A zero-distance drop is not a write.
+        if (shifted == original) return null
+
+        // The UNTIL check is deferred to the write, which knows how far the move
+        // reaches and so which date has to clear it.
+        if ((shifted.problems() - EventFormProblem.RecurrenceEndsBeforeStart).isNotEmpty()) {
+            _outcome.value = MoveOutcome.Failed
+            return null
+        }
+
+        // An exception row stands alone whatever rule a sync adapter left on it.
+        val isRecurring = original.rrule != null && !detail.isException
+        val movedDay = shifted.start.date != original.start.date
+        // The series anchor moves by the same *wall-clock* shift as the dragged
+        // occurrence, so only a whole-day shift carries it across the same number
+        // of midnights whatever time of day it sits at. A same-date drag has its
+        // own, narrower check — see anchorKeepsItsDay.
+        val wholeDayShift = original.isAllDay || shifted.start.time == original.start.time
+        val realigned = if (isRecurring && movedDay) {
+            if (wholeDayShift) {
+                realignRecurrence(
+                    requireNotNull(original.rrule),
+                    original.start.date,
+                    shifted.start.date,
+                )
+            } else {
+                null
+            }
+        } else {
+            original.rrule
+        }
+        return PreparedMove(
+            request = request,
+            original = original,
+            // A rule we can't re-derive stays verbatim: the only scope offered
+            // then is the single occurrence, whose exception row carries no rule.
+            updated = shifted.copy(rrule = realigned ?: original.rrule),
+            isRecurring = isRecurring,
+            canRealign = when {
+                !isRecurring -> true
+                movedDay -> realigned != null
+                else -> anchorKeepsItsDay(detail, original, shifted, zone)
+            },
+            // Where the series row's own DTSTART lands, given the anchor moves by
+            // the same shift. Only read under canRealign, which is what
+            // guarantees the anchor really does travel this many days.
+            newAnchorDate = anchorDate(detail, original, zone)
+                .plus(shifted.start.date.toEpochDays() - original.start.date.toEpochDays(), DateTimeUnit.DAY),
+        )
+    }
+
+    private suspend fun write(prepared: PreparedMove, scope: RecurringWriteScope) {
+        val request = prepared.request
+        if (endsBeforeItStarts(prepared, scope)) {
+            _outcome.value = MoveOutcome.BlockedSeriesEnd
+            _abandoned.value += 1
+            return
+        }
+        _outcome.value = try {
+            when {
+                !prepared.isRecurring || scope == RecurringWriteScope.AllEvents ->
+                    repository.updateEvent(request.eventId, prepared.original, prepared.updated)
+
+                scope == RecurringWriteScope.ThisEvent ->
+                    repository.updateOccurrence(
+                        request.eventId,
+                        request.beginMillis,
+                        prepared.updated,
+                    )
+
+                else -> repository.updateEventFromOccurrence(
+                    eventId = request.eventId,
+                    beginMillis = request.beginMillis,
+                    original = prepared.original,
+                    updated = prepared.updated,
+                )
+            }
+            MoveOutcome.Moved(
+                startMillis = movedStartMillis(prepared),
+                isAllDay = prepared.updated.isAllDay,
+                undo = undoFor(prepared, scope),
+            )
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: SecurityException) {
+            MoveOutcome.WriteDenied
+        } catch (e: NoSuchEventException) {
+            MoveOutcome.Gone
+        } catch (e: Exception) {
+            MoveOutcome.Failed
+        }
+        // Nothing landed, so the copy the view is holding has nothing to fade
+        // into — let it go now rather than at the end of the settle timeout.
+        if (_outcome.value !is MoveOutcome.Moved) _abandoned.value += 1
+    }
+
+    /**
+     * Whether this write would leave a rule whose `UNTIL` precedes the first day
+     * it now applies to — the provider then generates nothing at all. Which date
+     * has to clear `UNTIL` depends on the scope: a whole-series move carries the
+     * series *anchor*, a split starts at the moved occurrence, and a single
+     * occurrence becomes an exception row that no `UNTIL` constrains.
+     */
+    private fun endsBeforeItStarts(prepared: PreparedMove, scope: RecurringWriteScope): Boolean {
+        if (!prepared.isRecurring || scope == RecurringWriteScope.ThisEvent) return false
+        val rule = prepared.updated.rrule ?: return false
+        val end = parseSimpleRecurrence(rule)?.end as? RecurrenceEnd.Until ?: return false
+        val firstDay = if (scope == RecurringWriteScope.AllEvents) {
+            prepared.newAnchorDate
+        } else {
+            prepared.updated.start.date
+        }
+        return end.date < firstDay
+    }
+
+    /**
+     * Whether a same-date drag leaves the series anchor on its own day too. The
+     * anchor moves by the same wall-clock delta as the occurrence, and normally
+     * shares its time of day — but a row with no `EVENT_TIMEZONE` resolves the
+     * two in zones that can sit a DST hour apart, so a near-midnight drag could
+     * carry the anchor across a midnight the occurrence never crossed and leave
+     * `BYDAY` naming the wrong weekday.
+     */
+    private fun anchorKeepsItsDay(
+        detail: EventDetail,
+        original: EventForm,
+        shifted: EventForm,
+        zone: TimeZone,
+    ): Boolean {
+        val anchorZone = if (original.isAllDay) TimeZone.UTC else original.resolvedZone(zone)
+        val anchorMinute = detail.instance.start.toLocalDateTime(anchorZone)
+            .time.toMillisecondOfDay() / MILLIS_PER_MINUTE
+        val delta = (
+            shifted.start.time.toMillisecondOfDay() - original.start.time.toMillisecondOfDay()
+            ) / MILLIS_PER_MINUTE
+        return anchorMinute + delta in 0 until MINUTES_PER_DAY
+    }
+
+    /**
+     * The series row's own start date — for a recurring master, `EventDetail`
+     * carries the row's DTSTART rather than the tapped occurrence's. Read in the
+     * same anchoring the write path uses: UTC for an all-day series.
+     */
+    private fun anchorDate(detail: EventDetail, original: EventForm, zone: TimeZone): LocalDate =
+        detail.instance.start
+            .toLocalDateTime(if (original.isAllDay) TimeZone.UTC else original.resolvedZone(zone))
+            .date
+
+    /**
+     * Undo is offered only where the inverse is one symmetric write: a
+     * non-recurring event, and a whole-series move. "This event" leaves an
+     * exception row behind and "this and following" splits the series with an
+     * UNTIL truncation — neither is undone by shifting back.
+     */
+    private fun undoFor(prepared: PreparedMove, scope: RecurringWriteScope): MoveUndo? =
+        if (!prepared.isRecurring || scope == RecurringWriteScope.AllEvents) {
+            MoveUndo(
+                eventId = prepared.request.eventId,
+                moved = prepared.updated,
+                restored = prepared.original,
+            )
+        } else {
+            null
+        }
+
+    /**
+     * Where the dragged occurrence now begins, in the same anchoring the views
+     * read dates back in: UTC midnight for an all-day event.
+     */
+    private fun movedStartMillis(prepared: PreparedMove): Long {
+        val form = prepared.updated
+        return if (form.isAllDay) {
+            form.start.date.atStartOfDayIn(TimeZone.UTC).toEpochMilliseconds()
+        } else {
+            form.start.toInstant(form.resolvedZone(TimeZone.currentSystemDefault()))
+                .toEpochMilliseconds()
+        }
+    }
+
+}

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

@@ -17,6 +17,7 @@ val LocalUse24HourFormat = staticCompositionLocalOf { true }
 private const val PATTERN_24 = "HH:mm"
 private const val PATTERN_12 = "h:mm a"
 private const val HOUR_PATTERN_12 = "h a"
+private const val HOUR_MINUTE_PATTERN_12 = "h:mm"
 
 /** A time-of-day [DateTimeFormatter] for the resolved convention and [locale]. */
 fun timeOfDayFormatter(is24Hour: Boolean, locale: Locale): DateTimeFormatter =
@@ -42,6 +43,18 @@ fun formatMinuteOfDay(minutes: Int, is24Hour: Boolean, locale: Locale): String =
     else -> formatTimeOfDay(minutes / 60, minutes % 60, is24Hour, locale)
 }
 
+/**
+ * The time shown in the timeline gutter while a block is dragged: 24h →
+ * "09:15", 12h → "9:15". The meridiem is dropped — the hour labels around it
+ * already carry it, and the gutter is too narrow.
+ */
+fun formatGutterTime(minutes: Int, is24Hour: Boolean, locale: Locale): String {
+    val clamped = minutes.coerceIn(0, MINUTES_PER_DAY - 1)
+    val pattern = if (is24Hour) PATTERN_24 else HOUR_MINUTE_PATTERN_12
+    return LocalTime.of(clamped / 60, clamped % 60)
+        .format(DateTimeFormatter.ofPattern(pattern, locale))
+}
+
 /**
  * The compact hour-only label for a timeline gutter: 24h → "13" (zero-padded,
  * the prior look); 12h → "1 PM".

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

@@ -0,0 +1,702 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.ScrollState
+import androidx.compose.foundation.MutatePriority
+import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.absoluteOffset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.positionInRoot
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.week.MINUTES_PER_DAY
+import de.jeanlucmakiola.calendula.ui.week.TimedBlock
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
+import de.jeanlucmakiola.floret.locale.currentLocale
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.plus
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.math.roundToInt
+import kotlin.time.Instant
+
+/** Start granularity a dragged block snaps to, matching the big calendar apps. */
+const val DRAG_SNAP_MINUTES: Int = 15
+
+/** How close to a timeline edge the finger must get before the view scrolls. */
+private val AUTO_SCROLL_EDGE = 64.dp
+
+/** Fastest auto-scroll step, per frame, right at the edge. */
+private val AUTO_SCROLL_STEP = 16.dp
+
+/** A block being dragged, in root coordinates so it can be drawn in an overlay. */
+data class TimelineDrag(
+    val event: EventInstance,
+    val date: LocalDate,
+    /**
+     * Where the dragged *block's* top edge now sits, in minutes from [date]'s
+     * midnight. The gesture's own quantity — what snaps, what the haptics tick
+     * on, and what the drop is expressed in. Not the event's start: for the tail
+     * of an event that began the day before, the two are a clip offset apart.
+     */
+    val startMin: Int,
+    /** The event's new start, from [date]'s midnight — negative if it began earlier. */
+    val eventStartMin: Int,
+    val eventSpanMin: Int,
+    /** The event as the grid would draw it, one piece per day column it covers. */
+    val pieces: List<TimelineDragPiece>,
+) {
+    /** What the snap haptics key off: one tick per changed slot, not per frame. */
+    val slot: Pair<LocalDate, Int> get() = date to startMin
+}
+
+/**
+ * One day column's share of a dragged event, ready to draw. Both halves of an
+ * event crossing midnight are previewed, whichever half the finger picked up:
+ * showing only the held one made the event read as growing rather than moving,
+ * since the day beside it still stood at the block's old extent (#253).
+ */
+data class TimelineDragPiece(
+    val topLeftInRoot: Offset,
+    val sizePx: IntSize,
+    val continuesBefore: Boolean,
+    val continuesAfter: Boolean,
+)
+
+/**
+ * How a run of [spanMin] minutes beginning [eventStartMin] minutes into a day —
+ * negative when it began on an earlier one — falls across day columns, as
+ * offsets from that day. Every slice but the first and last is a whole day, and
+ * the flags say which edges are cuts rather than the event's own ends.
+ *
+ * [within] bounds the day offsets that have a column to draw in, so a very long
+ * event doesn't slice days no one can see.
+ */
+internal fun dragSlices(
+    eventStartMin: Int,
+    spanMin: Int,
+    within: IntRange? = null,
+): List<DragSlice> {
+    val span = spanMin.coerceAtLeast(0)
+    val end = eventStartMin + span
+    val first = eventStartMin.floorDiv(MINUTES_PER_DAY)
+    // A zero-length event still has a block, on the one day it sits in.
+    val last = maxOf((end - 1).floorDiv(MINUTES_PER_DAY), first)
+    val from = maxOf(first, within?.first ?: first)
+    val to = minOf(last, within?.last ?: last)
+    if (from > to) return emptyList()
+    return (from..to).map { day ->
+        val dayStart = day * MINUTES_PER_DAY
+        val sliceStart = maxOf(eventStartMin - dayStart, 0)
+        val sliceEnd = minOf(end - dayStart, MINUTES_PER_DAY)
+        DragSlice(
+            dayOffset = day,
+            startMin = sliceStart,
+            spanMin = sliceEnd - sliceStart,
+            continuesBefore = day > first,
+            continuesAfter = day < last,
+        )
+    }
+}
+
+/**
+ * How far above its day's midnight a block's top edge may be dragged. Zero for
+ * an ordinary block, whose top edge is the event's own start. A tail clipped at
+ * midnight has to go lower: its top edge *is* midnight and stays there however
+ * much earlier the event moves, so pinning it at zero made dragging the second
+ * half earlier a no-op (#253). It may rise until the event's end reaches one
+ * snap step into this day — or by a single step, for a tail too short to afford
+ * even that, which then leaves the day for the one before it.
+ */
+internal fun dragFloorMin(clipOffsetMin: Int, eventSpanMin: Int): Int =
+    if (clipOffsetMin > 0) {
+        minOf(-DRAG_SNAP_MINUTES, DRAG_SNAP_MINUTES + clipOffsetMin - eventSpanMin)
+    } else {
+        0
+    }
+
+/** One day's share of a dragged event, before it is placed on screen. */
+internal data class DragSlice(
+    val dayOffset: Int,
+    val startMin: Int,
+    val spanMin: Int,
+    val continuesBefore: Boolean,
+    val continuesAfter: Boolean,
+)
+
+/**
+ * Where a finished drag asks its event to go. [date]/[startMin] are where the
+ * dragged *block's* top edge landed, which is the event's own start only for a
+ * block that isn't clipped — see [clipOffsetMin] and [startInstant].
+ */
+data class TimelineDrop(
+    val event: EventInstance,
+    val date: LocalDate,
+    val startMin: Int,
+    /** Minutes from the event's start to the dragged block's top edge. */
+    val clipOffsetMin: Int = 0,
+)
+
+/**
+ * The timeline's live geometry, republished on every layout. Plain fields rather
+ * than snapshot state: it changes on every scroll frame, and the drag loop reads
+ * it per frame anyway.
+ */
+class TimelineGeometry {
+    /** The day-columns row — scrolling *content*, so its root position folds in the scroll. */
+    var grid: LayoutCoordinates? = null
+
+    /** The scroll viewport, for the edge that triggers auto-scrolling. */
+    var viewport: LayoutCoordinates? = null
+    var scroll: ScrollState? = null
+    var hourPx: Float = 0f
+
+    /** Column pitch — one column plus the gap after it. */
+    var columnWidthPx: Float = 0f
+    var columnGapPx: Float = 0f
+    var edgePx: Float = 0f
+    var stepPx: Float = 0f
+    var days: List<LocalDate> = emptyList()
+
+    /**
+     * Whether the columns are laid out right-to-left. Pointer coordinates are
+     * never mirrored but the grid is, so the mapping has to flip with it.
+     */
+    var isRtl: Boolean = false
+}
+
+/**
+ * Hoisted drag state for one timeline (#68). It lives above the per-page
+ * `AnimatedContent`, so a page change mid-drag can't strand a ghost, and the
+ * block it renders is drawn in an overlay, clear of the day column's clip.
+ */
+@Stable
+class TimelineDragController {
+    val geometry = TimelineGeometry()
+
+    var drag: TimelineDrag? by mutableStateOf(null)
+        private set
+
+    /**
+     * A dropped block, held at the slot it landed on while the write runs — the
+     * grid behind it still shows the old time until the query re-reads.
+     */
+    var settling: TimelineDrag? by mutableStateOf(null)
+        private set
+
+    /**
+     * Which block is lifted, and whether anything is. Separate snapshot state
+     * from [drag], which changes every frame, so blocks that only need "am I the
+     * ghost" don't recompose that often. Stays set through [settling].
+     */
+    var liftedInstanceId: Long? by mutableStateOf(null)
+        private set
+
+    /**
+     * The event row and start instant the settled drop came from. The instance id
+     * alone can't identify the source for the length of the write: the provider
+     * regenerates `Instances` rows, so a re-read carrying the *old* time can
+     * arrive under a new instance id. Matching the start instant rather than a
+     * single day and slot keeps *both* halves of an event that crosses midnight
+     * ghosted until the write lands (#253).
+     */
+    private var settledOrigin: Pair<Long, Instant>? by mutableStateOf(null)
+
+    /** Whether a finger is on a block right now — [settling] is not dragging. */
+    var isDragging: Boolean by mutableStateOf(false)
+        private set
+
+    /**
+     * Whether the grid itself now draws the settled drop at its landing slot.
+     * The copy may only be handed back once this is true, or the source ghost
+     * flashes back to full opacity in its old slot.
+     */
+    var settledOnGrid: Boolean by mutableStateOf(false)
+        private set
+
+    /**
+     * The abandoned-move counter, read at the drop so the mark can't be a
+     * composition behind the tick it is compared against.
+     */
+    var abandonedTicks: StateFlow<Int>? = null
+
+    /** What [abandonedTicks] stood at when the settling drop was let go. */
+    var settledAbandonedMark: Int = 0
+        private set
+
+    private var source: TimedBlock? = null
+    private var grab = Offset.Zero
+    private var pointer = Offset.Zero
+
+    /**
+     * How far the picked-up block's top edge sits past the event's own start —
+     * nonzero only for a block clipped at midnight, which is the tail of an
+     * event that began the day before (#253). The gesture tracks the block the
+     * finger is on; this is what turns where it lands back into an event start.
+     */
+    private var clipOffsetMin = 0
+
+    /**
+     * The slot the block already occupied when it was picked up — not the same
+     * as its start, since the target snaps to the grid (09:07 lifts to 09:00).
+     */
+    private var originSlot: Pair<LocalDate, Int>? = null
+
+    fun begin(
+        block: TimedBlock,
+        clipOffsetMin: Int,
+        pointerInRoot: Offset,
+        blockInRoot: Offset,
+    ) {
+        source = block
+        this.clipOffsetMin = clipOffsetMin
+        settling = null
+        isDragging = true
+        liftedInstanceId = block.event.instanceId
+        grab = pointerInRoot - blockInRoot
+        pointer = pointerInRoot
+        originSlot = null
+        recompute()
+        originSlot = drag?.slot
+    }
+
+    fun move(pointerInRoot: Offset) {
+        pointer = pointerInRoot
+        recompute()
+    }
+
+    fun cancel() {
+        source = null
+        clipOffsetMin = 0
+        isDragging = false
+        liftedInstanceId = null
+        originSlot = null
+        drag = null
+        settling = null
+        settledOnGrid = false
+        settledOrigin = null
+    }
+
+    /**
+     * Whether [block] is part of the event whose copy is in flight, and so must
+     * stay a ghost: the instance the finger picked up, or once dropped whatever
+     * the re-read now carries at the time it came from — both halves of it, for
+     * an event that crosses midnight (#253).
+     */
+    fun ghosts(block: TimedBlock): Boolean {
+        if (liftedInstanceId == null) return false
+        if (block.event.instanceId == liftedInstanceId) return true
+        val (eventId, start) = settledOrigin ?: return false
+        return block.event.eventId == eventId && block.event.start == start
+    }
+
+    /**
+     * What a day column now holds, so a settled drop can tell when the grid has
+     * caught up with it. Matched on the landing slot plus either the event row
+     * or its title, since a single-occurrence move writes a new `eventId`. A
+     * blank title matches nothing: every untitled event has one (#253).
+     */
+    fun noteGrid(date: LocalDate, blocks: List<TimedBlock>) {
+        val landed = settling ?: return
+        if (settledOnGrid) return
+        // Where this day would draw it, which for a drop clipped at midnight is
+        // the day's own start rather than the edge the finger held (#253) — and
+        // which for a tail dragged clear of its day is the day before it.
+        val offset = (date.toEpochDays() - landed.date.toEpochDays()).toInt()
+        val slice = dragSlices(landed.eventStartMin, landed.eventSpanMin, offset..offset)
+            .firstOrNull() ?: return
+        settledOnGrid = blocks.any { block ->
+            block.startMin == slice.startMin &&
+                (
+                    block.event.eventId == landed.event.eventId ||
+                        (
+                            landed.event.title.isNotBlank() &&
+                                block.event.title == landed.event.title
+                            )
+                    )
+        }
+    }
+
+    /**
+     * End the drag, handing back where it landed — null when it never resolved,
+     * or when it landed back on the slot it started from. A real drop keeps its
+     * copy on the target as [settling] until [release].
+     */
+    fun finish(): TimelineDrop? {
+        val landed = drag
+        val origin = originSlot
+        val clipOffset = clipOffsetMin
+        cancel()
+        if (landed == null || landed.slot == origin) return null
+        settling = landed
+        liftedInstanceId = landed.event.instanceId
+        settledOrigin = landed.event.eventId to landed.event.start
+        settledAbandonedMark = abandonedTicks?.value ?: 0
+        return TimelineDrop(landed.event, landed.date, landed.startMin, clipOffset)
+    }
+
+    /**
+     * Stop ghosting the source — the grid draws the drop itself by now — while
+     * the copy is still dissolving. Un-ghosting at [release] instead would leave
+     * the block dim under the fading copy and then brighten it: a visible dip.
+     */
+    fun handOver() {
+        liftedInstanceId = null
+        settledOrigin = null
+    }
+
+    /** Drop the copy, once it has faded into the grid's own block. */
+    fun release() {
+        settling = null
+        settledOnGrid = false
+        handOver()
+    }
+
+    /**
+     * Re-derive the target from the pointer's *root* position. Recomputed rather
+     * than accumulated from `positionChange()`, because a stationary finger emits
+     * no move events while auto-scroll walks the content underneath it.
+     */
+    fun recompute() {
+        val block = source ?: return
+        val grid = geometry.grid?.takeIf { it.isAttached } ?: return
+        val hourPx = geometry.hourPx
+        val columnPx = geometry.columnWidthPx
+        val days = geometry.days
+        if (hourPx <= 0f || columnPx <= 0f || days.isEmpty()) return
+
+        val origin = grid.positionInRoot()
+        val rawMinutes = (pointer.y - grab.y - origin.y) / hourPx * 60f
+        val snapped = (rawMinutes / DRAG_SNAP_MINUTES).roundToInt() * DRAG_SNAP_MINUTES
+        val eventSpan = (block.event.end - block.event.start).inWholeMinutes.toInt()
+            .coerceAtLeast(0)
+        val floor = dragFloorMin(clipOffsetMin, eventSpan)
+        val startMin = snapped.coerceIn(floor, MINUTES_PER_DAY - DRAG_SNAP_MINUTES)
+        val eventStartMin = startMin - clipOffsetMin
+        val column = ((pointer.x - origin.x) / columnPx).toInt().coerceIn(0, days.lastIndex)
+        val dayIndex = if (geometry.isRtl) days.lastIndex - column else column
+        drag = TimelineDrag(
+            event = block.event,
+            date = days[dayIndex],
+            startMin = startMin,
+            eventStartMin = eventStartMin,
+            eventSpanMin = eventSpan,
+            // Bounded to the columns this timeline actually shows: a day it
+            // doesn't has no piece to draw. The write is unaffected.
+            pieces = dragSlices(
+                eventStartMin,
+                eventSpan,
+                within = -dayIndex..days.lastIndex - dayIndex,
+            ).map { slice ->
+                val day = dayIndex + slice.dayOffset
+                val col = if (geometry.isRtl) days.lastIndex - day else day
+                TimelineDragPiece(
+                    topLeftInRoot = Offset(
+                        x = origin.x + col * columnPx,
+                        y = origin.y + slice.startMin / 60f * hourPx,
+                    ),
+                    sizePx = IntSize(
+                        (columnPx - geometry.columnGapPx).roundToInt(),
+                        maxOf(
+                            slice.spanMin / 60f * hourPx,
+                            MIN_EVENT_FRACTION * hourPx,
+                        ).roundToInt(),
+                    ),
+                    continuesBefore = slice.continuesBefore,
+                    continuesAfter = slice.continuesAfter,
+                )
+            },
+        )
+    }
+
+    /**
+     * Hold the scroll for the whole drag and nudge it once per frame while the
+     * finger sits near an edge. One `scroll` call, since a loop of
+     * `animateScrollBy` would re-acquire the mutex and cancel the last.
+     */
+    suspend fun autoScroll() {
+        val scroll = geometry.scroll ?: return
+        scroll.scroll(MutatePriority.UserInput) {
+            while (true) {
+                withFrameNanos { }
+                recompute()
+                val step = edgeStep()
+                if (step != 0f) scrollBy(step)
+            }
+        }
+    }
+
+    private fun edgeStep(): Float {
+        val viewport = geometry.viewport?.takeIf { it.isAttached } ?: return 0f
+        val edge = geometry.edgePx
+        if (edge <= 0f) return 0f
+        val bounds = viewport.boundsInRoot()
+        val fromTop = pointer.y - bounds.top
+        val fromBottom = bounds.bottom - pointer.y
+        return when {
+            fromTop < edge -> -(edge - fromTop) / edge * geometry.stepPx
+            fromBottom < edge -> (edge - fromBottom) / edge * geometry.stepPx
+            else -> 0f
+        }
+    }
+}
+
+@Composable
+fun rememberTimelineDragController(): TimelineDragController {
+    val controller = remember { TimelineDragController() }
+    val density = LocalDensity.current
+    controller.geometry.edgePx = with(density) { AUTO_SCROLL_EDGE.toPx() }
+    controller.geometry.stepPx = with(density) { AUTO_SCROLL_STEP.toPx() }
+    controller.abandonedTicks = LocalEventMove.current?.abandoned
+    return controller
+}
+
+/**
+ * How far this block's top edge sits past its event's start, in minutes — zero
+ * for a block that begins on [day], and the part already run for the tail of an
+ * event that started earlier, whose top edge is midnight rather than the event's
+ * start. Dragging such a tail moves the event by where *its own* top edge lands,
+ * so the offset has to come back off at the drop (#253).
+ */
+fun TimedBlock.clipOffsetMinutes(day: LocalDate, zone: TimeZone): Int {
+    val start = event.start.toLocalDateTime(zone)
+    val days = (day.toEpochDays() - start.date.toEpochDays()).toInt()
+    val minutes = days * MINUTES_PER_DAY + startMin - start.time.toSecondOfDay() / 60
+    return minutes.coerceAtLeast(0)
+}
+
+/**
+ * True when the event began before [day] — this block is its tail, cut at
+ * midnight rather than starting where the event does.
+ */
+fun TimedBlock.continuesBefore(day: LocalDate, zone: TimeZone): Boolean =
+    event.start < day.atStartOfDayIn(zone)
+
+/** True when the event runs past [day]'s midnight, so this block is cut there. */
+fun TimedBlock.continuesAfter(day: LocalDate, zone: TimeZone): Boolean =
+    event.end > day.plus(1, DateTimeUnit.DAY).atStartOfDayIn(zone)
+
+/**
+ * The instant a drop asks for — the *event's* new start, so the tail of an
+ * overnight event drops back onto the day its own start belongs to. Read in the
+ * zone the timeline is drawn in. A drop into a spring-forward gap has no instant
+ * of its own; `toInstant` resolves it forward by the missing hour, and the block
+ * visibly settles there.
+ */
+fun TimelineDrop.startInstant(zone: TimeZone): Instant {
+    // Wall clock throughout, and past this day at either end: a block's top edge
+    // can be dragged above its midnight and a tail's below the next one, so the
+    // start is resolved as a day plus a minute of it rather than as an offset
+    // from an instant — which would shift by an hour across a DST boundary.
+    val fromMidnight = startMin - clipOffsetMin
+    val day = date.plus(fromMidnight.floorDiv(MINUTES_PER_DAY), DateTimeUnit.DAY)
+    val minute = fromMidnight.mod(MINUTES_PER_DAY)
+    return LocalDateTime(day, LocalTime(minute / 60, minute % 60)).toInstant(zone)
+}
+
+/**
+ * A beat after the grid draws the drop, so its own block is under way before the
+ * copy starts dissolving.
+ */
+const val SETTLE_GRACE_MILLIS: Long = 60L
+
+/**
+ * How long to wait for a grid that never confirms the drop — it landed on a day
+ * this timeline doesn't show, or the write failed. The copy has to go either way.
+ */
+private const val SETTLE_TIMEOUT_MILLIS = 900L
+
+/**
+ * The hand-over: the copy dissolves over this while the grid's own block slides
+ * in under it. Kept short, because a full-width copy sits over any neighbour it
+ * now shares a lane with until it is gone.
+ */
+const val SETTLE_FADE_MILLIS: Int = 250
+
+/**
+ * The floating block, drawn over the whole calendar so it is free of the day
+ * column's clip and of the scroll viewport's rounded corners.
+ */
+@Composable
+fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier = Modifier) {
+    var origin by remember { mutableStateOf(Offset.Zero) }
+    val dark = isSystemInDarkTheme()
+    val soften = LocalSoftenColors.current
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
+    val reduceMotion = rememberReduceMotion()
+    val moveInFlight = moveInFlight()
+
+    // Both live here rather than beside the controller: they read [drag], which
+    // changes every frame, and this composable is the one that is meant to.
+    DragSnapHaptics(controller.drag?.slot)
+    LaunchedEffect(controller.isDragging) {
+        if (controller.isDragging) controller.autoScroll()
+    }
+    // Hold the landed copy until the write is done — including the time a
+    // recurring drop's scope dialog is up — and then until the grid draws the
+    // drop itself.
+    var handingOver by remember(controller.settling) { mutableStateOf(false) }
+    val abandoned = abandonedMoves()
+    LaunchedEffect(controller.settling, moveInFlight, controller.settledOnGrid, abandoned) {
+        if (controller.settling == null || moveInFlight) return@LaunchedEffect
+        // Past the mark this drop was let go on, it was abandoned: nothing will
+        // land and there is nothing to wait for.
+        if (abandoned == controller.settledAbandonedMark) {
+            delay(if (controller.settledOnGrid) SETTLE_GRACE_MILLIS else SETTLE_TIMEOUT_MILLIS)
+        }
+        handingOver = true
+        controller.handOver()
+        delay(SETTLE_FADE_MILLIS.toLong())
+        controller.release()
+    }
+
+    Box(
+        modifier = modifier
+            .fillMaxSize()
+            // A copy of a block still in the tree behind it; announcing it again
+            // would duplicate the event for the drag's duration.
+            .clearAndSetSemantics { }
+            .onGloballyPositioned { origin = it.positionInRoot() },
+    ) {
+        val drag = controller.drag ?: controller.settling ?: return@Box
+        // Landed: the copy sinks back to the grid's own plane while the write runs.
+        val landed = controller.drag == null
+        val lift by animateFloatAsState(
+            targetValue = if (landed || reduceMotion) 0f else 1f,
+            label = "drag-lift",
+        )
+        val copyAlpha by animateFloatAsState(
+            targetValue = if (handingOver) 0f else 1f,
+            animationSpec = tween(SETTLE_FADE_MILLIS),
+            label = "drag-handover",
+        )
+        val fill = eventFill(drag.event.color, dark, soften)
+        val title = drag.event.title.ifBlank { stringResource(R.string.event_untitled) }
+        // Read off the event rather than the held block, so grabbing either half
+        // of an event that crosses midnight names the same hours. An end past
+        // midnight wraps rather than saturating, so a four-hour event dragged to
+        // 22:00 reads "22:00–02:00" and not "22:00–24:00".
+        val startMin = drag.eventStartMin.mod(MINUTES_PER_DAY)
+        val rawEnd = startMin + drag.eventSpanMin
+        val endMin = if (rawEnd > MINUTES_PER_DAY) rawEnd % MINUTES_PER_DAY else rawEnd
+        val label = "${formatMinuteOfDay(startMin, use24Hour, locale)}–" +
+            formatMinuteOfDay(endMin, use24Hour, locale)
+        // The tallest piece carries the range: on the smallest it would be
+        // clipped away, which is exactly the case when a short tail is held.
+        val labelled = drag.pieces.indices.maxByOrNull { drag.pieces[it].sizePx.height }
+        drag.pieces.forEachIndexed { index, piece ->
+            DragCopy(
+                topLeftInRoot = piece.topLeftInRoot,
+                overlayOrigin = origin,
+                sizePx = piece.sizePx,
+                fill = fill,
+                shape = timedBlockShape(piece.continuesBefore, piece.continuesAfter),
+                lift = lift,
+                alpha = copyAlpha,
+                title = title,
+                // Once for the whole event: repeated, it would name it per day.
+                label = label.takeIf { index == labelled },
+            )
+        }
+    }
+}
+
+/** One piece of a dragged block, floating over the calendar. */
+@Composable
+private fun DragCopy(
+    topLeftInRoot: Offset,
+    overlayOrigin: Offset,
+    sizePx: IntSize,
+    fill: Color,
+    shape: RoundedCornerShape,
+    lift: Float,
+    alpha: Float,
+    title: String,
+    label: String?,
+) {
+    val density = LocalDensity.current
+    Box(
+        modifier = Modifier
+            // Absolute: these are root coordinates, and the direction-aware
+            // offset would mirror them across the screen in an RTL layout.
+            .absoluteOffset {
+                IntOffset(
+                    (topLeftInRoot.x - overlayOrigin.x).roundToInt(),
+                    (topLeftInRoot.y - overlayOrigin.y).roundToInt(),
+                )
+            }
+            .size(
+                width = with(density) { sizePx.width.toDp() },
+                height = with(density) { sizePx.height.toDp() },
+            )
+            .padding(horizontal = 1.dp)
+            .graphicsLayer {
+                scaleX = 1f + 0.02f * lift
+                scaleY = 1f + 0.02f * lift
+                shadowElevation = 8.dp.toPx() * lift
+                this.alpha = alpha
+                this.shape = shape
+                clip = false
+            }
+            .background(fill, shape)
+            .padding(horizontal = 4.dp, vertical = 2.dp),
+    ) {
+        Column {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.labelMedium,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                color = eventInk(fill, alpha = 0.85f),
+            )
+            if (label != null) {
+                Text(
+                    text = label,
+                    style = MaterialTheme.typography.labelSmall,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    color = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
+                )
+            }
+        }
+    }
+}

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

@@ -76,6 +76,18 @@ fun TimelineScale.hourHeight(viewportHeight: Dp): Dp = when (this) {
         .coerceAtLeast(fillHourHeight(viewportHeight))
 }
 
+/**
+ * The minute of the day a tap [offsetY] px down a timeline column means, snapped
+ * to the hour it landed in.
+ *
+ * [hourPx] must be the hour height the column is drawing at *now* — a tap
+ * detector that captured it when it was installed maps taps to a pre-pinch grid
+ * (#148). A zero or negative height (a viewport measured at nothing) has no grid
+ * to read, so it answers midnight rather than dividing by it.
+ */
+fun tappedMinuteOfDay(offsetY: Float, hourPx: Float): Int =
+    if (hourPx <= 0f) 0 else (offsetY / hourPx).toInt().coerceIn(0, 23) * 60
+
 /**
  * Shortest an event block may render, as a fraction of an hour. Blocks keep a
  * floor so a 15-minute event stays tappable, but the floor scales with the hour

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

@@ -41,7 +41,14 @@ class TimelineZoom(
     var scale: TimelineScale by mutableStateOf(initial)
         private set
 
-    private var pinching = false
+    /**
+     * Whether fingers are rescaling the timeline right now. Snapshot state, so
+     * anything that tweens off [scale] can stand down for the gesture: the
+     * height changes every pointer frame, and a spring would spend the whole
+     * pinch chasing a target that has already moved.
+     */
+    var isPinching: Boolean by mutableStateOf(false)
+        private set
 
     /**
      * Take a value that came from the preference. Ignored mid-pinch: the stored
@@ -49,11 +56,11 @@ class TimelineZoom(
      * snap the timeline back while the user is still pinching.
      */
     fun adopt(stored: TimelineScale) {
-        if (!pinching) scale = stored
+        if (!isPinching) scale = stored
     }
 
     fun beginPinch() {
-        pinching = true
+        isPinching = true
     }
 
     fun pinchTo(hourHeight: Dp) {
@@ -61,7 +68,7 @@ class TimelineZoom(
     }
 
     fun endPinch() {
-        pinching = false
+        isPinching = false
         persist(scale)
     }
 }

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

@@ -0,0 +1,145 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+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.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+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.graphics.TransformOrigin
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.layout
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.floret.components.GroupedListInset
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
+import kotlin.math.roundToInt
+
+/**
+ * The viewport a view preview pretends to be: a phone's width by the height a
+ * calendar view gets under the top bar. Scaling every preview from one fixed
+ * height keeps them comparable — each shows the same slice of screen.
+ */
+internal val PREVIEW_VIEWPORT_HEIGHT = 440.dp
+
+/**
+ * Renders [content] at a full phone viewport and shrinks the finished layout
+ * into a box [height] tall, for the settings and onboarding choosers. Callers
+ * pass the *real* view composables, so a preview cannot drift from what it
+ * depicts.
+ *
+ * The [layout] below ignores the incoming constraints so the view measures at a
+ * phone viewport, and a [graphicsLayer] scale shrinks the result.
+ * `Modifier.requiredSize` is the obvious alternative but *centres* content that
+ * overflows its constraints, leaving only the bottom-right corner in the clip.
+ */
+@Composable
+internal fun ScaledViewPreview(
+    height: Dp,
+    modifier: Modifier = Modifier,
+    content: @Composable () -> Unit,
+) {
+    val screenWidth = LocalConfiguration.current.screenWidthDp.dp
+    val scale = height.value / PREVIEW_VIEWPORT_HEIGHT.value
+
+    Box(
+        modifier = modifier
+            .clipToBounds()
+            .background(MaterialTheme.colorScheme.surface)
+            // A preview is a picture, not a control: swallow touches before the
+            // view's own clickables see them, and give screen readers one label
+            // instead of six weeks of day cells.
+            .pointerInput(Unit) {
+                awaitPointerEventScope {
+                    while (true) {
+                        awaitPointerEvent(PointerEventPass.Initial).changes
+                            .forEach { it.consume() }
+                    }
+                }
+            }
+            .clearAndSetSemantics { }
+            // Measure at a full phone viewport but report the scaled size, so the
+            // node occupies exactly what it draws.
+            .layout { measurable, _ ->
+                val fullWidth = screenWidth.roundToPx()
+                val fullHeight = PREVIEW_VIEWPORT_HEIGHT.roundToPx()
+                val placeable = measurable.measure(Constraints.fixed(fullWidth, fullHeight))
+                layout((fullWidth * scale).roundToInt(), (fullHeight * scale).roundToInt()) {
+                    placeable.place(0, 0)
+                }
+            }
+            .graphicsLayer {
+                scaleX = scale
+                scaleY = scale
+                transformOrigin = TransformOrigin(0f, 0f)
+            },
+    ) {
+        Column(Modifier.fillMaxSize()) { content() }
+    }
+}
+
+/**
+ * The stage every preview picker sets its preview on, cross-fading as [selected]
+ * changes. A preview draws the app's own surface, so a tonal plate gives it the
+ * edge it would otherwise lack on a chooser screen; the plate takes the width
+ * and outer radius of the grouped rows underneath so the two read as one stack.
+ *
+ * Only vertical spacing is the caller's to pass — the horizontal inset is the
+ * rows' own, and the alignment is the point.
+ */
+@Composable
+internal fun <T> ViewPreviewFrame(
+    selected: T,
+    label: String,
+    modifier: Modifier = Modifier,
+    content: @Composable (T) -> Unit,
+) {
+    val reduceMotion = rememberReduceMotion()
+    Box(
+        modifier = modifier
+            .fillMaxWidth()
+            .padding(horizontal = GroupedListInset)
+            .clip(FRAME_SHAPE)
+            .background(MaterialTheme.colorScheme.surfaceContainerHigh)
+            .padding(FRAME_INSET),
+        contentAlignment = Alignment.Center,
+    ) {
+        Crossfade(
+            targetState = selected,
+            animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+            label = label,
+        ) { shown ->
+            // Each preview renders the real view at phone size and scales it
+            // down, so its own corners are square — the plate rounds them.
+            Box(
+                modifier = Modifier
+                    .clip(PREVIEW_SHAPE)
+                    .background(MaterialTheme.colorScheme.surface)
+                    .clipToBounds(),
+            ) {
+                content(shown)
+            }
+        }
+    }
+}
+
+private val FRAME_INSET = 8.dp
+
+/** The grouped rows' own outer radius, so the stack shares one silhouette. */
+private val FRAME_SHAPE = RoundedCornerShape(22.dp)
+private val PREVIEW_SHAPE = RoundedCornerShape(12.dp)

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

@@ -42,9 +42,11 @@ import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -53,14 +55,19 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.customActions
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -74,7 +81,25 @@ import de.jeanlucmakiola.calendula.ui.common.TodayAction
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
+import de.jeanlucmakiola.calendula.ui.common.BlockTimeLabel
+import de.jeanlucmakiola.calendula.ui.common.animatedBlockPlacement
+import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
+import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
+import de.jeanlucmakiola.calendula.ui.common.MoveRequest
+import de.jeanlucmakiola.calendula.ui.common.MoveTarget
 import de.jeanlucmakiola.calendula.ui.common.NowLine
+import de.jeanlucmakiola.calendula.ui.common.TimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.TimelineDragOverlay
+import de.jeanlucmakiola.calendula.ui.common.TimelineDrop
+import de.jeanlucmakiola.calendula.ui.common.clipOffsetMinutes
+import de.jeanlucmakiola.calendula.ui.common.continuesAfter
+import de.jeanlucmakiola.calendula.ui.common.continuesBefore
+import de.jeanlucmakiola.calendula.ui.common.timedBlockShape
+import de.jeanlucmakiola.calendula.ui.common.eventDragAllowed
+import de.jeanlucmakiola.calendula.ui.common.eventMoveAction
+import de.jeanlucmakiola.calendula.ui.common.rememberEventDragSource
+import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.startInstant
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
@@ -82,8 +107,10 @@ import de.jeanlucmakiola.calendula.ui.common.rememberCalendarPageSwipe
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
+import de.jeanlucmakiola.calendula.ui.common.EventChipShape
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.eventInk
+import de.jeanlucmakiola.calendula.ui.common.declinedDecoration
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
@@ -93,9 +120,12 @@ import de.jeanlucmakiola.calendula.ui.common.MIN_EVENT_FRACTION
 import de.jeanlucmakiola.calendula.ui.common.SECONDARY_INK_ALPHA
 import de.jeanlucmakiola.calendula.ui.common.hourHeight
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelinePinchZoom
-import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
 import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
+import de.jeanlucmakiola.calendula.ui.common.GUTTER_WIDTH
+import de.jeanlucmakiola.calendula.ui.common.HourGutter
+import de.jeanlucmakiola.calendula.ui.common.TIMELINE_CONTENT_END_INSET
 import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
+import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.week.TimedBlock
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
@@ -106,16 +136,11 @@ import kotlin.time.Clock
 import java.util.Locale
 import kotlin.math.roundToInt
 
-private val GUTTER_WIDTH = 48.dp
-/** Start inset for the gutter's hour labels so they centre on the top bar's
- *  hamburger: with a 48dp gutter, 8dp lands the centre at 28dp (the app bar's
- *  4dp inset + 24dp half icon button), matching the week view. */
-private val GUTTER_CONTENT_START_INSET = 8.dp
 private val ALL_DAY_ROW_HEIGHT = 24.dp
 private val ALL_DAY_VERTICAL_PADDING = 6.dp
 
 /** Total all-day strip height for the day (0 when there are no all-day events). */
-private fun DayUiState.Success.allDayStripHeight(): Dp {
+internal fun DayUiState.Success.allDayStripHeight(): Dp {
     if (allDay.isEmpty()) return 0.dp
     val lanes = allDay.maxOf { it.lane } + 1
     return ALL_DAY_ROW_HEIGHT * lanes + ALL_DAY_VERTICAL_PADDING * 2
@@ -298,9 +323,16 @@ private fun DayContent(
     // drag is consumed by the inner scroll first — the two gestures coexist.
     val swipeModifier = rememberCalendarPageSwipe(onSwipeNext, onSwipePrev)
 
+    // Above the AnimatedContent: a page change mid-drag would strand the
+    // floating block inside the outgoing page.
+    val dragController = rememberTimelineDragController()
+    val move = LocalEventMove.current
+    val zone = remember { TimeZone.currentSystemDefault() }
+
+    Box(modifier = modifier) {
         AnimatedContent(
             targetState = state,
-        modifier = modifier.then(swipeModifier),
+            modifier = Modifier.fillMaxSize().then(swipeModifier),
             contentKey = { s ->
                 when (s) {
                     is DayUiState.Success -> "success-${s.date}"
@@ -319,21 +351,36 @@ private fun DayContent(
                     topSectionColor = topSectionColor,
                     scrollState = scrollState,
                     allDayHeight = allDayHeight,
+                    dragController = dragController,
                     onEventClick = onEventClick,
                     onCreateAt = onCreateAt,
+                    onDrop = { drop ->
+                        move?.move(
+                            MoveRequest(
+                                eventId = drop.event.eventId,
+                                beginMillis = drop.event.start.toEpochMilliseconds(),
+                                endMillis = drop.event.end.toEpochMilliseconds(),
+                                target = MoveTarget.Start(drop.startInstant(zone)),
+                            ),
+                        )
+                    },
                 )
             }
         }
+        TimelineDragOverlay(dragController)
+    }
 }
 
 @Composable
-private fun DaySuccess(
+internal fun DaySuccess(
     state: DayUiState.Success,
     topSectionColor: Color,
     scrollState: ScrollState,
     allDayHeight: Dp,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
 ) {
     Column(modifier = Modifier.fillMaxSize()) {
         // All-day strip collapses to nothing when the day has no all-day events,
@@ -352,8 +399,10 @@ private fun DaySuccess(
         Timeline(
             state = state,
             scrollState = scrollState,
+            dragController = dragController,
             onEventClick = onEventClick,
             onCreateAt = onCreateAt,
+            onDrop = onDrop,
         )
     }
 }
@@ -425,7 +474,11 @@ private fun AllDayStrip(
             // Height is hoisted + animated so it resizes smoothly; padding sits
             // inside it so the content area is lanes * row height.
             .height(height)
-            .padding(vertical = ALL_DAY_VERTICAL_PADDING),
+            .padding(
+                top = ALL_DAY_VERTICAL_PADDING,
+                bottom = ALL_DAY_VERTICAL_PADDING,
+                end = TIMELINE_CONTENT_END_INSET,
+            ),
     ) {
         // Keep the gutter-width offset so the bars line up with the day column.
         Spacer(Modifier.width(GUTTER_WIDTH))
@@ -467,7 +520,7 @@ private fun AllDayBar(
     val fill = eventFill(event.color, dark, soften)
     Box(
         modifier = modifier
-            .background(fill, RoundedCornerShape(4.dp))
+            .background(fill, EventChipShape)
             .clickable(onClick = onClick)
             .padding(horizontal = 6.dp, vertical = 2.dp)
             .semantics { contentDescription = title },
@@ -479,6 +532,7 @@ private fun AllDayBar(
             maxLines = 1,
             overflow = TextOverflow.Ellipsis,
             color = eventInk(fill),
+            textDecoration = declinedDecoration(event.isDeclined),
         )
     }
 }
@@ -487,13 +541,15 @@ private fun AllDayBar(
 private fun Timeline(
     state: DayUiState.Success,
     scrollState: ScrollState,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
 ) {
     val dark = isSystemInDarkTheme()
-    val use24Hour = LocalUse24HourFormat.current
-    val locale = currentLocale()
     val zoom = LocalTimelineZoom.current
+    val density = LocalDensity.current
+    val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
 
     // BoxWithConstraints rather than Box: the fit-the-whole-day scale needs the
     // timeline's own viewport height, which is only known here — below the top
@@ -512,39 +568,20 @@ private fun Timeline(
         Row(modifier = Modifier.fillMaxSize().then(pinch)) {
             // Hour gutter (scrolls in sync with the day column). Start inset so the
             // labels centre on the top bar hamburger, matching the week view.
-            Column(
-                modifier = Modifier
-                    .width(GUTTER_WIDTH)
-                    .padding(start = GUTTER_CONTENT_START_INSET)
-                    .fillMaxHeight()
-                    .verticalScroll(scrollState),
-            ) {
-                (0 until 24).forEach { h ->
-                    Box(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .height(hourHeight),
-                    ) {
-                        if (h > 0) {
-                            Text(
-                                text = formatHourLabel(h, use24Hour, locale),
-                                style = MaterialTheme.typography.labelSmall,
-                                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                                modifier = Modifier
-                                    .align(Alignment.TopCenter)
-                                    .offset(y = (-6).dp),
+            HourGutter(
+                scrollState = scrollState,
+                hourHeight = hourHeight,
+                dragController = dragController,
             )
-                        }
-                    }
-                }
-            }
             // Day column: rounded, clipped scroll viewport (permanent corners).
             Box(
                 modifier = Modifier
                     .weight(1f)
                     .fillMaxHeight()
+                    .padding(end = TIMELINE_CONTENT_END_INSET)
                     .clip(RoundedCornerShape(16.dp))
-                    .verticalScroll(scrollState),
+                    .verticalScroll(scrollState)
+                    .onGloballyPositioned { dragController.geometry.viewport = it },
             ) {
                 DayColumnCard(
                     blocks = state.timed,
@@ -552,11 +589,26 @@ private fun Timeline(
                     date = state.date,
                     today = state.today,
                     hourHeight = hourHeight,
+                    dragController = dragController,
                     onEventClick = onEventClick,
                     onCreateAt = onCreateAt,
+                    onDrop = onDrop,
                     modifier = Modifier
                         .fillMaxWidth()
-                        .height(totalHeight),
+                        .height(totalHeight)
+                        // The scrolling content itself, so its root position
+                        // already folds in the scroll offset.
+                        .onGloballyPositioned { coords ->
+                            dragController.geometry.let {
+                                it.grid = coords
+                                it.scroll = scrollState
+                                it.hourPx = with(density) { hourHeight.toPx() }
+                                it.columnGapPx = 0f
+                                it.columnWidthPx = coords.size.width.toFloat()
+                                it.days = listOf(state.date)
+                                it.isRtl = isRtl
+                            }
+                        },
                 )
             }
         }
@@ -570,13 +622,25 @@ private fun DayColumnCard(
     date: LocalDate,
     today: LocalDate,
     hourHeight: Dp,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val hourPx = with(LocalDensity.current) { hourHeight.toPx() }
     val showHourLines = LocalShowHourLines.current
     val hourLineColor = MaterialTheme.colorScheme.outlineVariant
+    // Tells a settled drop when this column has caught up with it.
+    LaunchedEffect(blocks, dragController.settling) {
+        dragController.noteGrid(date, blocks)
+    }
+    // The tap detector outlives the composition that installed it — a pinch or a
+    // Settings change moves the hour height without restarting it — so it reads
+    // the height and the callback through state handles instead of capturing
+    // them, or taps land on the scale the column had before the zoom (#148).
+    val currentHourPx = rememberUpdatedState(hourPx)
+    val currentOnCreateAt = rememberUpdatedState(onCreateAt)
     Card(
         // Plain rectangular column — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -597,30 +661,48 @@ private fun DayColumnCard(
                 // only fires on the column background. Snaps to the tapped hour.
                 .pointerInput(date) {
                     detectTapGestures { offset ->
-                        val hour = (offset.y / hourPx).toInt().coerceIn(0, 23)
-                        onCreateAt(date, hour * 60)
+                        currentOnCreateAt.value(
+                            date,
+                            tappedMinuteOfDay(offset.y, currentHourPx.value),
+                        )
                     }
                 },
         ) {
             val colWidth = maxWidth
             val minEventHeight = hourHeight * MIN_EVENT_FRACTION
+            // Keyed by event, so a block that changes time or lane is the *same*
+            // composable afterwards and tweens there. The ordinal disambiguates
+            // a column holding two occurrences of one series.
+            val ordinals = mutableMapOf<Long, Int>()
             blocks.forEach { block ->
+                val ordinal = ordinals.merge(block.event.eventId, 1, Int::plus)!! - 1
+                key(block.event.eventId, ordinal) {
                     val laneWidth = colWidth / block.laneCount
                     val top = hourHeight * (block.startMin / 60f)
                     val rawHeight = hourHeight * ((block.endMin - block.startMin) / 60f)
                     val height = if (rawHeight < minEventHeight) minEventHeight else rawHeight
+                    val place = animatedBlockPlacement(
+                        x = laneWidth * block.lane,
+                        y = top,
+                        width = laneWidth,
+                        height = height,
+                    )
                     EventBlock(
                         block = block,
                         dark = dark,
-                    height = height,
+                        height = place.height,
+                        date = date,
+                        dragController = dragController,
                         onClick = { onEventClick(block.event) },
+                        onDrop = onDrop,
                         modifier = Modifier
-                        .offset(x = laneWidth * block.lane, y = top)
-                        .width(laneWidth)
-                        .height(height)
+                            .offset(x = place.x, y = place.y)
+                            .width(place.width)
+                            .height(place.height)
                             .padding(horizontal = 1.dp),
                     )
                 }
+            }
             // Current-time line, on top of the events, only on today's column.
             if (date == today) {
                 NowLine(date = date, hourHeight = hourHeight)
@@ -634,7 +716,10 @@ private fun EventBlock(
     block: TimedBlock,
     dark: Boolean,
     height: Dp,
+    date: LocalDate,
+    dragController: TimelineDragController,
     onClick: () -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
@@ -658,12 +743,41 @@ private fun EventBlock(
     val showTitle = available >= titleLineHeight
     val soften = LocalSoftenColors.current
     val fill = eventFill(block.event.color, dark, soften)
+    val zone = remember { TimeZone.currentSystemDefault() }
+    val moveAction = eventMoveAction(block.event)
+    val draggable = eventDragAllowed(block.event)
+    // The drop takes this offset back off, so a tail clipped at midnight lands
+    // where the event's own start belongs (#253).
+    val clipOffset = remember(block, date, zone) { block.clipOffsetMinutes(date, zone) }
+    val shape = remember(block, date, zone) {
+        timedBlockShape(block.continuesBefore(date, zone), block.continuesAfter(date, zone))
+    }
+    val dragModifier = rememberEventDragSource(
+        enabled = draggable,
+        key = block.event.instanceId,
+        onPickUp = { pointer, blockRoot, _ ->
+            dragController.begin(block, clipOffset, pointer, blockRoot)
+        },
+        onMove = dragController::move,
+        onDrop = { dragController.finish()?.let(onDrop) },
+        onCancel = dragController::cancel,
+    )
+    val lifted = draggable && dragController.ghosts(block)
+    val ghost = ghostAlpha(lifted)
     Box(
         modifier = modifier
-            .background(fill, RoundedCornerShape(4.dp))
+            // The source stays put as a ghost while its floating copy travels.
+            .then(if (ghost < 1f) Modifier.alpha(ghost) else Modifier)
+            .background(fill, shape)
             .clickable(onClick = onClick)
+            // After clickable, so it is the inner node and wins the main pass;
+            // the tap still works, since a drag consumes the up.
+            .then(dragModifier)
             .padding(horizontal = 4.dp, vertical = 2.dp)
-            .semantics { contentDescription = "$title, $timeLabel" },
+            .semantics {
+                contentDescription = "$title, $timeLabel"
+                if (moveAction != null) customActions = listOf(moveAction)
+            },
     ) {
         Column {
             if (showTitle) {
@@ -673,14 +787,12 @@ private fun EventBlock(
                     maxLines = if (showTime) 1 else 2,
                     overflow = TextOverflow.Ellipsis,
                     color = eventInk(fill, alpha = 0.85f),
+                    textDecoration = declinedDecoration(block.event.isDeclined),
                 )
             }
             if (showTime) {
-                Text(
-                    text = timeLabel,
-                    style = MaterialTheme.typography.labelSmall,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis,
+                BlockTimeLabel(
+                    label = timeLabel,
                     color = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
                 )
             }
@@ -696,7 +808,12 @@ private fun DayLoading() {
         // Same scale resolution as the loaded timeline, so the skeleton's column
         // doesn't resize the moment the real day arrives.
         val totalHeight = scale.hourHeight(maxHeight) * 24
-        Row(modifier = Modifier.fillMaxSize().verticalScroll(scrollState)) {
+        Row(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(end = TIMELINE_CONTENT_END_INSET)
+                .verticalScroll(scrollState),
+        ) {
             Spacer(Modifier.width(GUTTER_WIDTH))
             Box(
                 modifier = Modifier

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

@@ -0,0 +1,65 @@
+package de.jeanlucmakiola.calendula.ui.day
+
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
+import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
+import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.sampleTimelineEvents
+import de.jeanlucmakiola.calendula.ui.week.layoutAllDay
+import de.jeanlucmakiola.calendula.ui.week.layoutDay
+import kotlinx.coroutines.flow.first
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+
+/**
+ * A live, scaled-down Day view for the onboarding view chooser. Today's date is
+ * real; only the events are stand-ins.
+ */
+@Composable
+internal fun DayViewPreview(
+    height: Dp,
+    modifier: Modifier = Modifier,
+) {
+    val zone = remember { TimeZone.currentSystemDefault() }
+    val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
+    val state = remember(today, zone) { sampleDayState(today, zone) }
+    val scrollState = rememberScrollState()
+    LaunchedEffect(Unit) {
+        snapshotFlow { scrollState.maxValue }.first { it > 0 }
+        // Half the scroll range is noon — the same centring the live view does.
+        scrollState.scrollTo(scrollState.maxValue / 2)
+    }
+
+    ScaledViewPreview(height = height, modifier = modifier) {
+        DaySuccess(
+            state = state,
+            topSectionColor = MaterialTheme.colorScheme.surface,
+            scrollState = scrollState,
+            allDayHeight = state.allDayStripHeight(),
+            dragController = rememberTimelineDragController(),
+            onEventClick = {},
+            onCreateAt = { _, _ -> },
+            onDrop = {},
+        )
+    }
+}
+
+/** Sample day state, laid out through the same helpers the live view uses. */
+private fun sampleDayState(today: LocalDate, zone: TimeZone): DayUiState.Success {
+    val days = listOf(today)
+    val events = sampleTimelineEvents(days, today, zone)
+    return DayUiState.Success(
+        date = today,
+        today = today,
+        allDay = layoutAllDay(events.filter { it.isAllDay }, days, zone),
+        timed = layoutDay(events, today, zone),
+    )
+}

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

@@ -48,9 +48,14 @@ class EventDetailViewModel @Inject constructor(
 ) : ViewModel() {
 
     private val _target = MutableStateFlow<Target?>(null)
-    // Bumped by retry() to re-run the load for the same target.
+    // Bumped by retry() and by re-opening the target already shown, to re-run
+    // the load without changing the target.
     private val _reload = MutableStateFlow(0)
 
+    // Last target whose content is already on screen; a re-read of it skips the
+    // Loading skeleton so the sheet doesn't blank out between two identical reads.
+    private var loadedTarget: Target? = null
+
     private val _deleteState = MutableStateFlow<DeleteUiState>(DeleteUiState.Idle)
     val deleteState: StateFlow<DeleteUiState> = _deleteState.asStateFlow()
 
@@ -58,11 +63,14 @@ class EventDetailViewModel @Inject constructor(
         combine(_target, _reload) { target, _ -> target }
             .flatMapLatest { target ->
                 if (target == null) {
+                    loadedTarget = null
                     flowOf<EventDetailUiState>(EventDetailUiState.Loading)
                 } else {
                     flow {
-                        emit(EventDetailUiState.Loading)
-                        emit(loadDetail(target))
+                        if (loadedTarget != target) emit(EventDetailUiState.Loading)
+                        val loaded = loadDetail(target)
+                        loadedTarget = target.takeIf { loaded is EventDetailUiState.Success }
+                        emit(loaded)
                     }
                 }
             }
@@ -78,9 +86,15 @@ class EventDetailViewModel @Inject constructor(
      * the occurrence's own times (from `CalendarContract.Instances`); they
      * override the series DTSTART/DTEND so recurring events show the correct
      * date instead of the first occurrence.
+     *
+     * Re-opening the *same* occurrence always re-reads it. The view model
+     * outlives the sheet, and a `StateFlow` conflates an identical value away,
+     * so assigning the target alone would leave an edit that changed no time —
+     * adding a description, say (#196) — showing the state from before the save.
      */
     fun open(eventId: Long, beginMillis: Long, endMillis: Long) {
-        _target.value = Target(eventId, beginMillis, endMillis)
+        val target = Target(eventId, beginMillis, endMillis)
+        if (_target.value == target) _reload.value += 1 else _target.value = target
     }
 
     /** Re-run the current load after a failure. */

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

@@ -64,6 +64,7 @@ import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SegmentedButton
 import androidx.compose.material3.SegmentedButtonDefaults
 import androidx.compose.material3.SingleChoiceSegmentedButtonRow
+import androidx.compose.material3.SnackbarDuration
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Surface
@@ -127,6 +128,7 @@ import de.jeanlucmakiola.floret.identity.collapseExit
 import de.jeanlucmakiola.floret.identity.expandEnter
 import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.calendula.data.calendar.CalendarColorPalette
+import de.jeanlucmakiola.calendula.ui.common.RecurringScopeDialog
 import de.jeanlucmakiola.calendula.ui.common.CalendarPickerGroups
 import de.jeanlucmakiola.calendula.ui.common.CalendarDatePickerDialog
 import de.jeanlucmakiola.calendula.ui.common.ColorSwatchRow
@@ -263,13 +265,16 @@ fun EventEditScreen(
                 viewModel.reset()
                 onSaved()
             }
+            // A failed save leaves the form looking unchanged, so the snackbar is
+            // the only sign anything happened — long rather than the default
+            // flash (Codeberg #234: it read as "nothing happens at all").
             SaveUiState.Failed -> {
                 viewModel.consumeSaveResult()
-                snackbarHostState.showSnackbar(saveFailedMessage)
+                snackbarHostState.showSnackbar(saveFailedMessage, duration = SnackbarDuration.Long)
             }
             SaveUiState.NeedsPermission -> {
                 viewModel.consumeSaveResult()
-                snackbarHostState.showSnackbar(writeDeniedMessage)
+                snackbarHostState.showSnackbar(writeDeniedMessage, duration = SnackbarDuration.Long)
             }
             // AwaitingScope/AwaitingConflict/Gone render as dialogs below.
             else -> Unit
@@ -452,30 +457,11 @@ private fun SaveScopeDialog(
     onSelect: (RecurringWriteScope) -> Unit,
     onDismiss: () -> Unit,
 ) {
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = { Text(stringResource(R.string.event_edit_recurring_title)) },
-        text = {
-            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                if (!recurrenceChanged) {
-                    OptionCard(
-                        label = stringResource(R.string.event_delete_option_occurrence),
-                        onClick = { onSelect(RecurringWriteScope.ThisEvent) },
-                    )
-                }
-                OptionCard(
-                    label = stringResource(R.string.event_delete_option_following),
-                    onClick = { onSelect(RecurringWriteScope.ThisAndFollowing) },
-                )
-                OptionCard(
-                    label = stringResource(R.string.event_delete_option_series),
-                    onClick = { onSelect(RecurringWriteScope.AllEvents) },
-                )
-            }
-        },
-        confirmButton = {
-            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
-        },
+    RecurringScopeDialog(
+        title = stringResource(R.string.event_edit_recurring_title),
+        onSelect = onSelect,
+        onDismiss = onDismiss,
+        allowOccurrence = !recurrenceChanged,
     )
 }
 

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.edit
 
+import android.util.Log
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
@@ -56,6 +57,8 @@ import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Instant
 import javax.inject.Inject
 
+private const val TAG = "EventEdit"
+
 /**
  * Where a prefilled [EventEditViewModel.openImported] form came from. The sources
  * want different reminder handling (#49), and differ in whether they own the
@@ -751,7 +754,15 @@ class EventEditViewModel @Inject constructor(
                 throw e
             } catch (e: SecurityException) {
                 SaveUiState.NeedsPermission
+            } catch (e: NoSuchEventException) {
+                // The event or occurrence is already gone: the same answer the
+                // pre-check gives, and better than a bare "couldn't save".
+                SaveUiState.Gone
             } catch (e: Exception) {
+                // The user only gets a generic snackbar, so without this a failed
+                // write leaves nothing to report (Codeberg #234). Scope and event
+                // id only — never the form's content.
+                Log.w(TAG, "Save failed (scope=$scope, eventId=${target?.eventId})", e)
                 SaveUiState.Failed
             }
         }

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

@@ -93,15 +93,11 @@ fun ImportScreen(
     }
 
     // Hoisted target calendar so the always-visible top-bar Import action can
-    // read it without the user scrolling to a bottom button. Defaults to the
-    // first *local* calendar — the first row the picker shows ("Your calendars"
-    // group leads) — so the pre-selection lines up with the top of the list;
-    // falls back to the first calendar if there are no local ones. Re-defaults
-    // when the "many" list first arrives (keyed on it), then holds the pick.
+    // read it without the user scrolling to a bottom button (see
+    // [defaultImportTarget] for the choice). Re-defaults when the "many" list
+    // first arrives (keyed on it), then holds the pick.
     val many = state as? ImportUiState.Many
-    val defaultTarget = many?.calendars?.let { cals ->
-        (cals.firstOrNull { it.isLocal } ?: cals.firstOrNull())?.id
-    }
+    val defaultTarget = many?.let { defaultImportTarget(it.calendars, it.fileCalendarName) }
     var selected by rememberSaveable(defaultTarget) { mutableStateOf(defaultTarget) }
 
     Scaffold(
@@ -252,6 +248,15 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
             style = MaterialTheme.typography.headlineSmall,
             color = MaterialTheme.colorScheme.onSurface,
         )
+        if (state.summary.failed > 0) {
+            Spacer(Modifier.height(8.dp))
+            Text(
+                stringResource(R.string.import_done_failed_note),
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                textAlign = TextAlign.Center,
+            )
+        }
         if (state.summary.skippedDuplicate > 0) {
             Spacer(Modifier.height(8.dp))
             Text(
@@ -290,6 +295,19 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
                     onContainer = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
             }
+            if (state.summary.failed > 0) {
+                ImportStatCard(
+                    count = state.summary.failed,
+                    label = stringResource(R.string.import_done_failed_label),
+                    contentDescription = pluralStringResource(
+                        R.plurals.import_done_failed,
+                        state.summary.failed,
+                        state.summary.failed,
+                    ),
+                    container = MaterialTheme.colorScheme.errorContainer,
+                    onContainer = MaterialTheme.colorScheme.onErrorContainer,
+                )
+            }
         }
         Spacer(Modifier.weight(1f))
         Button(
@@ -301,7 +319,7 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
     }
 }
 
-/** A big-number tonal tile summarising one import outcome (added / skipped). */
+/** A big-number tonal tile summarising one import outcome (added / skipped / failed). */
 @Composable
 private fun RowScope.ImportStatCard(
     count: Int,
@@ -343,6 +361,9 @@ private fun WarningText(warning: IcsParseWarning) {
         IcsParseWarning.EventWithoutStartSkipped -> stringResource(R.string.import_warning_no_start)
         IcsParseWarning.AttendeesIgnored -> stringResource(R.string.import_warning_attendees)
         IcsParseWarning.UnknownTimezone -> stringResource(R.string.import_warning_timezone)
+        IcsParseWarning.TasksImportedAsEvents -> stringResource(R.string.import_warning_tasks)
+        IcsParseWarning.RecurrenceRuleRepaired ->
+            stringResource(R.string.import_warning_recurrence_repaired)
     }
     Text(
         text = text,

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

@@ -43,6 +43,12 @@ sealed interface ImportUiState {
         val events: List<ParsedIcsEvent>,
         val warnings: Set<IcsParseWarning>,
         val calendars: List<CalendarSource>,
+        /**
+         * The calendar the file says its events came from, when every one of
+         * them names the same — used to preselect a matching target (see
+         * [fileCalendarName]).
+         */
+        val fileCalendarName: String? = null,
     ) : ImportUiState
 
     data class Done(val summary: IcsImportSummary) : ImportUiState
@@ -92,6 +98,7 @@ class ImportViewModel @Inject constructor(
                         warnings = parsed.warnings,
                         calendars = repository.calendars().first()
                             .filter { it.isEventTarget },
+                        fileCalendarName = fileCalendarName(parsed.events),
                     )
                 }
             }
@@ -113,3 +120,33 @@ class ImportViewModel @Inject constructor(
         }
     }
 }
+
+/**
+ * The one calendar [events] all came from, or null.
+ *
+ * Every event has to agree, unnamed ones included: a foreign file where a single
+ * `VEVENT` carries a `CATEGORIES` tag and the rest carry nothing names no
+ * calendar — it just has one tagged event, and letting it pick the target would
+ * land the whole file wherever that tag happens to match.
+ */
+internal fun fileCalendarName(events: List<ParsedIcsEvent>): String? =
+    events.map { it.calendarName }.distinct().singleOrNull()
+
+/**
+ * The target calendar to preselect for a bulk import.
+ *
+ * A calendar named like the one the file came from wins — restoring "Birthdays"
+ * onto the Birthdays calendar is what the user means. Otherwise the first
+ * *local* calendar, which is the first row the picker shows ("Your calendars"
+ * leads), so the pre-selection lines up with the top of the list; failing that
+ * the first calendar of any kind.
+ */
+internal fun defaultImportTarget(
+    calendars: List<CalendarSource>,
+    fileCalendarName: String?,
+): Long? {
+    val named = fileCalendarName?.let { name ->
+        calendars.firstOrNull { it.displayName.equals(name, ignoreCase = true) }
+    }
+    return (named ?: calendars.firstOrNull { it.isLocal } ?: calendars.firstOrNull())?.id
+}

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

@@ -0,0 +1,345 @@
+package de.jeanlucmakiola.calendula.ui.month
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.layout.positionInRoot
+import androidx.compose.ui.unit.IntSize
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.datetime.LocalDate
+import kotlin.math.abs
+
+/** One week row's live geometry, republished on every layout while it is on screen. */
+class MonthRowGeometry(
+    val days: List<LocalDate>,
+    /** The row's day-column box — the space chip offsets are measured in. */
+    val cell: LayoutCoordinates,
+    /** The lane band inside that box, where the chips themselves are seated. */
+    val band: LayoutCoordinates?,
+    val columnWidthPx: Float,
+    val laneHeightPx: Float,
+    val laneCount: Int,
+    /**
+     * Whether the columns are laid out right-to-left. Pointer coordinates are
+     * never mirrored but the grid is, so the mapping has to flip with it.
+     */
+    val isRtl: Boolean,
+    /** What this row currently draws in [lane] of column `col`, or null. */
+    val chipAt: (col: Int, lane: Int) -> EventInstance?,
+    /** The column the chip in [lane] of column `col` is drawn from. */
+    val chipStart: (col: Int, lane: Int) -> Int,
+) {
+    /** Root top-left of the chip seated in [lane] of column [col]. */
+    fun seat(col: Int, lane: Int): Offset? {
+        val band = band?.takeIf { it.isAttached } ?: return null
+        val origin = band.positionInRoot()
+        val column = if (isRtl) days.lastIndex - col else col
+        return Offset(origin.x + column * columnWidthPx, origin.y + lane * laneHeightPx)
+    }
+
+    /**
+     * Where this row seats [event] on [date], or null when it doesn't hold it —
+     * the day isn't in this week, or the chip went into the day's "+N" overflow.
+     */
+    fun seatOf(event: EventInstance, date: LocalDate): Offset? {
+        val (col, lane) = chipSeat(days, laneCount, chipAt, chipStart, event, date) ?: return null
+        return seat(col, lane)
+    }
+}
+
+/**
+ * The column and lane a row draws [event]'s chip in, given it covers [date] —
+ * null when the row seats no such chip. The column is the *left end* of the bar
+ * within this row, not [date]'s own: a bar spanning several days is drawn once,
+ * from its first column, so an event dropped onto the second day it covers is
+ * seated a column (or more) to the left of where it landed (#253).
+ */
+internal fun chipSeat(
+    days: List<LocalDate>,
+    laneCount: Int,
+    chipAt: (col: Int, lane: Int) -> EventInstance?,
+    chipStart: (col: Int, lane: Int) -> Int,
+    event: EventInstance,
+    date: LocalDate,
+): Pair<Int, Int>? {
+    val col = days.indexOf(date).takeIf { it >= 0 } ?: return null
+    val lane = (0 until laneCount).firstOrNull { lane ->
+        chipAt(col, lane)?.let { isSameEvent(it, event) } == true
+    } ?: return null
+    return chipStart(col, lane) to lane
+}
+
+/**
+ * Whether [chip] is the moved event [moved] as the grid now holds it. Neither id
+ * alone will do: re-read instances get new instance ids, and a single-occurrence
+ * move writes a new event id — the title survives both. A *blank* title is no
+ * evidence at all, though: every untitled event carries one, so matching on it
+ * made any two of them the same event (#253).
+ */
+internal fun isSameEvent(chip: EventInstance, moved: EventInstance): Boolean =
+    chip.eventId == moved.eventId ||
+        (moved.title.isNotBlank() && chip.title == moved.title)
+
+/** A chip in flight, in root coordinates so it can be drawn in an overlay. */
+data class MonthChipDrag(
+    val event: EventInstance,
+    /** The day whose column the chip was grabbed in — the drag is a delta from it. */
+    val grabDate: LocalDate,
+    val targetDate: LocalDate?,
+    val topLeftInRoot: Offset,
+    val sizePx: IntSize,
+)
+
+/** Where a finished chip drag asks its event to go, as a whole-day shift. */
+data class MonthChipDrop(
+    val event: EventInstance,
+    val grabDate: LocalDate,
+    val targetDate: LocalDate,
+)
+
+/**
+ * Hoisted drag state for the month grid (#68). Every visible week row registers
+ * itself so a chip can be carried across rows, the target resolved against
+ * whichever registered row the finger is over. Rows are keyed by an identity
+ * token rather than a date: the continuous style can show the same week twice.
+ */
+@Stable
+class MonthDragController {
+    private val rows = LinkedHashMap<Any, MonthRowGeometry>()
+
+    var drag: MonthChipDrag? by mutableStateOf(null)
+        private set
+
+    /**
+     * A dropped chip, held on the day it landed on while the write runs — the
+     * grid behind it still shows the old day until the query re-reads.
+     */
+    var settling: MonthChipDrag? by mutableStateOf(null)
+        private set
+
+    /**
+     * Which chip is lifted, and whether anything is. Separate snapshot state from
+     * [drag], which changes every frame, so the chips and rows that only need
+     * "am I the ghost" don't recompose that often. Stays set through [settling].
+     */
+    var liftedInstanceId: Long? by mutableStateOf(null)
+        private set
+
+    /**
+     * Where the grid itself now draws the drop, in root coordinates — published
+     * by whichever week row ends up holding it. The copy is dropped wherever the
+     * finger was while the grid seats it in a lane, so without this it would
+     * cross-fade across the gap instead of gliding onto its seat.
+     */
+    var settledInRoot: Offset? by mutableStateOf(null)
+        private set
+
+    /**
+     * Whether the drop's own chip is still standing in for the copy. Cleared at
+     * [handOver] rather than [release], or the chip stays dim under a copy that
+     * has already faded and brightens afterwards: a visible dip.
+     */
+    private var settledGhost: Boolean by mutableStateOf(false)
+
+    /** Whether a finger is on a chip right now — [settling] is not dragging. */
+    var isDragging: Boolean by mutableStateOf(false)
+        private set
+
+    /**
+     * The last drop this controller made, kept past [release] for [beginUndo] —
+     * the confirmation chip carries Undo long after the copy is gone.
+     */
+    private var undoable: MonthChipDrag? = null
+
+    /**
+     * The abandoned-move counter, read at the drop so the mark can't be a
+     * composition behind the tick it is compared against.
+     */
+    var abandonedTicks: StateFlow<Int>? = null
+
+    /** What [abandonedTicks] stood at when the settling chip was let go. */
+    var settledAbandonedMark: Int = 0
+        private set
+
+    private var event: EventInstance? = null
+    private var grabDate: LocalDate? = null
+    private var grab = Offset.Zero
+    private var pointer = Offset.Zero
+    private var sizePx = IntSize.Zero
+
+    fun putRow(token: Any, geometry: MonthRowGeometry) {
+        rows[token] = geometry
+    }
+
+    fun removeRow(token: Any) {
+        rows.remove(token)
+    }
+
+    fun begin(
+        event: EventInstance,
+        grabDate: LocalDate,
+        pointerInRoot: Offset,
+        chipInRoot: Offset,
+        size: IntSize,
+    ) {
+        this.event = event
+        this.grabDate = grabDate
+        settling = null
+        isDragging = true
+        liftedInstanceId = event.instanceId
+        grab = pointerInRoot - chipInRoot
+        pointer = pointerInRoot
+        sizePx = size
+        recompute()
+    }
+
+    fun move(pointerInRoot: Offset) {
+        pointer = pointerInRoot
+        recompute()
+    }
+
+    fun cancel() {
+        event = null
+        grabDate = null
+        isDragging = false
+        liftedInstanceId = null
+        drag = null
+        settling = null
+        settledInRoot = null
+        settledGhost = false
+    }
+
+    /**
+     * Whether [days] holds the chip the grid has drawn for the settled drop —
+     * the seat the copy is on its way to, which must ghost until it gets there.
+     */
+    fun isSettledChip(event: EventInstance, days: List<LocalDate>?): Boolean {
+        val landed = settling?.takeIf { settledGhost } ?: return false
+        if (days == null || landed.targetDate !in days) return false
+        return isSameEvent(event, landed.event)
+    }
+
+    /**
+     * Ask the row keyed [token] whether it now seats the settled chip. Both
+     * copies of a week the continuous style shows twice will answer; the seat
+     * nearest where the chip was let go is the one the finger was over.
+     */
+    fun noteSettled(token: Any) {
+        val landed = settling ?: return
+        val target = landed.targetDate ?: return
+        val at = rows[token]?.seatOf(landed.event, target) ?: return
+        val current = settledInRoot
+        val closer = current == null ||
+            abs(at.y - landed.topLeftInRoot.y) < abs(current.y - landed.topLeftInRoot.y)
+        if (closer) settledInRoot = at
+    }
+
+    /**
+     * Put a chip on the journey an undo's inverse write is about to make, so it
+     * travels back rather than teleporting. Writes nothing itself. False when
+     * there is no drop of this controller's left to undo, or the grid doesn't
+     * seat the moved event where the chip would have to start from.
+     */
+    fun beginUndo(): Boolean {
+        val last = undoable ?: return false
+        undoable = null
+        val from = last.targetDate ?: return false
+        val at = rows.values.firstNotNullOfOrNull { it.seatOf(last.event, from) } ?: return false
+        settling = last.copy(grabDate = from, targetDate = last.grabDate, topLeftInRoot = at)
+        liftedInstanceId = last.event.instanceId
+        settledGhost = true
+        settledInRoot = null
+        settledAbandonedMark = abandonedTicks?.value ?: 0
+        return true
+    }
+
+    /**
+     * End the drag, handing back where it landed — null when it never resolved,
+     * or when it landed back on the day it came from. A real drop keeps its chip
+     * on the target day as [settling] until [release], slid over to that day's
+     * column so it lands where the grid is about to draw it.
+     */
+    fun finish(): MonthChipDrop? {
+        val landed = drag
+        val left = landed?.targetDate?.let(::columnLeft)
+        cancel()
+        val target = landed?.targetDate?.takeIf { it != landed.grabDate } ?: return null
+        settling = landed.copy(
+            topLeftInRoot = Offset(left ?: landed.topLeftInRoot.x, landed.topLeftInRoot.y),
+        )
+        liftedInstanceId = landed.event.instanceId
+        settledGhost = true
+        undoable = settling
+        settledAbandonedMark = abandonedTicks?.value ?: 0
+        return MonthChipDrop(landed.event, landed.grabDate, target)
+    }
+
+    /**
+     * Stop ghosting the source while the copy is still dissolving — un-ghosting
+     * at [release] instead leaves the chip dim and then brightens it.
+     */
+    fun handOver() {
+        liftedInstanceId = null
+        settledGhost = false
+    }
+
+    /** Drop the copy, once it has faded into the grid's own chip. */
+    fun release() {
+        settling = null
+        settledInRoot = null
+        handOver()
+    }
+
+    /** Root x of [date]'s column, in whichever visible row shows that day. */
+    private fun columnLeft(date: LocalDate): Float? = rows.values.firstNotNullOfOrNull { row ->
+        val index = row.days.indexOf(date).takeIf { it >= 0 } ?: return@firstNotNullOfOrNull null
+        val bounds = row.cell.takeIf { it.isAttached }?.boundsInRoot()
+            ?: return@firstNotNullOfOrNull null
+        val column = if (row.isRtl) row.days.lastIndex - index else index
+        bounds.left + column * row.columnWidthPx
+    }
+
+    private fun recompute() {
+        val event = event ?: return
+        val grabbed = grabDate ?: return
+        val resolved = rows.values.firstNotNullOfOrNull { row ->
+            val bounds = row.cell.takeIf { it.isAttached }?.boundsInRoot()
+                ?: return@firstNotNullOfOrNull null
+            if (!bounds.contains(pointer) || row.columnWidthPx <= 0f) {
+                null
+            } else {
+                val column = ((pointer.x - bounds.left) / row.columnWidthPx)
+                    .toInt()
+                    .coerceIn(0, row.days.lastIndex)
+                row.days[if (row.isRtl) row.days.lastIndex - column else column]
+            }
+        }
+        drag = MonthChipDrag(
+            event = event,
+            grabDate = grabbed,
+            // Off the grid entirely: keep the last cell it was over, so a
+            // wobble past the edge doesn't drop the target.
+            targetDate = resolved ?: drag?.targetDate,
+            topLeftInRoot = pointer - grab,
+            sizePx = sizePx,
+        )
+    }
+}
+
+@Composable
+fun rememberMonthDragController(): MonthDragController {
+    val controller = remember { MonthDragController() }
+    controller.abandonedTicks = LocalEventMove.current?.abandoned
+    return controller
+}
+
+val LocalMonthDrag = compositionLocalOf<MonthDragController?> { null }

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

@@ -4,7 +4,9 @@ import androidx.activity.compose.BackHandler
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.animation.ExperimentalSharedTransitionApi
 import androidx.compose.animation.SharedTransitionLayout
+import androidx.compose.animation.core.Animatable
 import androidx.compose.animation.core.RepeatMode
+import androidx.compose.animation.core.VectorConverter
 import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.animation.core.snap
 import androidx.compose.animation.core.animateFloat
@@ -17,6 +19,8 @@ import androidx.compose.animation.togetherWith
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
 import androidx.compose.foundation.gestures.detectDragGestures
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
@@ -59,9 +63,11 @@ import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.key
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.mutableIntStateOf
@@ -77,11 +83,38 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.draw.drawBehind
 import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.foundation.layout.absoluteOffset
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.geometry.Offset
+import kotlin.math.roundToInt
+import de.jeanlucmakiola.calendula.ui.common.rememberDragSurface
+import de.jeanlucmakiola.calendula.ui.common.eventMoveAction
+import de.jeanlucmakiola.calendula.ui.common.MoveTarget
+import de.jeanlucmakiola.calendula.ui.common.MoveRequest
+import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
+import de.jeanlucmakiola.calendula.ui.common.moveInFlight
+import de.jeanlucmakiola.calendula.ui.common.abandonedMoves
+import de.jeanlucmakiola.calendula.ui.common.OnUndoStarted
+import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
+import de.jeanlucmakiola.calendula.ui.common.DragSnapHaptics
+import de.jeanlucmakiola.calendula.ui.common.SETTLE_FADE_MILLIS
+import de.jeanlucmakiola.calendula.ui.common.SETTLE_GRACE_MILLIS
+import de.jeanlucmakiola.calendula.ui.common.EventMoveScope
+import de.jeanlucmakiola.calendula.domain.spanFirstDay
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.semantics.customActions
+import androidx.compose.ui.layout.positionInRoot
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.input.pointer.PointerEventPass
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.stringResource
@@ -109,9 +142,12 @@ import de.jeanlucmakiola.calendula.ui.common.CALENDAR_SWIPE_THRESHOLD
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
+import de.jeanlucmakiola.calendula.ui.common.declinedDecoration
 import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
+import de.jeanlucmakiola.calendula.ui.common.EventChipShape
+import de.jeanlucmakiola.calendula.ui.common.monthBarShape
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.eventInk
 import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
@@ -126,6 +162,7 @@ import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.floret.time.isoWeekNumber
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.launch
@@ -384,13 +421,23 @@ fun MonthScreen(
                 )
             },
         ) { innerPadding ->
-            Column(
+            // Hoisted above every style's grid: a dragged chip is drawn in an
+            // overlay, clear of the week row's and the list viewport's clips.
+            val chipDrag = rememberMonthDragController()
+            // Undo moves the event back, so the chip travels back too. The
+            // signal comes from the write, not from the chip that offers it.
+            OnUndoStarted { chipDrag.beginUndo() }
+            Box(
                 modifier = Modifier
                     .padding(innerPadding)
                     .fillMaxSize(),
             ) {
+            Column(modifier = Modifier.fillMaxSize()) {
                 WeekdayHeader(weekStart = weekStart, showWeekNumbers = showWeekNumbers)
-                CompositionLocalProvider(LocalDimCutoff provides dimCutoff) {
+                CompositionLocalProvider(
+                    LocalDimCutoff provides dimCutoff,
+                    LocalMonthDrag provides chipDrag,
+                ) {
                     if (scrolling) {
                         ContinuousMonthContent(
                             state = continuousState,
@@ -399,6 +446,7 @@ fun MonthScreen(
                             showWeekNumbers = showWeekNumbers,
                             onRetry = jumpToToday,
                             onOpenDay = onOpenDay,
+                            onEventClick = onEventClick,
                         )
                     } else if (viewStyle == MonthViewStyle.Split) {
                         SplitMonthContent(
@@ -423,12 +471,109 @@ fun MonthScreen(
                             onSwipePrev = goPrev,
                             onRetry = jumpToToday,
                             onOpenDay = onOpenDay,
+                            onEventClick = onEventClick,
                         )
                     }
                 }
             }
+            MonthDragOverlay(chipDrag)
             }
         }
+    }
+}
+
+/**
+ * How long to wait for a grid that never seats the drop — it landed in a day's
+ * "+N" overflow or on a day this month doesn't show, or the write failed.
+ */
+private const val MONTH_SETTLE_TIMEOUT_MILLIS = 450L
+
+/** The chip in flight, drawn over the grid and following the finger. */
+@Composable
+private fun MonthDragOverlay(controller: MonthDragController) {
+    var origin by remember { mutableStateOf(Offset.Zero) }
+    val dark = isSystemInDarkTheme()
+    val density = LocalDensity.current
+    val reduceMotion = rememberReduceMotion()
+    val moveInFlight = moveInFlight()
+    // Here rather than beside the controller: this reads [drag], which changes
+    // every frame, and this composable is the one that is meant to.
+    DragSnapHaptics(controller.drag?.targetDate)
+    // Hold the landed chip until the write is done — including the time a
+    // recurring drop's scope dialog is up — and then, unlike the timeline, carry
+    // it to its seat: it was dropped at whatever height the finger was at, while
+    // the grid seats it in a lane.
+    var handingOver by remember(controller.settling) { mutableStateOf(false) }
+    var gliding by remember(controller.settling) { mutableStateOf(false) }
+    val glide = remember { Animatable(Offset.Zero, Offset.VectorConverter) }
+    val glideSpec = MaterialTheme.motionScheme.fastSpatialSpec<Offset>()
+    val seat = controller.settledInRoot
+    val abandoned = abandonedMoves()
+    LaunchedEffect(controller.settling, moveInFlight, seat, abandoned) {
+        val landed = controller.settling
+        if (landed == null || moveInFlight) return@LaunchedEffect
+        if (seat == null) {
+            // Past the mark this drop was let go on, it was abandoned and no
+            // seat is ever coming.
+            if (abandoned == controller.settledAbandonedMark) delay(MONTH_SETTLE_TIMEOUT_MILLIS)
+        } else {
+            if (!gliding) glide.snapTo(landed.topLeftInRoot)
+            gliding = true
+            if (reduceMotion) glide.snapTo(seat) else glide.animateTo(seat, glideSpec)
+            delay(SETTLE_GRACE_MILLIS)
+        }
+        handingOver = true
+        controller.handOver()
+        delay(SETTLE_FADE_MILLIS.toLong())
+        controller.release()
+    }
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            // A copy of a chip still in the tree behind it; announcing it again
+            // would duplicate the event for the drag's duration.
+            .clearAndSetSemantics { }
+            .onGloballyPositioned { origin = it.positionInRoot() },
+    ) {
+        val drag = controller.drag ?: controller.settling ?: return@Box
+        // Landed: the copy sinks back to the grid's own plane while the write runs.
+        val lift by animateFloatAsState(
+            targetValue = if (controller.drag == null || reduceMotion) 0f else 1f,
+            label = "chip-lift",
+        )
+        val copyAlpha by animateFloatAsState(
+            targetValue = if (handingOver) 0f else 1f,
+            animationSpec = tween(SETTLE_FADE_MILLIS),
+            label = "chip-handover",
+        )
+        MonthBar(
+            event = drag.event,
+            dark = dark,
+            continuesLeft = false,
+            continuesRight = false,
+            modifier = Modifier
+                // Absolute: these are root coordinates, and the direction-aware
+                // offset would mirror them across the screen in an RTL layout.
+                .absoluteOffset {
+                    val at = if (gliding) glide.value else drag.topLeftInRoot
+                    IntOffset(
+                        (at.x - origin.x).roundToInt(),
+                        (at.y - origin.y).roundToInt(),
+                    )
+                }
+                .width(with(density) { drag.sizePx.width.toDp() })
+                .height(with(density) { drag.sizePx.height.toDp() })
+                .padding(horizontal = CELL_GAP + 1.dp, vertical = 1.dp)
+                .graphicsLayer {
+                    scaleX = 1f + 0.04f * lift
+                    scaleY = 1f + 0.04f * lift
+                    shadowElevation = 8.dp.toPx() * lift
+                    alpha = copyAlpha
+                    shape = EventChipShape
+                    clip = false
+                },
+        )
+    }
 }
 
 @Composable
@@ -440,6 +585,7 @@ private fun MonthContent(
     onSwipePrev: () -> Unit,
     onRetry: () -> Unit,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
 ) {
     val slideSpec = rememberCalendarSlideSpec()
     val fadeSpec = rememberCalendarFadeSpec()
@@ -466,6 +612,7 @@ private fun MonthContent(
                 state = s,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
             )
         }
     }
@@ -484,6 +631,7 @@ private fun ContinuousMonthContent(
     showWeekNumbers: Boolean,
     onRetry: () -> Unit,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
 ) {
     when (state) {
         // The scrolling styles get their own skeleton rather than the paged
@@ -498,6 +646,7 @@ private fun ContinuousMonthContent(
                 listState = listState,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
             )
         } else {
             ContinuousMonthGrid(
@@ -505,6 +654,7 @@ private fun ContinuousMonthContent(
                 listState = listState,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
             )
         }
     }
@@ -603,7 +753,8 @@ private val CELL_SHAPE = RoundedCornerShape(CELL_CORNER)
 
 /** Width of the split style's selected-day outline. */
 private val SPLIT_SELECTION_STROKE = 1.5.dp
-private const val MAX_EVENT_ROWS = 3
+/** Lanes of bars/pills a day cell draws before the rest become overflow dots. */
+internal const val MAX_EVENT_ROWS = 3
 
 /**
  * Row height in the continuous grid. The paged grid divides the viewport between
@@ -621,11 +772,15 @@ private val CONTINUOUS_ROW_HEIGHT = 112.dp
  */
 private val CONTINUOUS_MONTH_GAP = 20.dp
 
+/** Gap between the weekday header and the seamless stream's first week row. */
+private val DENSE_HEADER_GAP = 4.dp
+
 @Composable
 internal fun MonthGrid(
     state: MonthUiState.Success,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     /** See [MonthWeekRow]'s `selected`: an anchor for the morph, never a mark. */
     selected: LocalDate? = null,
 ) {
@@ -646,6 +801,7 @@ internal fun MonthGrid(
                 inMonth = { it.month == month.month && it.year == month.year },
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
+                onEventClick = onEventClick,
                 selected = selected,
                 modifier = Modifier
                     .fillMaxWidth()
@@ -676,6 +832,7 @@ internal fun ContinuousMonthGrid(
     listState: LazyListState,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val monthCount = remember { continuousMonthCount() }
@@ -703,6 +860,7 @@ internal fun ContinuousMonthGrid(
                     today = state.today,
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
+                    onEventClick = onEventClick,
                 )
             }
         }
@@ -722,6 +880,7 @@ private fun ContinuousMonthBlock(
     today: LocalDate,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
 ) {
     val rowCount = remember(month, weekStart) { weekRowsInMonth(month, weekStart) }
     Column(
@@ -744,6 +903,7 @@ private fun ContinuousMonthBlock(
                     blankOutside = true,
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
+                    onEventClick = onEventClick,
                     modifier = Modifier
                         .fillMaxWidth()
                         .height(CONTINUOUS_ROW_HEIGHT),
@@ -802,6 +962,7 @@ internal fun DenseMonthGrid(
     listState: LazyListState,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val weekCount = remember(state.weekStart) { continuousWeekCount(state.weekStart) }
@@ -809,10 +970,15 @@ internal fun DenseMonthGrid(
         state = listState,
         modifier = modifier
             .fillMaxSize()
-            .padding(horizontal = 8.dp),
+            // The gap under the weekday header is a real margin, not content
+            // padding: a lazy list scrolls its rows *through* the before-content
+            // padding, so scrolling to a week landed its row that far down with
+            // the tail of the previous one showing above it (#191).
+            .padding(horizontal = 8.dp)
+            .padding(top = DENSE_HEADER_GAP),
         verticalArrangement = Arrangement.spacedBy(2.dp),
         // Bottom inset clears the FAB stack so the last row stays tappable.
-        contentPadding = PaddingValues(top = 4.dp, bottom = 96.dp),
+        contentPadding = PaddingValues(bottom = 96.dp),
     ) {
         items(count = weekCount, key = { it }) { index ->
             val week = state.weeksByIndex[index]
@@ -827,6 +993,7 @@ internal fun DenseMonthGrid(
                     inMonth = { true },
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
+                    onEventClick = onEventClick,
                     labelMonthOnFirst = true,
                     modifier = Modifier
                         .fillMaxWidth()
@@ -1054,6 +1221,9 @@ private fun SplitMonthBody(
                 onSelectDay(it)
                 onSetExpanded(false)
             },
+            // A tapped chip is asking for that event, not for its day, so it
+            // opens the detail from here too rather than collapsing (#187).
+            onEventClick = onEventClick,
             onCollapse = { onSetExpanded(false) },
         )
     } else {
@@ -1154,6 +1324,7 @@ private fun SplitMonthExpanded(
     showWeekNumbers: Boolean,
     swipeModifier: Modifier,
     onPickDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     onCollapse: () -> Unit,
 ) {
     val slideSpec = rememberCalendarSlideSpec()
@@ -1176,6 +1347,7 @@ private fun SplitMonthExpanded(
                 state = s,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onPickDay,
+                onEventClick = onEventClick,
                 selected = sel,
             )
         }
@@ -1656,7 +1828,7 @@ private fun ContinuousMonthSkeleton(dense: Boolean) {
                 modifier = Modifier.padding(bottom = 8.dp),
             )
         } else {
-            Spacer(Modifier.height(4.dp))
+            Spacer(Modifier.height(DENSE_HEADER_GAP))
         }
         // More rows than a viewport holds; the clip takes the overflow.
         repeat(6) {
@@ -1704,6 +1876,7 @@ private fun MonthWeekRow(
     inMonth: (LocalDate) -> Boolean,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
+    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
     blankOutside: Boolean = false,
     labelMonthOnFirst: Boolean = false,
@@ -1720,6 +1893,51 @@ private fun MonthWeekRow(
     val shownLanes = laneCount.coerceAtMost(MAX_EVENT_ROWS)
     val morphing = morphInFlight()
 
+    // Drag to reschedule (#68). The chips can take no pointer input of their own
+    // — the full-bleed tap layer sits on top of them — so one detector on the
+    // row's day-column box hit-tests them geometrically instead.
+    val moveScope = LocalEventMove.current
+    val dragController = LocalMonthDrag.current
+    val rowToken = remember { Any() }
+    val bandCoordinates = remember { arrayOfNulls<LayoutCoordinates>(1) }
+    val cellCoordinates = remember { arrayOfNulls<LayoutCoordinates>(1) }
+    val density = LocalDensity.current
+    val rowHeightPx = with(density) { EVENT_ROW_HEIGHT.toPx() }
+    val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
+    val dragging = dragController?.isDragging == true
+    DisposableEffect(rowToken, dragController) {
+        onDispose { dragController?.removeRow(rowToken) }
+    }
+    // Republished on layout *and* on every recomposition: the coordinates change
+    // only on the former, but what the row draws — which the controller reads to
+    // find a moved chip's seat — changes on the latter.
+    val publish = {
+        val cell = cellCoordinates[0]?.takeIf { it.isAttached }
+        if (dragController != null && cell != null) {
+            dragController.putRow(
+                rowToken,
+                MonthRowGeometry(
+                    days = week.days,
+                    cell = cell,
+                    band = bandCoordinates[0],
+                    columnWidthPx = cell.size.width / 7f,
+                    laneHeightPx = rowHeightPx,
+                    laneCount = MAX_EVENT_ROWS,
+                    isRtl = isRtl,
+                    chipAt = { col, lane -> week.chipAt(col, lane, MAX_EVENT_ROWS) },
+                    chipStart = { col, lane -> week.chipStartCol(col, lane) },
+                ),
+            )
+        }
+    }
+    SideEffect { publish() }
+    // Once the grid holds the settled chip, tell the controller where this row
+    // has seated it, so the copy in flight can glide onto it. Keyed on the week,
+    // which is what changes when the re-read lands.
+    LaunchedEffect(week, dragController?.settling) {
+        dragController?.noteSettled(rowToken)
+    }
+
     Row(modifier) {
         // Optional calendar-week gutter, sized so the seven day columns below
         // divide the remaining width — the absolute bar offsets stay correct
@@ -1735,7 +1953,21 @@ private fun MonthWeekRow(
         BoxWithConstraints(
             Modifier
                 .weight(1f)
-                .fillMaxHeight(),
+                .fillMaxHeight()
+                .onGloballyPositioned { coords ->
+                    cellCoordinates[0] = coords
+                    publish()
+                }
+                .then(
+                    monthChipDragModifier(
+                        week = week,
+                        moveScope = moveScope,
+                        controller = dragController,
+                        band = bandCoordinates,
+                        rowHeightPx = rowHeightPx,
+                        isRtl = isRtl,
+                    ),
+                ),
         ) {
             val colW = maxWidth / 7
 
@@ -1800,7 +2032,13 @@ private fun MonthWeekRow(
                     modifier = Modifier
                         .fillMaxWidth()
                         .weight(1f)
-                        .then(if (morphing) Modifier else Modifier.clipToBounds()),
+                        .onGloballyPositioned {
+                            bandCoordinates[0] = it
+                            publish()
+                        }
+                        // A dragged chip travels to another row, so the clip
+                        // yields for it as it does for a morph.
+                        .then(if (morphing || dragging) Modifier else Modifier.clipToBounds()),
                 ) {
                     // Spanning bars on their shared lanes.
                     week.spans.filter { it.lane < shownLanes }.forEach { span ->
@@ -1810,6 +2048,7 @@ private fun MonthWeekRow(
                             dark = dark,
                             continuesLeft = span.continuesLeft,
                             continuesRight = span.continuesRight,
+                            days = week.days.subList(span.startCol, span.endCol + 1),
                             modifier = Modifier
                                 .offset(
                                     x = colW * span.startCol,
@@ -1879,6 +2118,7 @@ private fun MonthWeekRow(
                                 dark = dark,
                                 continuesLeft = false,
                                 continuesRight = false,
+                                days = listOf(d),
                                 modifier = Modifier
                                     .offset(
                                         x = colW * col,
@@ -1936,11 +2176,17 @@ private fun MonthWeekRow(
                 }
             }
 
-            // Tap layer: in month view a tap on any day opens that day. Padded and
+            // Tap layer: a tap on a chip opens that event, anything else opens the
+            // day (#187). The chips take no pointer input of their own — this
+            // layer covers them — so the lane under the finger is resolved
+            // geometrically, exactly as the drag pickup above does it; the down
+            // position is read on the initial pass, which consumes nothing and so
+            // leaves both the click and a pickup in flight untouched. Padded and
             // clipped to the background pill so the ripple matches it. A blanked
             // cell isn't part of this month, so it takes no taps either.
+            val downY = remember(week.days.size) { FloatArray(week.days.size) { NO_DOWN_Y } }
             Row(Modifier.matchParentSize()) {
-                week.days.forEach { d ->
+                week.days.forEachIndexed { col, d ->
                     if (blankOutside && !inMonth(d)) {
                         Spacer(Modifier.weight(1f).fillMaxHeight())
                     } else {
@@ -1948,9 +2194,33 @@ private fun MonthWeekRow(
                             Modifier
                                 .weight(1f)
                                 .fillMaxHeight()
+                                .pointerInput(col) {
+                                    awaitEachGesture {
+                                        downY[col] = awaitFirstDown(
+                                            requireUnconsumed = false,
+                                            pass = PointerEventPass.Initial,
+                                        ).position.y
+                                    }
+                                }
                                 .padding(horizontal = CELL_GAP, vertical = 1.dp)
                                 .clip(CELL_SHAPE)
-                                .clickable { onOpenDay(d) },
+                                .clickable {
+                                    // Cleared on read: a click with no fresh down
+                                    // (TalkBack, D-pad) would otherwise resolve the
+                                    // previous tap's position and reopen its chip.
+                                    val cellY = downY[col]
+                                    downY[col] = NO_DOWN_Y
+                                    val chip = week.chipAtCellY(
+                                        col = col,
+                                        cellY = cellY,
+                                        bandTopInCell = bandTopInCell(
+                                            cellCoordinates,
+                                            bandCoordinates,
+                                        ),
+                                        rowHeightPx = rowHeightPx,
+                                    )
+                                    if (chip != null) onEventClick(chip) else onOpenDay(d)
+                                },
                         )
                     }
                 }
@@ -1959,6 +2229,107 @@ private fun MonthWeekRow(
     }
 }
 
+/**
+ * How far the event band sits below the top of the row's day-column box, or null
+ * while either is unmeasured. Read off the live coordinates rather than summed
+ * from the padding constants, so it can't drift from what the row actually drew.
+ */
+private fun bandTopInCell(
+    cell: Array<LayoutCoordinates?>,
+    band: Array<LayoutCoordinates?>,
+): Float? {
+    val cellTop = cell[0]?.takeIf { it.isAttached }?.positionInRoot()?.y ?: return null
+    val bandTop = band[0]?.takeIf { it.isAttached }?.positionInRoot()?.y ?: return null
+    return bandTop - cellTop
+}
+
+/**
+ * Stand-in [cellY] for "no touch down recorded", which resolves to no chip.
+ */
+private const val NO_DOWN_Y = Float.NEGATIVE_INFINITY
+
+/**
+ * The chip at [cellY] in column [col], where [cellY] is measured from the top of
+ * the row's day-column box. Null for a tap above the band (the day number), on an
+ * empty lane, or on the overflow dots — all of which mean "open the day", the
+ * dots included: their point is that the day holds more than fits.
+ */
+internal fun MonthWeek.chipAtCellY(
+    col: Int,
+    cellY: Float,
+    bandTopInCell: Float?,
+    rowHeightPx: Float,
+): EventInstance? {
+    if (bandTopInCell == null || rowHeightPx <= 0f) return null
+    val bandY = cellY - bandTopInCell
+    if (bandY < 0f) return null
+    return chipAt(col, (bandY / rowHeightPx).toInt(), MAX_EVENT_ROWS)
+}
+
+/**
+ * The row-level pickup for month chips: resolves which chip the press landed on
+ * from the geometry the row just laid out, and abandons the gesture on empty
+ * space (or an unmovable calendar) so tapping a day still opens it.
+ */
+@Composable
+private fun monthChipDragModifier(
+    week: MonthWeek,
+    moveScope: EventMoveScope?,
+    controller: MonthDragController?,
+    band: Array<LayoutCoordinates?>,
+    rowHeightPx: Float,
+    isRtl: Boolean,
+): Modifier = rememberDragSurface(
+    enabled = moveScope?.dragEnabled == true && controller != null,
+    key = week.days.first(),
+    onPickUp = { local, pointerInRoot, nodeInRoot, size ->
+        val bandTop = band[0]?.takeIf { it.isAttached }?.positionInRoot()?.y
+        val columnPx = size.width / 7f
+        val bandY = if (bandTop == null) -1f else local.y - (bandTop - nodeInRoot.y)
+        val lane = (bandY / rowHeightPx).toInt()
+        // The column under the finger on screen, and the day that column shows.
+        val column = (local.x / columnPx).toInt()
+        val dayIndex = if (isRtl) week.days.lastIndex - column else column
+        val event = if (bandY < 0f || columnPx <= 0f) {
+            null
+        } else {
+            week.chipAt(dayIndex, lane, MAX_EVENT_ROWS)
+        }
+        if (event == null || moveScope?.allows(event) != true) {
+            false
+        } else {
+            controller?.begin(
+                event = event,
+                grabDate = week.days[dayIndex],
+                pointerInRoot = pointerInRoot,
+                chipInRoot = Offset(
+                    x = nodeInRoot.x + column * columnPx,
+                    y = requireNotNull(bandTop) + lane * rowHeightPx,
+                ),
+                size = IntSize(columnPx.toInt(), rowHeightPx.toInt()),
+            )
+            true
+        }
+    },
+    onMove = { controller?.move(it) },
+    onDrop = {
+        controller?.finish()?.let { drop ->
+            // How many columns the finger crossed — grabbing the middle of a
+            // multi-day bar shifts by what it travelled, not to where it landed.
+            val delta = (drop.targetDate.toEpochDays() - drop.grabDate.toEpochDays()).toInt()
+            moveScope?.move(
+                MoveRequest(
+                    eventId = drop.event.eventId,
+                    beginMillis = drop.event.start.toEpochMilliseconds(),
+                    endMillis = drop.event.end.toEpochMilliseconds(),
+                    target = MoveTarget.ByDays(delta),
+                ),
+            )
+        }
+    },
+    onCancel = { controller?.cancel() },
+)
+
 /**
  * Left-gutter calendar-week cell (#25): a full-height tonal pill mirroring the
  * day cells' geometry, set apart by the secondaryContainer tint (matching the
@@ -2051,23 +2422,34 @@ private fun MonthBar(
     continuesLeft: Boolean,
     continuesRight: Boolean,
     modifier: Modifier = Modifier,
+    /**
+     * The days this chip covers in its row, for the drag (#68). A drop's own chip
+     * has to ghost until the copy lands on it, and the instance id can't find it:
+     * the provider hands the re-read instance a new one.
+     */
+    days: List<LocalDate>? = null,
 ) {
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     val dimCutoff = LocalDimCutoff.current
     val dimmed = dimCutoff != null && event.hasEnded(dimCutoff)
     val soften = LocalSoftenColors.current
     val fill = eventFill(event.color, dark, soften)
-    val shape = RoundedCornerShape(
-        topStart = if (continuesLeft) 0.dp else 4.dp,
-        bottomStart = if (continuesLeft) 0.dp else 4.dp,
-        topEnd = if (continuesRight) 0.dp else 4.dp,
-        bottomEnd = if (continuesRight) 0.dp else 4.dp,
-    )
+    val moveAction = eventMoveAction(event)
+    // The source stays put as a ghost while its floating copy travels.
+    val monthDrag = LocalMonthDrag.current
+    val lifted = monthDrag?.liftedInstanceId == event.instanceId ||
+        monthDrag?.isSettledChip(event, days) == true
+    val ghost = ghostAlpha(lifted)
+    val shape = monthBarShape(continuesLeft, continuesRight)
     Box(
         modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
+            .then(if (ghost < 1f) Modifier.alpha(ghost) else Modifier)
             .background(fill, shape)
             .padding(horizontal = 4.dp)
-            .semantics { contentDescription = title },
+            .semantics {
+                contentDescription = title
+                if (moveAction != null) customActions = listOf(moveAction)
+            },
         contentAlignment = Alignment.CenterStart,
     ) {
         Text(
@@ -2076,6 +2458,7 @@ private fun MonthBar(
             maxLines = 1,
             overflow = TextOverflow.Ellipsis,
             color = eventInk(fill),
+            textDecoration = declinedDecoration(event.isDeclined),
         )
     }
 }

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

@@ -1,54 +1,31 @@
 package de.jeanlucmakiola.calendula.ui.month
 
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clipToBounds
-import androidx.compose.ui.layout.layout
-import androidx.compose.ui.unit.Constraints
-import androidx.compose.ui.graphics.TransformOrigin
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.input.pointer.PointerEventPass
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalConfiguration
-import androidx.compose.ui.semantics.clearAndSetSemantics
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
+import de.jeanlucmakiola.calendula.ui.common.sampleMonthEvents
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.YearMonth
-import kotlinx.datetime.atTime
 import kotlinx.datetime.plus
-import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Clock
-import kotlin.math.roundToInt
 
 /**
  * A live, scaled-down Month view in a given [MonthViewStyle], for the settings
- * chooser.
- *
- * It renders the *real* grid composables rather than a drawing of them, so the
- * preview cannot drift from the thing it depicts: change a cell's shape or an
- * event bar's colour and every preview follows automatically. The trick is
- * [requiredSize] — it ignores the incoming constraints, so the grid lays itself
- * out at a full phone width and a plausible viewport height, and a
- * [graphicsLayer] scale shrinks the finished layout into the card.
+ * and onboarding choosers.
  *
  * The month, today's position and the week start are all real; only the events
- * are stand-ins, since the settings screen has no business querying the
- * provider for a thumbnail.
+ * are stand-ins. See [ScaledViewPreview] for how the real grid composables get
+ * measured at phone size and shrunk into the card.
  */
 @Composable
 internal fun MonthStylePreview(
@@ -57,56 +34,18 @@ internal fun MonthStylePreview(
     height: Dp,
     modifier: Modifier = Modifier,
 ) {
-    val screenWidth = LocalConfiguration.current.screenWidthDp.dp
-    val scale = height.value / VIRTUAL_HEIGHT.value
     val zone = remember { TimeZone.currentSystemDefault() }
     val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
     val sample = remember(today, weekStart, zone) { sampleMonthState(today, weekStart, zone) }
 
-    Box(
-        modifier = modifier
-            .clipToBounds()
-            .background(MaterialTheme.colorScheme.surface)
-            // A preview is a picture, not a control: swallow touches before the
-            // grid's own clickables see them, and give screen readers one label
-            // instead of six weeks of day cells.
-            .pointerInput(Unit) {
-                awaitPointerEventScope {
-                    while (true) {
-                        awaitPointerEvent(PointerEventPass.Initial).changes
-                            .forEach { it.consume() }
-                    }
-                }
-            }
-            .clearAndSetSemantics { }
-            // Measure the grid at a full phone viewport but report the scaled
-            // size, so the node occupies exactly what it draws.
-            //
-            // Modifier.requiredSize would be the obvious way to force the larger
-            // measurement, but it *centres* content that overflows the incoming
-            // constraints — which pushed the grid to a negative offset and left
-            // only its bottom-right corner inside the clip.
-            .layout { measurable, _ ->
-                val fullWidth = screenWidth.roundToPx()
-                val fullHeight = VIRTUAL_HEIGHT.roundToPx()
-                val placeable = measurable.measure(Constraints.fixed(fullWidth, fullHeight))
-                layout((fullWidth * scale).roundToInt(), (fullHeight * scale).roundToInt()) {
-                    placeable.place(0, 0)
-                }
-            }
-            .graphicsLayer {
-                scaleX = scale
-                scaleY = scale
-                transformOrigin = TransformOrigin(0f, 0f)
-            },
-    ) {
-        Column(Modifier.fillMaxSize()) {
+    ScaledViewPreview(height = height, modifier = modifier) {
         WeekdayHeader(weekStart = weekStart, showWeekNumbers = false)
         when (style) {
             MonthViewStyle.Paged -> MonthGrid(
                 state = sample.month,
                 showWeekNumbers = false,
                 onOpenDay = {},
+                onEventClick = {},
             )
             MonthViewStyle.Continuous -> ContinuousMonthGrid(
                 state = sample.continuous,
@@ -117,18 +56,19 @@ internal fun MonthStylePreview(
                 ),
                 showWeekNumbers = false,
                 onOpenDay = {},
+                onEventClick = {},
             )
             MonthViewStyle.Dense -> DenseMonthGrid(
                 state = sample.continuous,
                 listState = rememberLazyListState(
-                            // Start a week above today's, so the preview shows a
-                            // stream running past the viewport rather than one
-                            // beginning at its top edge.
-                            initialFirstVisibleItemIndex =
-                                weekIndexOf(today, weekStart) - 1,
+                    // Start a week above today's, so the preview shows a stream
+                    // running past the viewport rather than one beginning at its
+                    // top edge.
+                    initialFirstVisibleItemIndex = weekIndexOf(today, weekStart) - 1,
                 ),
                 showWeekNumbers = false,
                 onOpenDay = {},
+                onEventClick = {},
             )
             MonthViewStyle.Split -> {
                 SplitMonthGrid(
@@ -150,15 +90,8 @@ internal fun MonthStylePreview(
             }
         }
     }
-    }
 }
 
-/**
- * The viewport the preview pretends to be: a phone's width by the height a
- * calendar view gets under the top bar. Scaling from a fixed height keeps the
- * three styles comparable — each shows the same slice of screen.
- */
-private val VIRTUAL_HEIGHT = 440.dp
 private val SPLIT_PANE_HEIGHT = 170.dp
 
 private class SampleMonth(
@@ -170,9 +103,6 @@ private class SampleMonth(
  * A month's worth of stand-in events, laid out through the same
  * [layoutMonthWeeks] / [clipWeekToMonth] the live views use — so the preview
  * exercises the real span, lane and overflow logic rather than approximating it.
- *
- * Colours are raw ARGB on purpose: that is what the provider hands out for an
- * event, so a token here would misrepresent what the grid actually renders.
  */
 private fun sampleMonthState(
     today: LocalDate,
@@ -181,7 +111,7 @@ private fun sampleMonthState(
 ): SampleMonth {
     val ym = YearMonth(today.year, today.month)
     val first = LocalDate(ym.year, ym.month, 1)
-    val events = sampleEvents(first, today, zone)
+    val events = sampleMonthEvents(first, today, zone)
 
     val weeks = layoutMonthWeeks(ym, weekStart, events, zone)
     val month = MonthUiState.Success(
@@ -213,72 +143,3 @@ private fun sampleMonthState(
     )
     return SampleMonth(month, continuous)
 }
-
-private val SAMPLE_COLORS = listOf(
-    0xFF3F7BD4.toInt(),
-    0xFFCE5B4C.toInt(),
-    0xFF4E9A6A.toInt(),
-    0xFF8A63C7.toInt(),
-)
-
-private fun sampleEvents(
-    firstOfMonth: LocalDate,
-    today: LocalDate,
-    zone: TimeZone,
-): List<EventInstance> {
-    var id = 0L
-    fun next() = ++id
-
-    fun timed(day: LocalDate, hour: Int, length: Int, colorIndex: Int) = EventInstance(
-        instanceId = next(),
-        eventId = id,
-        calendarId = 1L,
-        title = SAMPLE_TITLES[(id.toInt() - 1) % SAMPLE_TITLES.size],
-        start = day.atTime(hour, 0).toInstant(zone),
-        end = day.atTime(hour + length, 0).toInstant(zone),
-        isAllDay = false,
-        color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
-        location = null,
-    )
-
-    fun allDay(from: LocalDate, days: Int, colorIndex: Int) = EventInstance(
-        instanceId = next(),
-        eventId = id,
-        calendarId = 1L,
-        title = SAMPLE_TITLES[(id.toInt() - 1) % SAMPLE_TITLES.size],
-        // All-day events sit at UTC midnights with an exclusive end.
-        start = from.atTime(0, 0).toInstant(TimeZone.UTC),
-        end = from.plus(days, DateTimeUnit.DAY).atTime(0, 0).toInstant(TimeZone.UTC),
-        isAllDay = true,
-        color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
-        location = null,
-    )
-
-    // Spread across the month so most weeks carry something, with one multi-day
-    // bar to show a span bridging cells and a busy today for the split pane.
-    return buildList {
-        add(allDay(firstOfMonth.plus(9, DateTimeUnit.DAY), days = 3, colorIndex = 2))
-        add(timed(firstOfMonth.plus(1, DateTimeUnit.DAY), 9, 1, 0))
-        add(timed(firstOfMonth.plus(4, DateTimeUnit.DAY), 14, 2, 1))
-        add(timed(firstOfMonth.plus(7, DateTimeUnit.DAY), 11, 1, 3))
-        add(timed(firstOfMonth.plus(15, DateTimeUnit.DAY), 10, 1, 0))
-        add(timed(firstOfMonth.plus(18, DateTimeUnit.DAY), 16, 1, 2))
-        add(timed(firstOfMonth.plus(22, DateTimeUnit.DAY), 8, 2, 1))
-        add(timed(firstOfMonth.plus(25, DateTimeUnit.DAY), 13, 1, 3))
-        // Today, so the split pane's list and the grid's dots both have content.
-        add(timed(today, 9, 1, 0))
-        add(timed(today, 12, 1, 1))
-        add(timed(today, 15, 2, 3))
-    }
-}
-
-private val SAMPLE_TITLES = listOf(
-    "Standup",
-    "Lunch",
-    "Review",
-    "Gym",
-    "Call",
-    "Workshop",
-    "Dentist",
-    "Trip",
-)

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

@@ -67,6 +67,33 @@ fun MonthWeek.laneEvents(col: Int, day: LocalDate, laneCap: Int): List<EventInst
     return byLane.filterNotNull()
 }
 
+/**
+ * The event drawn in lane [lane] of column [col], or null for an empty slot.
+ * Unlike [laneEvents] the lanes are *not* compacted — this answers "what is under
+ * this point", so an empty lane above a seated bar has to stay empty (#68).
+ */
+fun MonthWeek.chipAt(col: Int, lane: Int, laneCap: Int): EventInstance? {
+    if (col !in days.indices || lane !in 0 until laneCap) return null
+    spans.firstOrNull { it.lane == lane && col in it.startCol..it.endCol }?.let { return it.event }
+    val occupied = spans
+        .filter { it.lane < laneCap && col in it.startCol..it.endCol }
+        .map { it.lane }
+        .toSet()
+    val free = (0 until laneCap).filter { it !in occupied }
+    val index = free.indexOf(lane).takeIf { it >= 0 } ?: return null
+    return timedByDay[days[col]].orEmpty().take(free.size).getOrNull(index)
+}
+
+/**
+ * The column the chip drawn in lane [lane] of column [col] begins in. A bar is
+ * drawn once, from its own first column, so a chip seated by [chipAt] on the
+ * second day it covers belongs a column (or more) to the left (#253). Answers
+ * [col] for a single-day chip, and for an empty slot no one should be asking
+ * about.
+ */
+fun MonthWeek.chipStartCol(col: Int, lane: Int): Int =
+    spans.firstOrNull { it.lane == lane && col in it.startCol..it.endCol }?.startCol ?: col
+
 /**
  * The events on [day] that [laneEvents] had no lane left for — its exact
  * complement, in the same bars-then-pills order. Returned as events rather than

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

@@ -12,6 +12,7 @@ import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.ui.week.coversDay
 import de.jeanlucmakiola.calendula.ui.week.layoutAllDay
+import de.jeanlucmakiola.calendula.ui.week.spansMultipleDays
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -417,8 +418,11 @@ internal fun layoutCalendarWeek(
     zone: TimeZone,
 ): MonthWeek {
     val weekEvents = instances.filter { ev -> days.any { ev.coversDay(it, zone) } }
+    // A bar is decided by the *event*, not by how much of it this row holds: one
+    // crossing midnight into the next week row covers a single day in each, and
+    // counting per row drew it as two unrelated pills (#253).
     val (bars, singles) = weekEvents.partition { ev ->
-        ev.isAllDay || days.count { ev.coversDay(it, zone) } > 1
+        ev.isAllDay || ev.spansMultipleDays(zone)
     }
     val spans = layoutAllDay(bars, days, zone).map { s ->
         MonthSpan(

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/BackupStep.kt

@@ -0,0 +1,100 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import android.net.Uri
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.CloudOff
+import androidx.compose.material.icons.filled.FolderOpen
+import androidx.compose.material.icons.filled.Schedule
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.floret.components.BenefitRow
+import de.jeanlucmakiola.floret.components.OnboardingScaffold
+import de.jeanlucmakiola.floret.components.OnboardingSpace
+
+/**
+ * Wizard step shown only when everything you write to is a device-only calendar
+ * (#163): the events exist nowhere but this phone, so losing it loses them.
+ *
+ * The primary action picks a folder and switches automatic backup on in one go.
+ * Everything it sets is a normal Backup setting, adjustable afterwards.
+ */
+@Composable
+internal fun BackupStep(
+    onEnable: (Uri) -> Unit,
+    onSkip: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+) {
+    val pickFolder = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.OpenDocumentTree(),
+    ) { uri ->
+        // Cancelling the picker decides nothing and leaves the step open.
+        uri?.let(onEnable)
+    }
+
+    OnboardingScaffold(
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+        topSpacing = OnboardingSpace.lg,
+        hero = { IconHero(Icons.Filled.CloudOff) },
+        actions = {
+            Button(
+                onClick = { runCatching { pickFolder.launch(null) } },
+                modifier = Modifier.fillMaxWidth().height(56.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.onboarding_backup_enable_button),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+            }
+            TextButton(
+                onClick = onSkip,
+                modifier = Modifier.fillMaxWidth(),
+            ) {
+                Text(stringResource(R.string.onboarding_backup_skip_button))
+            }
+        },
+    ) {
+        Text(
+            text = stringResource(R.string.onboarding_backup_title),
+            style = MaterialTheme.typography.headlineMedium,
+            textAlign = TextAlign.Center,
+        )
+        Spacer(Modifier.height(12.dp))
+        Text(
+            text = stringResource(R.string.onboarding_backup_body),
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+        )
+
+        Spacer(Modifier.height(OnboardingSpace.lg))
+
+        BenefitRow(
+            icon = Icons.Filled.FolderOpen,
+            title = stringResource(R.string.onboarding_backup_benefit_folder_title),
+            body = stringResource(R.string.onboarding_backup_benefit_folder_body),
+        )
+        Spacer(Modifier.height(OnboardingSpace.sm))
+        BenefitRow(
+            icon = Icons.Filled.Schedule,
+            title = stringResource(R.string.onboarding_backup_benefit_daily_title),
+            body = stringResource(R.string.onboarding_backup_benefit_daily_body),
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/BrandHero.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
@@ -9,6 +9,7 @@ import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.Lock
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
@@ -16,20 +17,25 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.colorResource
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 
+/** What, if anything, the brand mark is wearing in its corner. */
+internal enum class HeroBadge { Denied, Done }
+
 /**
  * The app's adaptive launcher mark, reconstructed as a large branded squircle —
  * the hero of the onboarding screens (floret-kit's OnboardingScaffold supplies
  * the shell; the mark stays app-local so each sibling keeps its own identity).
- * A lock badge overlays the corner when permission has been [denied].
+ * A [badge] overlays the corner where the screen has a verdict to give: blocked,
+ * or finished.
  */
 @Composable
-internal fun BrandHero(denied: Boolean) {
+internal fun BrandHero(badge: HeroBadge? = null) {
     Box(contentAlignment = Alignment.Center) {
         Box(
             modifier = Modifier
@@ -43,24 +49,56 @@ internal fun BrandHero(denied: Boolean) {
                 modifier = Modifier.fillMaxSize(),
             )
         }
-        if (denied) {
-            // A small lock badge sits over the corner to signal "blocked".
+        if (badge != null) {
+            val container = when (badge) {
+                HeroBadge.Denied -> MaterialTheme.colorScheme.errorContainer
+                HeroBadge.Done -> MaterialTheme.colorScheme.primaryContainer
+            }
+            val onContainer = when (badge) {
+                HeroBadge.Denied -> MaterialTheme.colorScheme.onErrorContainer
+                HeroBadge.Done -> MaterialTheme.colorScheme.onPrimaryContainer
+            }
             Box(
                 modifier = Modifier
                     .align(Alignment.BottomEnd)
                     .offset(x = 10.dp, y = 10.dp)
                     .size(44.dp)
                     .clip(CircleShape)
-                    .background(MaterialTheme.colorScheme.errorContainer),
+                    .background(container),
                 contentAlignment = Alignment.Center,
             ) {
                 Icon(
-                    imageVector = Icons.Filled.Lock,
+                    imageVector = when (badge) {
+                        HeroBadge.Denied -> Icons.Filled.Lock
+                        HeroBadge.Done -> Icons.Filled.Check
+                    },
                     contentDescription = null,
-                    tint = MaterialTheme.colorScheme.onErrorContainer,
+                    tint = onContainer,
                     modifier = Modifier.size(24.dp),
                 )
             }
         }
     }
 }
+
+/**
+ * A single [icon] in the brand squircle — the same silhouette as [BrandHero],
+ * for the wizard steps that stand for a feature rather than for the app itself.
+ */
+@Composable
+internal fun IconHero(icon: ImageVector) {
+    Box(
+        modifier = Modifier
+            .size(128.dp)
+            .clip(RoundedCornerShape(34.dp))
+            .background(MaterialTheme.colorScheme.primaryContainer),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onPrimaryContainer,
+            modifier = Modifier.size(56.dp),
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/DoneStep.kt

@@ -0,0 +1,61 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.floret.components.OnboardingScaffold
+import de.jeanlucmakiola.floret.components.OnboardingSpace
+
+/**
+ * The wizard's closing screen (#163): the flow ends on a full screen saying so
+ * rather than dropping into the calendar mid-gesture, and the brand mark wears
+ * the check that the last step earned.
+ */
+@Composable
+internal fun DoneStep(
+    onFinished: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+) {
+    OnboardingScaffold(
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+        topSpacing = OnboardingSpace.lg,
+        hero = { BrandHero(HeroBadge.Done) },
+        actions = {
+            Button(
+                onClick = onFinished,
+                modifier = Modifier.fillMaxWidth().height(56.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.onboarding_done_button),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+            }
+        },
+    ) {
+        Text(
+            text = stringResource(R.string.onboarding_done_title),
+            style = MaterialTheme.typography.headlineMedium,
+            textAlign = TextAlign.Center,
+        )
+        Spacer(Modifier.height(12.dp))
+        Text(
+            text = stringResource(R.string.onboarding_done_body),
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingMotion.kt

@@ -0,0 +1,58 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import androidx.compose.animation.ContentTransform
+import androidx.compose.animation.SizeTransform
+import androidx.compose.animation.core.FiniteAnimationSpec
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.togetherWith
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.unit.IntOffset
+
+/**
+ * The M3 Expressive spatial spring the wizard's steps travel on. Read in
+ * composable scope so it can be captured by `AnimatedContent`'s non-composable
+ * transitionSpec lambda.
+ */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+internal fun rememberOnboardingSlideSpec(): FiniteAnimationSpec<IntOffset> =
+    MaterialTheme.motionScheme.defaultSpatialSpec()
+
+/**
+ * Moving between wizard steps (#163): the steps sit side by side and the whole
+ * width swipes across, position on a spring so the arriving step settles with a
+ * little give rather than stopping dead.
+ *
+ * No cross-fade, unlike the calendar's shared-axis paging: two steps have
+ * nothing in common, so fading one through the other smears. Both are opaque and
+ * travel in lockstep, showing one screen pushing the other off.
+ *
+ * @param slideDir     +1 = forward (incoming from the right), -1 = back.
+ * @param spec         spatial spec, typically [rememberOnboardingSlideSpec].
+ * @param fadeSpec     effects spec used for the whole transition under reduced
+ *                     motion.
+ * @param reduceMotion when true, drop the movement and cross-fade alone.
+ */
+internal fun onboardingSlideTransition(
+    slideDir: Int,
+    spec: FiniteAnimationSpec<IntOffset>,
+    fadeSpec: FiniteAnimationSpec<Float>,
+    reduceMotion: Boolean,
+): ContentTransform {
+    if (reduceMotion) {
+        return fadeIn(fadeSpec).togetherWith(fadeOut(fadeSpec))
+    }
+    val dir = if (slideDir == 0) 1 else slideDir
+    return ContentTransform(
+        targetContentEnter = slideInHorizontally(spec) { w -> dir * w },
+        initialContentExit = slideOutHorizontally(spec) { w -> -dir * w },
+        // Clipping to the animating container would shear both steps against the
+        // viewport edge as they pass; there is no size change here to contain.
+        sizeTransform = SizeTransform(clip = false),
+    )
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingPlan.kt

@@ -0,0 +1,116 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+/** One screen of the first-launch wizard (#163), in the order they are shown. */
+enum class OnboardingStep {
+    /** Required: nothing works without the calendar grant. */
+    Permission,
+
+    /** Whether Calendula delivers reminder notifications itself. */
+    Reminders,
+
+    /** Only when nothing you write to is synced anywhere — offers a backup. */
+    Backup,
+
+    /** Which view the app opens on, chosen from a live preview. */
+    View,
+
+    /** How the Month view lays itself out, chosen from a live preview. */
+    MonthStyle,
+
+    /** Only on an install that has calendars the device is hiding (#75). */
+    Visibility,
+
+    /** The closing screen: everything is answered and the app is ready. */
+    Done,
+}
+
+/**
+ * Which steps this install owes and where it has got to. [steps] is the whole
+ * flow — completed steps included — so the counter doesn't renumber as steps
+ * are finished; [current] is null once nothing is left and the app opens.
+ */
+data class OnboardingPlan(
+    val steps: List<OnboardingStep>,
+    val current: OnboardingStep?,
+) {
+    /** 1-based position of [current] in [steps], or 0 when the flow is done. */
+    val index: Int get() = steps.indexOf(current) + 1
+
+    val total: Int get() = steps.size
+
+    /** A one-step flow is not a wizard: there is nothing to count down. */
+    val showsProgress: Boolean get() = total > 1
+
+    /** The step before [current], or null at the start (and once finished). */
+    val previous: OnboardingStep? get() = steps.getOrNull(index - 2).takeIf { current != null }
+
+    /**
+     * Whether the wizard can step back. Everything is re-askable except the
+     * calendar grant, which belongs to the system — once given there is nothing
+     * for a back press to return to.
+     */
+    val canGoBack: Boolean get() = previous != null && previous != OnboardingStep.Permission
+}
+
+/**
+ * Work out the flow from what is stored.
+ *
+ * The optional steps belong to installs still working through their first run.
+ * Before the grant that can only be guessed, so one that has not answered the
+ * reminder step either counts as fresh — the same condition
+ * [de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs.armOnboardingWizard]
+ * commits to storage a moment later, and clears again on the closing screen so
+ * a later re-grant is only the permission step.
+ *
+ * [backupApplies] is null until the calendar list can be read, i.e. for the
+ * whole permission step; the backup step is assumed to apply until proven
+ * otherwise, so the flow can only ever get shorter — never sprout a step the
+ * counter had not accounted for.
+ *
+ * The month-style step is *not* conditional on Month being the chosen view:
+ * Month is reachable from the drawer whatever opens first, and a step that came
+ * and went as the view is picked would move the counter under the user on the
+ * step right before it.
+ *
+ * [visibilityArmed] carries the one-time notice that the device is hiding some
+ * calendars (#75) — the only optional step an *existing* install can be given,
+ * which is why it is not gated on `fresh`, and on its own it earns no closing
+ * screen.
+ */
+fun onboardingPlan(
+    hasPermission: Boolean,
+    remindersDone: Boolean,
+    wizardArmed: Boolean,
+    backupDone: Boolean,
+    viewDone: Boolean,
+    monthStyleDone: Boolean,
+    backupApplies: Boolean?,
+    visibilityArmed: Boolean = false,
+    visibilityDone: Boolean = false,
+    doneShown: Boolean = false,
+): OnboardingPlan {
+    val fresh = wizardArmed || (!hasPermission && !remindersDone)
+    val steps = buildList {
+        if (!hasPermission || fresh) add(OnboardingStep.Permission)
+        if (!remindersDone || fresh) add(OnboardingStep.Reminders)
+        if (fresh && backupApplies != false) add(OnboardingStep.Backup)
+        if (fresh) {
+            add(OnboardingStep.View)
+            add(OnboardingStep.MonthStyle)
+        }
+        if (visibilityArmed) add(OnboardingStep.Visibility)
+        if (fresh) add(OnboardingStep.Done)
+    }
+    val current = steps.firstOrNull { step ->
+        when (step) {
+            OnboardingStep.Permission -> !hasPermission
+            OnboardingStep.Reminders -> !remindersDone
+            OnboardingStep.Backup -> !backupDone
+            OnboardingStep.View -> !viewDone
+            OnboardingStep.MonthStyle -> !monthStyleDone
+            OnboardingStep.Visibility -> !visibilityDone
+            OnboardingStep.Done -> !doneShown
+        }
+    }
+    return OnboardingPlan(steps, current)
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingSteps.kt

@@ -0,0 +1,118 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.floret.components.OnboardingProgress
+
+/**
+ * Renders the wizard's current [step] (#163). Each step commits its own answer
+ * through [viewModel], which then hands the host the next one.
+ */
+@Composable
+fun OnboardingSteps(
+    step: OnboardingStep,
+    plan: OnboardingPlan,
+    viewModel: OnboardingViewModel,
+    onPermissionGranted: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    // Collected for every step, not just the two that draw a preview: starting
+    // it when the picker composes would leave that step blank as it slides in.
+    val choice by viewModel.viewChoice.collectAsStateWithLifecycle()
+
+    // Coerced because the outgoing half of a transition may be a step the live
+    // plan has since dropped — the backup step goes once the calendars say it
+    // does not apply — and a "Step 0 of 3" flash is worse than a stale number.
+    val index = (plan.steps.indexOf(step) + 1).coerceAtLeast(1)
+    val progress: (@Composable () -> Unit)? = if (!plan.showsProgress) {
+        null
+    } else {
+        {
+            OnboardingProgress(
+                step = index,
+                total = plan.total,
+                label = stringResource(R.string.onboarding_step_counter, index, plan.total),
+            )
+        }
+    }
+
+    // The system back gesture does the same thing as the button, and stays off
+    // on the first step so back still leaves the app.
+    BackHandler(enabled = plan.canGoBack) { viewModel.goBack() }
+    val navigationIcon: (@Composable () -> Unit)? = if (!plan.canGoBack) {
+        null
+    } else {
+        {
+            IconButton(onClick = viewModel::goBack) {
+                Icon(
+                    imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                    contentDescription = stringResource(R.string.onboarding_back),
+                )
+            }
+        }
+    }
+
+    when (step) {
+        OnboardingStep.Permission -> PermissionScreen(
+            onGranted = onPermissionGranted,
+            modifier = modifier,
+            progress = progress,
+        )
+        OnboardingStep.Reminders -> ReminderStep(
+            onFinished = viewModel::finishReminders,
+            modifier = modifier,
+            progress = progress,
+            navigationIcon = navigationIcon,
+        )
+        OnboardingStep.Backup -> BackupStep(
+            onEnable = viewModel::enableAutoBackup,
+            onSkip = viewModel::skipBackup,
+            modifier = modifier,
+            progress = progress,
+            navigationIcon = navigationIcon,
+        )
+        // The choice is null only until DataStore's first emission; rendering
+        // nothing for that frame beats a preview built on the wrong defaults.
+        OnboardingStep.View -> choice?.let {
+            ViewStep(
+                choice = it,
+                onSelect = viewModel::setDefaultView,
+                onFinished = viewModel::finishView,
+                modifier = modifier,
+                progress = progress,
+                navigationIcon = navigationIcon,
+            )
+        }
+        OnboardingStep.MonthStyle -> choice?.let {
+            MonthStyleStep(
+                choice = it,
+                onSelect = viewModel::setMonthViewStyle,
+                onFinished = viewModel::finishMonthStyle,
+                modifier = modifier,
+                progress = progress,
+                navigationIcon = navigationIcon,
+            )
+        }
+        OnboardingStep.Visibility -> VisibilityStep(
+            onFinished = viewModel::finishVisibility,
+            modifier = modifier,
+            progress = progress,
+            navigationIcon = navigationIcon,
+        )
+        OnboardingStep.Done -> DoneStep(
+            onFinished = viewModel::finishOnboarding,
+            modifier = modifier,
+            progress = progress,
+            navigationIcon = navigationIcon,
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingViewModel.kt

@@ -0,0 +1,321 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import de.jeanlucmakiola.calendula.data.backup.BackupScheduler
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.calendar.CalendarVisibilityReconciler
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
+import de.jeanlucmakiola.calendula.data.reminders.ReminderScanner
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapLatest
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+/**
+ * Drives the first-launch wizard (#163): decides which steps this install owes
+ * (see [onboardingPlan]) and commits each answer.
+ *
+ * [plan] is null until the first stored emission, so the host renders nothing
+ * for that frame rather than flashing a step the user has already answered.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+@HiltViewModel
+class OnboardingViewModel @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val prefs: SettingsPrefs,
+    private val calendarPrefs: CalendarPrefs,
+    private val repository: CalendarRepository,
+    private val scanner: ReminderScanner,
+    private val visibilityReconciler: CalendarVisibilityReconciler,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    /** Null until the host reports it — assuming either way would flash a screen. */
+    private val permissionReported = MutableStateFlow<Boolean?>(null)
+
+    /**
+     * The grant as the rest of the flow sees it: published only once the wizard
+     * has been armed for it, since arming is a stored write and the frames
+     * before it lands would collapse the plan to its one-step form.
+     */
+    private val hasPermission: StateFlow<Boolean?> = permissionReported
+        .mapLatest { granted ->
+            if (granted == true) armWizardIfFresh()
+            granted
+        }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.Eagerly,
+            initialValue = null,
+        )
+
+    /**
+     * Whether the backup step applies: something of yours is worth exporting and
+     * nothing you write to is synced anywhere. Null while the calendar list
+     * cannot be read: every frame before the grant, and any read that fails —
+     * an empty list is also how a null cursor arrives, and guessing false there
+     * would drop the step for the whole session.
+     */
+    private val backupApplies: Flow<Boolean?> = hasPermission.flatMapLatest { granted ->
+        if (granted != true) {
+            flowOf(null)
+        } else {
+            repository.calendars()
+                .map { calendars -> if (calendars.isEmpty()) null else calendars.backupApplies() }
+                .catch { emit(null) }
+                .flowOn(io)
+        }
+    }
+
+    private val flags: Flow<OnboardingFlags> = combine(
+        prefs.reminderOnboardingDone,
+        prefs.onboardingWizardArmed,
+        prefs.onboardingBackupDone,
+        prefs.onboardingViewDone,
+        prefs.onboardingMonthStyleDone,
+        ::OnboardingFlags,
+    )
+
+    /** The closing steps' own flags, and whether the notice applies at all. */
+    private val closingFlags: Flow<ClosingFlags> = combine(
+        calendarPrefs.visibilityNoticePending.map { it == true },
+        prefs.onboardingVisibilityDone,
+        prefs.onboardingDoneShown,
+        ::ClosingFlags,
+    )
+
+    val plan: StateFlow<OnboardingPlan?> =
+        combine(hasPermission, flags, closingFlags, backupApplies) { granted, stored, closing, backup ->
+            granted?.let {
+                onboardingPlan(
+                    hasPermission = it,
+                    remindersDone = stored.remindersDone,
+                    wizardArmed = stored.wizardArmed,
+                    backupDone = stored.backupDone,
+                    viewDone = stored.viewDone,
+                    monthStyleDone = stored.monthStyleDone,
+                    backupApplies = backup,
+                    visibilityArmed = closing.visibilityArmed,
+                    visibilityDone = closing.visibilityDone,
+                    doneShown = closing.doneShown,
+                )
+            }
+        }.stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = null,
+        )
+
+    /** The current view preferences, for the view step's initial selection. */
+    val viewChoice: StateFlow<ViewChoice?> = combine(
+        prefs.defaultView,
+        prefs.monthViewStyle,
+        prefs.weekStart,
+        ::ViewChoice,
+    ).stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000L),
+        initialValue = null,
+    )
+
+    fun setHasPermission(granted: Boolean) {
+        permissionReported.value = granted
+    }
+
+    /**
+     * Arm the wizard for an install that has yet to answer the reminder step,
+     * whatever route the grant took. Gating this on the in-app grant would
+     * strand anyone who granted on Android's own settings screen and came back
+     * to a restarted process, leaving them the reminder step alone.
+     */
+    private suspend fun armWizardIfFresh() {
+        if (!prefs.reminderOnboardingDone.first()) prefs.armOnboardingWizard()
+    }
+
+    /**
+     * Record the in-app grant. The launch scan ran before it and bailed out
+     * without arming anything, so the first alarm would otherwise wait on the
+     * daily worker.
+     */
+    fun onPermissionGranted() {
+        scanner.scanInBackground()
+    }
+
+    /** Close the reminder step, recording whether notifications stay on. */
+    fun finishReminders(remindersEnabled: Boolean) {
+        viewModelScope.launch {
+            prefs.setRemindersEnabled(remindersEnabled)
+            prefs.setReminderOnboardingDone()
+            // Nothing else re-arms the scan: turning reminders off cancels the
+            // alarm (#75).
+            scanner.scan()
+        }
+    }
+
+    /**
+     * Re-ask the step before the current one, by clearing its answer. The plan
+     * derives the position from those answers, so un-setting one *is* the back
+     * navigation. The calendar grant belongs to the system and cannot be
+     * returned to, which [OnboardingPlan.canGoBack] already refuses.
+     */
+    fun goBack() {
+        viewModelScope.launch {
+            when (plan.value?.previous) {
+                OnboardingStep.Reminders -> prefs.setReminderOnboardingDone(false)
+                OnboardingStep.Backup -> prefs.setOnboardingBackupDone(false)
+                OnboardingStep.View -> prefs.setOnboardingViewDone(false)
+                OnboardingStep.MonthStyle -> prefs.setOnboardingMonthStyleDone(false)
+                OnboardingStep.Visibility -> prefs.setOnboardingVisibilityDone(false)
+                OnboardingStep.Done -> prefs.setOnboardingDoneShown(false)
+                OnboardingStep.Permission, null -> Unit
+            }
+        }
+    }
+
+    /** Close the backup step without setting anything up. */
+    fun skipBackup() {
+        viewModelScope.launch { prefs.setOnboardingBackupDone() }
+    }
+
+    /**
+     * Turn automatic backup on, writing to the folder the user just picked
+     * (taking a durable write grant so background runs can keep writing), and
+     * close the step.
+     */
+    fun enableAutoBackup(folder: Uri) {
+        viewModelScope.launch {
+            runCatching {
+                context.contentResolver.takePersistableUriPermission(
+                    folder,
+                    Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
+                )
+            }
+            prefs.setAutoBackupFolderUri(folder.toString())
+            prefs.setAutoBackupEnabled(true)
+            BackupScheduler.apply(
+                context = context,
+                enabled = true,
+                intervalMinutes = prefs.autoBackupIntervalMinutes.first(),
+                hasFolder = true,
+            )
+            // Immediate feedback: the first backup lands while onboarding runs.
+            BackupScheduler.runNow(context)
+            prefs.setOnboardingBackupDone()
+        }
+    }
+
+    fun setDefaultView(view: CalendarView) {
+        viewModelScope.launch { prefs.setDefaultView(view) }
+    }
+
+    fun setMonthViewStyle(style: MonthViewStyle) {
+        viewModelScope.launch { prefs.setMonthViewStyle(style) }
+    }
+
+    /** Close a picker step — the choice itself is saved as it is made. */
+    fun finishView() {
+        viewModelScope.launch { prefs.setOnboardingViewDone() }
+    }
+
+    fun finishMonthStyle() {
+        viewModelScope.launch { prefs.setOnboardingMonthStyleDone() }
+    }
+
+    /** Acknowledge the calendar-visibility notice (#75). */
+    fun finishVisibility() {
+        viewModelScope.launch {
+            prefs.setOnboardingVisibilityDone()
+            // Retiring the notice drops its step, so it waits until nothing
+            // follows — the count must not fall on the way to a later screen.
+            if (plan.value?.steps?.last() == OnboardingStep.Visibility) retireVisibilityNotice()
+        }
+    }
+
+    /** Close the wizard from its last screen. */
+    fun finishOnboarding() {
+        viewModelScope.launch {
+            prefs.finishOnboardingWizard()
+            retireVisibilityNotice()
+        }
+    }
+
+    /**
+     * Put the one-time visibility notice away for good — nothing else clears it
+     * now that the wizard owns it, and left standing it would keep its step in
+     * every later plan.
+     */
+    private suspend fun retireVisibilityNotice() {
+        if (calendarPrefs.visibilityNoticePending.first() == true) {
+            calendarPrefs.setVisibilityNoticePending(false)
+        }
+    }
+
+    /**
+     * Fold the retired app-local calendar visibility into the device's own, and
+     * arm the notice if this install has anything to announce. Runs whenever the
+     * app comes up holding the permission, however it was granted — one taken on
+     * Android's app-settings screen never reaches the permission step's callback.
+     */
+    fun reconcileCalendarVisibility() {
+        viewModelScope.launch { visibilityReconciler.run() }
+    }
+}
+
+/** The stored answers the plan is derived from. */
+private data class OnboardingFlags(
+    val remindersDone: Boolean,
+    val wizardArmed: Boolean,
+    val backupDone: Boolean,
+    val viewDone: Boolean,
+    val monthStyleDone: Boolean,
+)
+
+/** The tail of the flow: the visibility notice and the closing screen. */
+private data class ClosingFlags(
+    val visibilityArmed: Boolean,
+    val visibilityDone: Boolean,
+    val doneShown: Boolean,
+)
+
+/** What the view step starts from, and renders its previews with. */
+data class ViewChoice(
+    val defaultView: CalendarView,
+    val monthViewStyle: MonthViewStyle,
+    val weekStart: WeekStartPref,
+)
+
+/**
+ * True when this device holds events that live nowhere else: at least one local
+ * calendar worth exporting, and no writable synced calendar to carry them.
+ * A read-only subscription is not a backup, so it does not count.
+ */
+private fun List<CalendarSource>.backupApplies(): Boolean {
+    val exportable = any { it.isLocal && it.canModifyContents && !it.isManaged }
+    val syncedTarget = any { !it.isLocal && it.canModifyContents }
+    return exportable && !syncedTarget
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/PermissionScreen.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 import de.jeanlucmakiola.floret.components.BenefitRow
 import de.jeanlucmakiola.floret.components.OnboardingScaffold
@@ -10,19 +10,15 @@ import android.net.Uri
 import android.provider.Settings
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowForward
 import androidx.compose.material.icons.filled.CalendarMonth
 import androidx.compose.material.icons.filled.Lock
-import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Icon
@@ -32,13 +28,11 @@ import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
@@ -52,6 +46,7 @@ private val CALENDAR_PERMISSIONS = arrayOf(
 fun PermissionScreen(
     onGranted: () -> Unit,
     modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
     viewModel: PermissionViewModel = hiltViewModel(),
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
@@ -76,6 +71,7 @@ fun PermissionScreen(
     when (state) {
         is PermissionUiState.Rationale -> RationaleContent(
             onRequest = { launcher.launch(CALENDAR_PERMISSIONS) },
+            progress = progress,
             modifier = modifier,
         )
         is PermissionUiState.Denied -> DeniedContent(
@@ -83,6 +79,7 @@ fun PermissionScreen(
                 viewModel.onRetry()
                 launcher.launch(CALENDAR_PERMISSIONS)
             },
+            progress = progress,
             modifier = modifier,
         )
         is PermissionUiState.Granted -> {
@@ -94,11 +91,14 @@ fun PermissionScreen(
 @Composable
 private fun RationaleContent(
     onRequest: () -> Unit,
+    progress: (@Composable () -> Unit)?,
     modifier: Modifier = Modifier,
 ) {
     OnboardingScaffold(
         modifier = modifier,
-        hero = { BrandHero(denied = false) },
+        progress = progress,
+        topSpacing = OnboardingSpace.lg,
+        hero = { BrandHero() },
         actions = {
             Button(
                 onClick = onRequest,
@@ -116,16 +116,8 @@ private fun RationaleContent(
                     modifier = Modifier.size(20.dp),
                 )
             }
-            PrivacyFootnote()
         },
     ) {
-        Text(
-            text = stringResource(R.string.app_name).uppercase(),
-            style = MaterialTheme.typography.labelLarge,
-            color = MaterialTheme.colorScheme.primary,
-            letterSpacing = 2.sp,
-        )
-        Spacer(Modifier.height(OnboardingSpace.xs))
         Text(
             text = stringResource(R.string.permission_rationale_title),
             style = MaterialTheme.typography.headlineMedium,
@@ -139,14 +131,8 @@ private fun RationaleContent(
             textAlign = TextAlign.Center,
         )
 
-        Spacer(Modifier.height(OnboardingSpace.xl))
+        Spacer(Modifier.height(OnboardingSpace.lg))
 
-        BenefitRow(
-            icon = Icons.Filled.Lock,
-            title = stringResource(R.string.permission_benefit_private_title),
-            body = stringResource(R.string.permission_benefit_private_body),
-        )
-        Spacer(Modifier.height(OnboardingSpace.sm))
         BenefitRow(
             icon = Icons.Filled.CalendarMonth,
             title = stringResource(R.string.permission_benefit_sync_title),
@@ -154,9 +140,9 @@ private fun RationaleContent(
         )
         Spacer(Modifier.height(OnboardingSpace.sm))
         BenefitRow(
-            icon = Icons.Filled.VisibilityOff,
-            title = stringResource(R.string.permission_benefit_privacy_title),
-            body = stringResource(R.string.permission_benefit_privacy_body),
+            icon = Icons.Filled.Lock,
+            title = stringResource(R.string.permission_benefit_private_title),
+            body = stringResource(R.string.permission_benefit_private_body),
         )
     }
 }
@@ -164,12 +150,14 @@ private fun RationaleContent(
 @Composable
 private fun DeniedContent(
     onRetry: () -> Unit,
+    progress: (@Composable () -> Unit)?,
     modifier: Modifier = Modifier,
 ) {
     val context = LocalContext.current
     OnboardingScaffold(
         modifier = modifier,
-        hero = { BrandHero(denied = true) },
+        progress = progress,
+        hero = { BrandHero(HeroBadge.Denied) },
         actions = {
             Button(
                 onClick = {
@@ -208,25 +196,3 @@ private fun DeniedContent(
         )
     }
 }
-
-@Composable
-private fun PrivacyFootnote() {
-    Row(
-        modifier = Modifier.fillMaxWidth().padding(top = 4.dp),
-        horizontalArrangement = Arrangement.Center,
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Icon(
-            imageVector = Icons.Filled.Lock,
-            contentDescription = null,
-            tint = MaterialTheme.colorScheme.onSurfaceVariant,
-            modifier = Modifier.size(14.dp),
-        )
-        Spacer(Modifier.width(6.dp))
-        Text(
-            text = stringResource(R.string.permission_privacy_footnote),
-            style = MaterialTheme.typography.labelMedium,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-        )
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/PermissionUiState.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 sealed interface PermissionUiState {
     data object Rationale : PermissionUiState

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

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 import androidx.lifecycle.ViewModel
 import dagger.hilt.android.lifecycle.HiltViewModel

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/ReminderStep.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.permission
+package de.jeanlucmakiola.calendula.ui.onboarding
 
 import de.jeanlucmakiola.floret.components.BenefitRow
 import de.jeanlucmakiola.floret.components.OnboardingScaffold
@@ -8,34 +8,25 @@ import android.Manifest
 import android.os.Build
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.NotificationsActive
 import androidx.compose.material.icons.filled.ContentCopy
-import androidx.compose.material.icons.filled.Tune
 import androidx.compose.material3.Button
-import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
 import de.jeanlucmakiola.calendula.R
 
 /**
- * One-time onboarding step after the calendar grant (v1.4): explains that
+ * Wizard step after the calendar grant (v1.4): explains that
  * Calendula delivers reminder notifications itself, warns about duplicates
  * when a second calendar app has notifications on, and requests
  * `POST_NOTIFICATIONS` (a system dialog on API 33+ only; minSdk is 29).
@@ -45,9 +36,11 @@ import de.jeanlucmakiola.calendula.R
  * the Settings toggle re-requests it. "Not now" turns the in-app toggle off.
  */
 @Composable
-fun ReminderOnboardingScreen(
+fun ReminderStep(
     onFinished: (remindersEnabled: Boolean) -> Unit,
     modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
 ) {
     val launcher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.RequestPermission(),
@@ -55,7 +48,10 @@ fun ReminderOnboardingScreen(
 
     OnboardingScaffold(
         modifier = modifier,
-        hero = { BellHero() },
+        progress = progress,
+        navigationIcon = navigationIcon,
+        topSpacing = OnboardingSpace.lg,
+        hero = { IconHero(Icons.Filled.NotificationsActive) },
         actions = {
             Button(
                 onClick = {
@@ -80,13 +76,6 @@ fun ReminderOnboardingScreen(
             }
         },
     ) {
-        Text(
-            text = stringResource(R.string.app_name).uppercase(),
-            style = MaterialTheme.typography.labelLarge,
-            color = MaterialTheme.colorScheme.primary,
-            letterSpacing = 2.sp,
-        )
-        Spacer(Modifier.height(OnboardingSpace.xs))
         Text(
             text = stringResource(R.string.reminder_onboarding_title),
             style = MaterialTheme.typography.headlineMedium,
@@ -100,7 +89,7 @@ fun ReminderOnboardingScreen(
             textAlign = TextAlign.Center,
         )
 
-        Spacer(Modifier.height(OnboardingSpace.xl))
+        Spacer(Modifier.height(OnboardingSpace.lg))
 
         BenefitRow(
             icon = Icons.Filled.NotificationsActive,
@@ -113,30 +102,5 @@ fun ReminderOnboardingScreen(
             title = stringResource(R.string.reminder_benefit_duplicates_title),
             body = stringResource(R.string.reminder_benefit_duplicates_body),
         )
-        Spacer(Modifier.height(OnboardingSpace.sm))
-        BenefitRow(
-            icon = Icons.Filled.Tune,
-            title = stringResource(R.string.reminder_benefit_reversible_title),
-            body = stringResource(R.string.reminder_benefit_reversible_body),
-        )
-    }
-}
-
-/** A bell in the brand squircle — same silhouette as the permission hero. */
-@Composable
-private fun BellHero() {
-    Box(
-        modifier = Modifier
-            .size(128.dp)
-            .clip(RoundedCornerShape(34.dp))
-            .background(MaterialTheme.colorScheme.primaryContainer),
-        contentAlignment = Alignment.Center,
-    ) {
-        Icon(
-            imageVector = Icons.Filled.NotificationsActive,
-            contentDescription = null,
-            tint = MaterialTheme.colorScheme.onPrimaryContainer,
-            modifier = Modifier.size(56.dp),
-        )
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/ViewStep.kt

@@ -0,0 +1,209 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
+import de.jeanlucmakiola.calendula.ui.agenda.AgendaViewPreview
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
+import de.jeanlucmakiola.calendula.ui.common.PickerDescription
+import de.jeanlucmakiola.calendula.ui.common.ViewPreviewFrame
+import de.jeanlucmakiola.calendula.ui.common.icon
+import de.jeanlucmakiola.calendula.ui.common.labelRes
+import de.jeanlucmakiola.calendula.ui.day.DayViewPreview
+import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
+import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
+import de.jeanlucmakiola.calendula.ui.month.descriptionRes
+import de.jeanlucmakiola.calendula.ui.month.labelRes
+import de.jeanlucmakiola.calendula.ui.week.WeekViewPreview
+import de.jeanlucmakiola.floret.components.GroupedListInset
+import de.jeanlucmakiola.floret.components.OnboardingScaffold
+import de.jeanlucmakiola.floret.components.OnboardingSpace
+import de.jeanlucmakiola.floret.components.GroupedRow
+import de.jeanlucmakiola.floret.components.SelectedCheck
+import de.jeanlucmakiola.floret.components.positionOf
+import de.jeanlucmakiola.floret.locale.currentLocale
+
+/**
+ * Wizard step: which view the app opens on (#163). Built like the Settings
+ * picker it mirrors — a live preview over connected grouped rows. Selecting
+ * applies immediately and leaves the step open; the preview is the confirmation.
+ */
+@Composable
+internal fun ViewStep(
+    choice: ViewChoice,
+    onSelect: (CalendarView) -> Unit,
+    onFinished: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+) {
+    val weekStart = choice.weekStart.resolveFirstDay(currentLocale())
+
+    StepPickerScaffold(
+        title = stringResource(R.string.onboarding_view_title),
+        onFinished = onFinished,
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+    ) {
+        StepPreview(selected = choice.defaultView) { view ->
+            when (view) {
+                CalendarView.Month -> MonthStylePreview(
+                    style = choice.monthViewStyle,
+                    weekStart = weekStart,
+                    height = PREVIEW_HEIGHT,
+                )
+                CalendarView.Week -> WeekViewPreview(weekStart = weekStart, height = PREVIEW_HEIGHT)
+                CalendarView.Day -> DayViewPreview(height = PREVIEW_HEIGHT)
+                CalendarView.Agenda -> AgendaViewPreview(height = PREVIEW_HEIGHT)
+            }
+        }
+        IMPLEMENTED_VIEWS.forEachIndexed { index, view ->
+            val isSelected = view == choice.defaultView
+            GroupedRow(
+                title = stringResource(view.labelRes),
+                position = positionOf(index, IMPLEMENTED_VIEWS.size),
+                selected = isSelected,
+                leading = {
+                    Icon(
+                        imageVector = view.icon,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                },
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
+                onClick = { onSelect(view) },
+            )
+        }
+    }
+}
+
+/**
+ * Wizard step: how the Month view lays itself out (#163). The same shape as
+ * [ViewStep] and as the Settings chooser this duplicates, down to the selected
+ * style's own blurb sitting under its preview rather than on every row.
+ */
+@Composable
+internal fun MonthStyleStep(
+    choice: ViewChoice,
+    onSelect: (MonthViewStyle) -> Unit,
+    onFinished: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+) {
+    val weekStart = choice.weekStart.resolveFirstDay(currentLocale())
+    val options = MonthViewStyle.entries
+
+    StepPickerScaffold(
+        title = stringResource(R.string.onboarding_month_style_title),
+        onFinished = onFinished,
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+    ) {
+        StepPreview(selected = choice.monthViewStyle) { style ->
+            MonthStylePreview(style = style, weekStart = weekStart, height = PREVIEW_HEIGHT)
+        }
+        PickerDescription(stringResource(choice.monthViewStyle.descriptionRes))
+        options.forEachIndexed { index, style ->
+            val isSelected = style == choice.monthViewStyle
+            GroupedRow(
+                title = stringResource(style.labelRes),
+                position = positionOf(index, options.size),
+                selected = isSelected,
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
+                onClick = { onSelect(style) },
+            )
+        }
+    }
+}
+
+/**
+ * The shell both picker steps share: the wizard chrome around a title and a
+ * full-bleed column, since grouped rows carry their own inset.
+ */
+@Composable
+private fun StepPickerScaffold(
+    title: String,
+    onFinished: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+    body: @Composable ColumnScope.() -> Unit,
+) {
+    OnboardingScaffold(
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+        topSpacing = OnboardingSpace.xs,
+        contentPadding = 0.dp,
+        // The preview gets the room it needs; Continue scrolls in under the
+        // options rather than pinning to the bottom.
+        scrollingActions = true,
+        hero = {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.headlineSmall,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = GroupedListInset),
+            )
+        },
+        actions = {
+            Button(
+                onClick = onFinished,
+                // Full-bleed step: the button takes the grouped rows' own inset
+                // and ends up as wide as the options above it.
+                modifier = Modifier
+                    .padding(horizontal = GroupedListInset)
+                    .fillMaxWidth()
+                    .height(56.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.onboarding_view_continue_button),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+            }
+        },
+        body = body,
+    )
+}
+
+/**
+ * The live preview, framed like the picker's. The wider gap below keeps the rows
+ * reading as a group of their own rather than as the preview's caption.
+ */
+@Composable
+private fun <T> StepPreview(selected: T, content: @Composable (T) -> Unit) {
+    ViewPreviewFrame(
+        selected = selected,
+        label = "step-preview",
+        modifier = Modifier.padding(top = OnboardingSpace.xs, bottom = OnboardingSpace.md),
+        content = content,
+    )
+}
+
+/** The same size the Settings chooser gives it. */
+private val PREVIEW_HEIGHT: Dp = 280.dp

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/VisibilityStep.kt

@@ -0,0 +1,65 @@
+package de.jeanlucmakiola.calendula.ui.onboarding
+
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.VisibilityOff
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.floret.components.OnboardingScaffold
+import de.jeanlucmakiola.floret.components.OnboardingSpace
+
+/**
+ * Wizard step for the one-time notice that Calendula now follows the device's
+ * own per-calendar visibility and some of yours are switched off (#75, #163).
+ *
+ * Nothing to decide here — the app does not switch those calendars back on,
+ * since that would un-hide them everywhere else too.
+ */
+@Composable
+internal fun VisibilityStep(
+    onFinished: () -> Unit,
+    modifier: Modifier = Modifier,
+    progress: (@Composable () -> Unit)? = null,
+    navigationIcon: (@Composable () -> Unit)? = null,
+) {
+    OnboardingScaffold(
+        modifier = modifier,
+        progress = progress,
+        navigationIcon = navigationIcon,
+        topSpacing = OnboardingSpace.lg,
+        hero = { IconHero(Icons.Filled.VisibilityOff) },
+        actions = {
+            Button(
+                onClick = onFinished,
+                modifier = Modifier.fillMaxWidth().height(56.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.onboarding_visibility_button),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+            }
+        },
+    ) {
+        Text(
+            text = stringResource(R.string.calendars_visibility_notice_title),
+            style = MaterialTheme.typography.headlineMedium,
+            textAlign = TextAlign.Center,
+        )
+        Spacer(Modifier.height(12.dp))
+        Text(
+            text = stringResource(R.string.calendars_visibility_notice_message),
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+        )
+    }
+}

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

@@ -1,53 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.permission
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.calendula.data.reminders.ReminderScanner
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-/**
- * Gates the one-time reminder onboarding step (v1.4) shown after the calendar
- * grant. [onboardingDone] is null until DataStore's first emission so the
- * step neither flashes for users who completed it nor gets skipped.
- */
-@HiltViewModel
-class ReminderOnboardingViewModel @Inject constructor(
-    private val prefs: SettingsPrefs,
-    private val scanner: ReminderScanner,
-) : ViewModel() {
-
-    val onboardingDone: StateFlow<Boolean?> = prefs.reminderOnboardingDone
-        .map { done -> done as Boolean? }
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = null,
-        )
-
-    /** Close the step, recording whether reminder notifications stay on. */
-    fun finish(remindersEnabled: Boolean) {
-        viewModelScope.launch {
-            prefs.setRemindersEnabled(remindersEnabled)
-            prefs.setReminderOnboardingDone()
-            // Nothing else re-arms the scan: turning reminders off cancels the
-            // alarm (#75).
-            scanner.scan()
-        }
-    }
-
-    /**
-     * Re-scan after the calendar permission is granted. The launch scan runs
-     * before the grant and bails out without arming anything, so without this
-     * the first alarm waits on the daily worker.
-     */
-    fun rearmAfterGrant() {
-        scanner.scanInBackground()
-    }
-}

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

@@ -1,67 +1,109 @@
 package de.jeanlucmakiola.calendula.ui.search
 
+import android.Manifest
+import android.content.pm.PackageManager
+import androidx.activity.compose.BackHandler
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.animateColorAsState
 import androidx.compose.foundation.background
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListScope
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
 import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.SearchOff
+import androidx.compose.material.icons.filled.SelectAll
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Checkbox
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.MatchSpan
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.SearchHit
+import de.jeanlucmakiola.calendula.domain.SearchMonth
 import de.jeanlucmakiola.floret.identity.animateItemMotion
+import de.jeanlucmakiola.floret.identity.fadeThrough
 import de.jeanlucmakiola.floret.identity.predictiveBack
+import de.jeanlucmakiola.calendula.ui.common.declinedTitle
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.Position
+import de.jeanlucmakiola.floret.components.SnackChip
+import de.jeanlucmakiola.floret.components.SnackChipHeight
+import de.jeanlucmakiola.floret.components.SnackChipMargin
 import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.floret.locale.localizedDateFormatter
+import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
+import de.jeanlucmakiola.calendula.ui.common.RecurringScopeDialog
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.domain.spanFirstDay
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
 import de.jeanlucmakiola.floret.components.positionOf
+import kotlinx.coroutines.delay
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toJavaLocalDate
 import java.time.Instant as JavaInstant
@@ -69,11 +111,13 @@ import java.time.ZoneId
 import java.time.format.DateTimeFormatter
 import java.time.format.FormatStyle
 
+/** How long the delete confirmation chip stays up, matching a short snackbar. */
+private const val CHIP_MILLIS = 4_000L
+
 /**
- * Full-text event search (top-bar entry). Type a query → matching events
- * (title / location / description) across the whole calendar, newest-relevant
- * first; tap a result to open its detail. A full-screen overlay hosted by
- * [de.jeanlucmakiola.calendula.ui.CalendarHost].
+ * Full-text event search over title / location / description: tap a result to
+ * open its detail, long-press to select several and delete them at once (#80).
+ * A full-screen overlay hosted by [de.jeanlucmakiola.calendula.ui.CalendarHost].
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -85,63 +129,79 @@ fun SearchScreen(
 ) {
     val query by viewModel.query.collectAsStateWithLifecycle()
     val state by viewModel.state.collectAsStateWithLifecycle()
+    val selection by viewModel.selection.collectAsStateWithLifecycle()
+    val deleteState by viewModel.deleteState.collectAsStateWithLifecycle()
     val focusRequester = remember { FocusRequester() }
     val keyboard = LocalSoftwareKeyboardController.current
+    val context = LocalContext.current
+    val inSelection = selection.isNotEmpty()
+    var showDeleteDialog by remember { mutableStateOf(false) }
 
-    // Each fresh open starts blank and straight into typing. The ViewModel is
-    // activity-scoped so it outlives the overlay; clearing on (re)enter is what
-    // resets a previous search. Peeking a result doesn't re-run this (the screen
-    // stays composed under the detail), so backing out keeps the query.
+    // The ViewModel is activity-scoped, so a re-enter is what resets the last
+    // search, its selection and any delete receipt still up. Peeking a result
+    // doesn't re-run this — the screen stays composed under the detail.
     LaunchedEffect(Unit) {
         viewModel.setQuery("")
+        viewModel.clearSelection()
+        viewModel.consumeDeleteResult()
+    }
+    // The field only exists out of selection mode, so a recreation that lands
+    // mid-selection has to wait for the clear above before it can be focused.
+    var focusPending by remember { mutableStateOf(true) }
+    LaunchedEffect(inSelection) {
+        if (inSelection || !focusPending) return@LaunchedEffect
+        focusPending = false
         focusRequester.requestFocus()
         keyboard?.show()
     }
+
+    // Same in-place WRITE_CALENDAR upgrade the detail screen does: a v1.0 install
+    // holds only READ_CALENDAR, and granting continues into the held delete.
+    var pendingWrite by remember { mutableStateOf<(() -> Unit)?>(null) }
+    val writePermissionLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.RequestPermission(),
+    ) { granted ->
+        if (granted) pendingWrite?.invoke()
+        pendingWrite = null
+    }
+    val requireWrite: (() -> Unit) -> Unit = { action ->
+        val granted = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.WRITE_CALENDAR,
+        ) == PackageManager.PERMISSION_GRANTED
+        if (granted) {
+            action()
+        } else {
+            pendingWrite = action
+            writePermissionLauncher.launch(Manifest.permission.WRITE_CALENDAR)
+        }
+    }
+
+    // Back leaves selection mode before it leaves the screen, and without the
+    // predictive-back scale-out — that would read as search closing and snapping
+    // back. The two handlers are mutually exclusive on [inSelection].
+    BackHandler(enabled = inSelection) { viewModel.clearSelection() }
+
     Scaffold(
-        modifier = modifier.predictiveBack(onBack = onBack),
+        modifier = modifier.predictiveBack(onBack = onBack, enabled = !inSelection),
         containerColor = MaterialTheme.colorScheme.surface,
         topBar = {
-            TopAppBar(
-                title = {
-                    InlineTextField(
-                        value = query,
-                        onValueChange = viewModel::setQuery,
-                        placeholder = stringResource(R.string.search_hint),
-                        capitalization = KeyboardCapitalization.None,
-                        imeAction = ImeAction.Search,
+            SearchTopBar(
+                inSelection = inSelection,
+                query = query,
+                selectedCount = selection.size,
+                focusRequester = focusRequester,
+                onQueryChange = viewModel::setQuery,
                 onImeAction = { keyboard?.hide() },
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .focusRequester(focusRequester),
-                    )
-                },
-                navigationIcon = {
-                    IconButton(onClick = onBack) {
-                        Icon(
-                            imageVector = Icons.AutoMirrored.Filled.ArrowBack,
-                            contentDescription = stringResource(R.string.search_back),
-                        )
-                    }
-                },
-                actions = {
-                    if (query.isNotEmpty()) {
-                        IconButton(onClick = { viewModel.setQuery("") }) {
-                            Icon(
-                                imageVector = Icons.Default.Close,
-                                contentDescription = stringResource(R.string.search_clear),
-                            )
-                        }
-                    }
-                },
-                colors = TopAppBarDefaults.topAppBarColors(
-                    containerColor = MaterialTheme.colorScheme.surface,
-                ),
+                onBack = onBack,
+                onCloseSelection = viewModel::clearSelection,
+                onSelectAll = viewModel::selectAll,
+                onDelete = { requireWrite { showDeleteDialog = true } },
             )
         },
     ) { padding ->
-        // imePadding shrinks the content by the keyboard, so the centered
-        // idle/empty message re-centres in the space above it (and the results
-        // list lifts clear of the keyboard too).
+        // imePadding so the idle/empty message re-centres above the keyboard and
+        // the results list lifts clear of it.
         Box(
             modifier = Modifier
                 .fillMaxSize()
@@ -158,52 +218,314 @@ fun SearchScreen(
                     text = stringResource(R.string.search_empty, s.query),
                 )
                 is SearchUiState.Results -> SearchResults(
-                    events = s.events,
+                    results = s,
+                    selection = selection,
+                    inSelection = inSelection,
                     onEventClick = onEventClick,
+                    onToggle = viewModel::toggleSelection,
                 )
             }
+            DeleteOutcomeChip(
+                deleteState = deleteState,
+                onConsume = viewModel::consumeDeleteResult,
+                modifier = Modifier.align(Alignment.BottomStart),
+            )
+        }
+    }
+
+    if (showDeleteDialog) {
+        val count = selection.size
+        // One decision for the whole batch: the scope question is only asked when
+        // a recurring event is in it, and one-offs ignore whatever comes back.
+        if (viewModel.selectionHasRecurring()) {
+            RecurringScopeDialog(
+                title = stringResource(R.string.event_delete_recurring_title),
+                onSelect = { scope ->
+                    showDeleteDialog = false
+                    viewModel.deleteSelected(scope)
+                },
+                onDismiss = { showDeleteDialog = false },
+            )
+        } else {
+            AlertDialog(
+                onDismissRequest = { showDeleteDialog = false },
+                title = {
+                    Text(pluralStringResource(R.plurals.search_delete_title, count, count))
+                },
+                text = { Text(stringResource(R.string.event_delete_body)) },
+                confirmButton = {
+                    TextButton(
+                        onClick = {
+                            showDeleteDialog = false
+                            viewModel.deleteSelected(RecurringWriteScope.AllEvents)
+                        },
+                    ) {
+                        Text(
+                            text = stringResource(R.string.event_detail_delete),
+                            color = MaterialTheme.colorScheme.error,
+                        )
+                    }
+                },
+                dismissButton = {
+                    TextButton(onClick = { showDeleteDialog = false }) {
+                        Text(stringResource(R.string.dialog_cancel))
+                    }
+                },
+            )
         }
     }
 }
 
+/**
+ * The search field and the contextual selection bar as one bar: the bar stays
+ * in place across the swap, easing its colour and fading its slots through.
+ */
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun SearchTopBar(
+    inSelection: Boolean,
+    query: String,
+    selectedCount: Int,
+    focusRequester: FocusRequester,
+    onQueryChange: (String) -> Unit,
+    onImeAction: () -> Unit,
+    onBack: () -> Unit,
+    onCloseSelection: () -> Unit,
+    onSelectAll: () -> Unit,
+    onDelete: () -> Unit,
+) {
+    val container by animateColorAsState(
+        targetValue = if (inSelection) {
+            MaterialTheme.colorScheme.surfaceContainerHigh
+        } else {
+            MaterialTheme.colorScheme.surface
+        },
+        animationSpec = MaterialTheme.motionScheme.fastEffectsSpec(),
+        label = "search-top-bar-color",
+    )
+    // Held past the selection emptying, so the count has something to draw while
+    // it fades out.
+    var lastCount by remember { mutableIntStateOf(0) }
+    if (selectedCount > 0) lastCount = selectedCount
+
+    // Read here so the non-composable transitionSpec lambdas can capture it.
+    val slotSwap = fadeThrough()
+
+    TopAppBar(
+        title = {
+            AnimatedContent(
+                targetState = inSelection,
+                transitionSpec = { slotSwap },
+                label = "search-top-bar-title",
+            ) { selecting ->
+                if (selecting) {
+                    Text(
+                        pluralStringResource(
+                            R.plurals.search_selected_count,
+                            lastCount,
+                            lastCount,
+                        ),
+                    )
+                } else {
+                    InlineTextField(
+                        value = query,
+                        onValueChange = onQueryChange,
+                        placeholder = stringResource(R.string.search_hint),
+                        capitalization = KeyboardCapitalization.None,
+                        imeAction = ImeAction.Search,
+                        onImeAction = onImeAction,
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .focusRequester(focusRequester),
+                    )
+                }
+            }
+        },
+        navigationIcon = {
+            AnimatedContent(
+                targetState = inSelection,
+                transitionSpec = { slotSwap },
+                label = "search-top-bar-navigation",
+            ) { selecting ->
+                if (selecting) {
+                    IconButton(onClick = onCloseSelection) {
+                        Icon(
+                            imageVector = Icons.Default.Close,
+                            contentDescription = stringResource(R.string.search_selection_close),
+                        )
+                    }
+                } else {
+                    IconButton(onClick = onBack) {
+                        Icon(
+                            imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                            contentDescription = stringResource(R.string.search_back),
+                        )
+                    }
+                }
+            }
+        },
+        actions = {
+            AnimatedContent(
+                targetState = inSelection,
+                transitionSpec = { slotSwap },
+                label = "search-top-bar-actions",
+            ) { selecting ->
+                Row {
+                    if (selecting) {
+                        IconButton(onClick = onSelectAll) {
+                            Icon(
+                                imageVector = Icons.Default.SelectAll,
+                                contentDescription = stringResource(R.string.search_select_all),
+                            )
+                        }
+                        IconButton(onClick = onDelete) {
+                            Icon(
+                                imageVector = Icons.Default.Delete,
+                                contentDescription = stringResource(
+                                    R.string.search_delete_selected,
+                                ),
+                                tint = MaterialTheme.colorScheme.error,
+                            )
+                        }
+                    } else if (query.isNotEmpty()) {
+                        IconButton(onClick = { onQueryChange("") }) {
+                            Icon(
+                                imageVector = Icons.Default.Close,
+                                contentDescription = stringResource(R.string.search_clear),
+                            )
+                        }
+                    }
+                }
+            }
+        },
+        colors = TopAppBarDefaults.topAppBarColors(containerColor = container),
+    )
+}
+
+@OptIn(ExperimentalFoundationApi::class)
 @Composable
 private fun SearchResults(
-    events: List<EventInstance>,
+    results: SearchUiState.Results,
+    selection: Set<Long>,
+    inSelection: Boolean,
     onEventClick: (EventInstance) -> Unit,
+    onToggle: (Long) -> Unit,
 ) {
     LazyColumn(
         modifier = Modifier.fillMaxSize(),
-        contentPadding = PaddingValues(start = 16.dp, end = 16.dp, top = 8.dp, bottom = 96.dp),
+        // No horizontal inset: GroupedRow already insets itself.
+        contentPadding = PaddingValues(top = 8.dp, bottom = 96.dp),
     ) {
-        itemsIndexed(
-            items = events,
-            key = { _, event -> event.eventId },
-        ) { index, event ->
-            SearchResultRow(
-                event = event,
-                position = positionOf(index, events.size),
-                modifier = animateItemMotion(),
-                onClick = { onEventClick(event) },
+        results.results.months.forEach { month ->
+            stickyHeader(key = "month-${month.year}-${month.monthNumber}") {
+                SearchSectionHeader(text = monthLabel(month))
+            }
+            hitRows(month.hits, results, selection, inSelection, onEventClick, onToggle)
+        }
+        // Held back from the calendar above: matched only in the notes.
+        if (results.results.inDescriptions.isNotEmpty()) {
+            stickyHeader(key = "in-descriptions") {
+                SearchSectionHeader(text = stringResource(R.string.search_in_descriptions))
+            }
+            hitRows(
+                results.results.inDescriptions,
+                results,
+                selection,
+                inSelection,
+                onEventClick,
+                onToggle,
             )
         }
     }
 }
 
+/** One section's rows, sharing a grouped-card run. */
+private fun LazyListScope.hitRows(
+    hits: List<SearchHit>,
+    results: SearchUiState.Results,
+    selection: Set<Long>,
+    inSelection: Boolean,
+    onEventClick: (EventInstance) -> Unit,
+    onToggle: (Long) -> Unit,
+) {
+    itemsIndexed(
+        items = hits,
+        key = { _, hit -> hit.event.eventId },
+    ) { index, hit ->
+        val event = hit.event
+        val deletable = results.isDeletable(event)
+        SearchResultRow(
+            hit = hit,
+            position = positionOf(index, hits.size),
+            modifier = animateItemMotion(),
+            selected = event.eventId in selection,
+            // A read-only calendar's row can't join a batch, so in selection
+            // mode it goes quiet rather than offering a checkbox that fails.
+            inSelection = inSelection,
+            selectable = deletable,
+            onClick = when {
+                inSelection && deletable -> ({ onToggle(event.eventId) })
+                inSelection -> null
+                else -> ({ onEventClick(event) })
+            },
+            onLongClick = { onToggle(event.eventId) }.takeIf { deletable && !inSelection },
+        )
+    }
+}
+
+/** Pinned section label, styled like the agenda's day headers. */
+@Composable
+private fun SearchSectionHeader(text: String) {
+    Surface(color = MaterialTheme.colorScheme.surface, modifier = Modifier.fillMaxWidth()) {
+        Text(
+            text = text,
+            style = MaterialTheme.typography.titleSmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.padding(start = 28.dp, end = 28.dp, top = 16.dp, bottom = 8.dp),
+        )
+    }
+}
+
+/** "August 2026" in the locale's own field order. */
+@Composable
+private fun monthLabel(month: SearchMonth): String {
+    val locale = currentLocale()
+    return remember(month.year, month.monthNumber, locale) {
+        localizedDateFormatter(locale, "LLLLy")
+            .format(java.time.LocalDate.of(month.year, month.monthNumber, 1))
+    }
+}
+
 @Composable
 private fun SearchResultRow(
-    event: EventInstance,
+    hit: SearchHit,
     position: Position,
     modifier: Modifier = Modifier,
-    onClick: () -> Unit,
+    selected: Boolean = false,
+    inSelection: Boolean = false,
+    selectable: Boolean = true,
+    onClick: (() -> Unit)?,
+    onLongClick: (() -> Unit)? = null,
 ) {
+    val event = hit.event
     val dark = isSystemInDarkTheme()
     val soften = LocalSoftenColors.current
+    // On a picked row the headline is already recoloured for the secondary
+    // container, so the match is carried by weight alone there.
+    val highlight = SpanStyle(
+        fontWeight = FontWeight.Bold,
+        color = if (selected) Color.Unspecified else MaterialTheme.colorScheme.primary,
+    )
     GroupedRow(
-        modifier = modifier,
-        title = event.title,
-        summary = searchSummary(event),
+        // Faded like a past event anywhere else in the app — search reaches back
+        // through the whole history.
+        modifier = if (hit.isPast) modifier.alpha(EventDimAlpha) else modifier,
+        title = declinedTitle(marked(event.title, hit.titleSpans, highlight), event.isDeclined),
+        summary = searchSummary(hit, highlight),
         position = position,
         minHeight = 64.dp,
+        selected = selected,
+        dimmed = inSelection && !selectable,
         leading = {
             Box(
                 modifier = Modifier
@@ -212,21 +534,97 @@ private fun SearchResultRow(
                     .background(eventAccent(event.color, dark, soften)),
             )
         },
+        trailing = if (inSelection && selectable) {
+            {
+                Checkbox(
+                    checked = selected,
+                    onCheckedChange = null,
+                )
+            }
+        } else {
+            null
+        },
         onClick = onClick,
+        onLongClick = onLongClick,
     )
 }
 
-/** "Wed, 17 Jun 2026 · 09:00 · Office" — date, then time (or All day), then location. */
+/**
+ * The batch's receipt: how many went, and whether any refused. No Undo — the
+ * provider can't put a deleted event back.
+ */
 @Composable
-private fun searchSummary(event: EventInstance): String {
+private fun DeleteOutcomeChip(
+    deleteState: BulkDeleteUiState,
+    onConsume: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val message = when (deleteState) {
+        is BulkDeleteUiState.Done -> when {
+            deleteState.failed > 0 -> stringResource(
+                R.string.search_delete_partial,
+                deleteState.deleted,
+                deleteState.failed,
+            )
+            else -> pluralStringResource(
+                R.plurals.search_delete_done,
+                deleteState.deleted,
+                deleteState.deleted,
+            )
+        }
+        is BulkDeleteUiState.NeedsPermission -> if (deleteState.deleted > 0) {
+            stringResource(R.string.search_delete_denied_partial, deleteState.deleted)
+        } else {
+            stringResource(R.string.event_delete_write_denied)
+        }
+        else -> null
+    }
+    // Held past the state being consumed so the chip has something to draw while
+    // it springs back out.
+    val shown = remember { mutableStateOf("") }
+    if (message != null && shown.value != message) shown.value = message
+
+    LaunchedEffect(deleteState) {
+        if (message == null) return@LaunchedEffect
+        delay(CHIP_MILLIS)
+        onConsume()
+    }
+    Box(
+        modifier = modifier
+            .navigationBarsPadding()
+            .padding(start = SnackChipMargin, bottom = SnackChipMargin)
+            .height(SnackChipHeight),
+        contentAlignment = Alignment.CenterStart,
+    ) {
+        SnackChip(visible = message != null, message = shown.value)
+    }
+}
+
+/** [text] with every matched run emphasised. */
+private fun marked(text: String, spans: List<MatchSpan>, style: SpanStyle): AnnotatedString =
+    if (spans.isEmpty()) {
+        AnnotatedString(text)
+    } else {
+        buildAnnotatedString {
+            append(text)
+            spans.forEach { addStyle(style, it.start, it.end) }
+        }
+    }
+
+/**
+ * "Wed, 17 Jun 2026 · 09:00 · Office", with a second line excerpting the
+ * description when that is where the query matched.
+ */
+@Composable
+private fun searchSummary(hit: SearchHit, highlight: SpanStyle): AnnotatedString {
+    val event = hit.event
     val locale = currentLocale()
     val zone = remember { ZoneId.systemDefault() }
     val start = remember(event.start, zone) {
         JavaInstant.ofEpochMilli(event.start.toEpochMilliseconds()).atZone(zone)
     }
-    // From the shared span rule, not [start]: an all-day event sits at UTC
-    // midnight and would name the day before west of UTC (#82). The clock time
-    // below stays device-zone — it is only rendered for timed events.
+    // From the span rule, not [start]: an all-day event sits at UTC midnight and
+    // would name the day before west of UTC (#82).
     val dateText = remember(event.start, event.end, event.isAllDay, locale) {
         DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
             .format(event.spanFirstDay(TimeZone.currentSystemDefault()).toJavaLocalDate())
@@ -237,8 +635,23 @@ private fun searchSummary(event: EventInstance): String {
     } else {
         remember(locale, use24Hour) { timeOfDayFormatter(use24Hour, locale) }.format(start)
     }
-    val base = "$dateText · $timeText"
-    return event.location?.takeIf { it.isNotBlank() }?.let { "$base · $it" } ?: base
+    return buildAnnotatedString {
+        append("$dateText · $timeText")
+        event.location?.takeIf { it.isNotBlank() }?.let { location ->
+            append(" · ")
+            val offset = length
+            append(location)
+            hit.locationSpans.forEach {
+                addStyle(highlight, offset + it.start, offset + it.end)
+            }
+        }
+        hit.descriptionSnippet?.let { snippet ->
+            append("\n")
+            val offset = length
+            append(snippet.text)
+            snippet.spans.forEach { addStyle(highlight, offset + it.start, offset + it.end) }
+        }
+    }
 }
 
 @Composable

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

@@ -6,6 +6,10 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.EventSearch
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.SearchResults
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.FlowPreview
@@ -14,12 +18,19 @@ import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.mapLatest
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Clock
 import javax.inject.Inject
 
@@ -33,8 +44,30 @@ sealed interface SearchUiState {
     /** A query ran but matched nothing. */
     data class Empty(val query: String) : SearchUiState
 
-    /** Matches, ordered nearest-to-today first (upcoming ascending, then past descending). */
-    data class Results(val events: List<EventInstance>) : SearchUiState
+    /** Matches by month — see [de.jeanlucmakiola.calendula.domain.EventSearch]. */
+    data class Results(
+        val results: SearchResults,
+        /** Rows from these are kept out of selection rather than failing later. */
+        val readOnlyCalendarIds: Set<Long> = emptySet(),
+    ) : SearchUiState {
+        val events: List<EventInstance> get() = results.allHits.map { it.event }
+
+        fun isDeletable(event: EventInstance): Boolean =
+            event.calendarId !in readOnlyCalendarIds
+    }
+}
+
+/** Outcome of deleting the selected results (#80). */
+sealed interface BulkDeleteUiState {
+    data object Idle : BulkDeleteUiState
+
+    data object Deleting : BulkDeleteUiState
+
+    /** Terminal: [deleted] events went, [failed] wouldn't. */
+    data class Done(val deleted: Int, val failed: Int) : BulkDeleteUiState
+
+    /** WRITE_CALENDAR was revoked after [deleted] went; the rest wasn't tried. */
+    data class NeedsPermission(val deleted: Int) : BulkDeleteUiState
 }
 
 @OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
@@ -47,17 +80,42 @@ class SearchViewModel @Inject constructor(
     private val _query = MutableStateFlow("")
     val query: StateFlow<String> = _query.asStateFlow()
 
-    val state: StateFlow<SearchUiState> = _query
-        .debounce(250L)
-        .map { it.trim() }
-        .distinctUntilChanged()
+    /** Bumped after a delete so the same query re-runs against the changed provider. */
+    private val _reload = MutableStateFlow(0)
+
+    private val _selection = MutableStateFlow<Set<Long>>(emptySet())
+
+    /** Event ids picked in selection mode; empty means the mode is off. */
+    val selection: StateFlow<Set<Long>> = _selection.asStateFlow()
+
+    private val _deleteState = MutableStateFlow<BulkDeleteUiState>(BulkDeleteUiState.Idle)
+    val deleteState: StateFlow<BulkDeleteUiState> = _deleteState.asStateFlow()
+
+    val state: StateFlow<SearchUiState> = combine(
+        _query.debounce(250L).map { it.trim() }.distinctUntilChanged(),
+        _reload,
+    ) { q, _ -> q }
         .mapLatest { q ->
             if (q.length < MIN_QUERY_LENGTH) {
                 SearchUiState.Idle
             } else {
-                val results = repository.searchEvents(q)
-                if (results.isEmpty()) SearchUiState.Empty(q)
-                else SearchUiState.Results(sortNearestFirst(results))
+                val now = Clock.System.now()
+                val zone = TimeZone.currentSystemDefault()
+                val results = EventSearch.search(
+                    candidates = repository.searchEvents(q),
+                    query = q,
+                    now = now,
+                    todayStart = now.toLocalDateTime(zone).date.atStartOfDayIn(zone),
+                    zone = zone,
+                )
+                if (results.isEmpty) {
+                    SearchUiState.Empty(q)
+                } else {
+                    SearchUiState.Results(
+                        results = results,
+                        readOnlyCalendarIds = readOnlyCalendarIds(),
+                    )
+                }
             }
         }
         .catch { emit(SearchUiState.Idle) }
@@ -65,13 +123,94 @@ class SearchViewModel @Inject constructor(
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000L), SearchUiState.Idle)
 
     fun setQuery(value: String) {
+        if (value != _query.value) _selection.value = emptySet()
         _query.value = value
     }
 
-    /** Soonest upcoming (and ongoing) first, then the most recent past. */
-    private fun sortNearestFirst(events: List<EventInstance>): List<EventInstance> {
-        val now = Clock.System.now()
-        val (upcoming, past) = events.partition { it.end >= now }
-        return upcoming.sortedBy { it.start } + past.sortedByDescending { it.start }
+    /** Toggle one result; the first pick is what turns selection mode on. */
+    fun toggleSelection(eventId: Long) {
+        val current = _selection.value
+        _selection.value = if (eventId in current) current - eventId else current + eventId
     }
+
+    /** Pick every result that lives in a writable calendar. */
+    fun selectAll() {
+        val results = state.value as? SearchUiState.Results ?: return
+        _selection.value = results.events.filter(results::isDeletable).map { it.eventId }.toSet()
+    }
+
+    /** Leave selection mode. */
+    fun clearSelection() {
+        _selection.value = emptySet()
+    }
+
+    /** Whether the batch needs a [RecurringWriteScope] decision before it runs. */
+    fun selectionHasRecurring(): Boolean {
+        val results = state.value as? SearchUiState.Results ?: return false
+        val picked = _selection.value
+        return results.events.any { it.eventId in picked && it.isRecurring }
+    }
+
+    /**
+     * Delete every selected event. [scope] reaches the recurring ones only; a
+     * one-off always goes whole. One at a time, so a single failure doesn't take
+     * the rest with it — the tally lands in [deleteState].
+     */
+    fun deleteSelected(scope: RecurringWriteScope) {
+        if (_deleteState.value == BulkDeleteUiState.Deleting) return
+        val results = state.value as? SearchUiState.Results ?: return
+        val picked = _selection.value
+        val targets = results.events.filter { it.eventId in picked && results.isDeletable(it) }
+        if (targets.isEmpty()) return
+
+        viewModelScope.launch {
+            _deleteState.value = BulkDeleteUiState.Deleting
+            var deleted = 0
+            var failed = 0
+            var denied = false
+            for (event in targets) {
+                try {
+                    withContext(io) { deleteOne(event, scope) }
+                    deleted++
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: SecurityException) {
+                    denied = true
+                    break
+                } catch (e: Exception) {
+                    failed++
+                }
+            }
+            _selection.value = emptySet()
+            _reload.value += 1
+            _deleteState.value = if (denied) {
+                BulkDeleteUiState.NeedsPermission(deleted = deleted)
+            } else {
+                BulkDeleteUiState.Done(deleted = deleted, failed = failed)
+            }
+        }
+    }
+
+    /** Reset [deleteState] after the screen showed the outcome. */
+    fun consumeDeleteResult() {
+        _deleteState.value = BulkDeleteUiState.Idle
+    }
+
+    private suspend fun deleteOne(event: EventInstance, scope: RecurringWriteScope) {
+        val begin = event.start.toEpochMilliseconds()
+        when {
+            !event.isRecurring -> repository.deleteEvent(event.eventId)
+            scope == RecurringWriteScope.ThisEvent ->
+                repository.deleteOccurrence(event.eventId, begin)
+            scope == RecurringWriteScope.ThisAndFollowing ->
+                repository.deleteEventFromOccurrence(event.eventId, begin)
+            else -> repository.deleteEvent(event.eventId)
+        }
+    }
+
+    private suspend fun readOnlyCalendarIds(): Set<Long> =
+        repository.calendars().first()
+            .filterNot { it.canModifyContents }
+            .map { it.id }
+            .toSet()
 }

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

@@ -1,24 +1,13 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
-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.layout.Box
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
-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.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.ui.common.PickerDescription
+import de.jeanlucmakiola.calendula.ui.common.ViewPreviewFrame
 import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import de.jeanlucmakiola.calendula.ui.month.descriptionRes
@@ -27,7 +16,6 @@ import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import kotlinx.datetime.DayOfWeek
 
 /**
@@ -51,40 +39,22 @@ internal fun MonthViewStylePicker(
     onDismiss: () -> Unit,
 ) {
     val options = MonthViewStyle.entries
-    val reduceMotion = rememberReduceMotion()
     FullScreenPicker(
         title = stringResource(R.string.settings_month_view_style),
         onDismiss = onDismiss,
         predictiveBack = true,
     ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(horizontal = 12.dp, vertical = 8.dp)
-                .height(PREVIEW_HEIGHT),
-            contentAlignment = Alignment.Center,
-        ) {
-            Crossfade(
-                targetState = selected,
-                animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+        ViewPreviewFrame(
+            selected = selected,
             label = "month-style-preview",
+            modifier = Modifier.padding(vertical = 8.dp),
         ) { shown ->
-                // The preview renders the real grid at phone size and scales it
-                // down, so its own corners are square — the frame rounds it.
-                Box(
-                    modifier = Modifier
-                        .clip(PREVIEW_SHAPE)
-                        .background(MaterialTheme.colorScheme.surface)
-                        .clipToBounds(),
-                ) {
             MonthStylePreview(
                 style = shown,
                 weekStart = weekStart,
                 height = PREVIEW_HEIGHT,
             )
         }
-            }
-        }
         // The selected style's own blurb lives here, under its preview, rather
         // than on every row — the rows stay single-line and dense, and the words
         // describe exactly what is being shown above.
@@ -109,4 +79,3 @@ internal fun MonthViewStylePicker(
 }
 
 private val PREVIEW_HEIGHT = 280.dp
-private val PREVIEW_SHAPE = RoundedCornerShape(12.dp)

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

@@ -302,13 +302,14 @@ private fun ReportProblemRow(position: Position) {
 @Composable
 private fun LanguageRow(position: Position) {
     val context = LocalContext.current
+    val supported = remember { AppLanguage.supportedTags(context, R.xml.locales_config) }
     // Setting a locale recreates the activity; mirror the choice locally so the
     // row updates instantly even before the recreation lands.
-    var current by remember { mutableStateOf(AppLanguage.currentTag()) }
+    var current by remember { mutableStateOf(AppLanguage.currentTag(supported)) }
     var showDialog by remember { mutableStateOf(false) }
 
     // null = follow the system; the rest are BCP-47 tags from locales_config.xml.
-    val options = remember { listOf<String?>(null) + AppLanguage.supportedTags(context, R.xml.locales_config) }
+    val options = remember(supported) { listOf<String?>(null) + supported }
 
     GroupedRow(
         title = stringResource(R.string.settings_language),

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

@@ -42,6 +42,8 @@ data class SettingsUiState(
     val showWeekNumbers: Boolean = false,
     /** Whether the jump-to-today control sits in the top bar instead of the FAB (#60). */
     val todayButtonInToolbar: Boolean = false,
+    /** Whether events can be dragged to another slot to reschedule them (#68, #173). */
+    val dragToReschedule: Boolean = true,
     /** How far ahead the in-app Agenda screen shows events (v2.11). */
     val agendaScreenRange: AgendaRange = AgendaRange.Month,
     /** How far ahead the agenda widget shows events (v2.11). */

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

@@ -145,9 +145,15 @@ class SettingsViewModel @Inject constructor(
                     prefs.showWeekNumbers,
                     prefs.agendaShowToday,
                     prefs.softenCalendarColors,
+                    combine(
                         prefs.todayButtonInToolbar,
-                ) { hourLines, weekNumbers, showToday, soften, todayInToolbar ->
-                    DisplayToggles(hourLines, weekNumbers, showToday, soften, todayInToolbar)
+                        prefs.dragToReschedule,
+                        ::Pair,
+                    ),
+                ) { hourLines, weekNumbers, showToday, soften, (todayInToolbar, dragToMove) ->
+                    DisplayToggles(
+                        hourLines, weekNumbers, showToday, soften, todayInToolbar, dragToMove,
+                    )
                 },
             ) { view, screenRange, widgetRange, timeFormat, toggles ->
                 ViewSettings(
@@ -157,6 +163,7 @@ class SettingsViewModel @Inject constructor(
                     agendaShowToday = toggles.agendaShowToday,
                     softenColors = toggles.softenColors,
                     todayButtonInToolbar = toggles.todayButtonInToolbar,
+                    dragToReschedule = toggles.dragToReschedule,
                 )
             },
             combine(
@@ -189,6 +196,7 @@ class SettingsViewModel @Inject constructor(
                 agendaShowToday = views.agendaShowToday,
                 softenColors = views.softenColors,
                 todayButtonInToolbar = views.todayButtonInToolbar,
+                dragToReschedule = views.dragToReschedule,
                 agendaShowRangeBar = misc.showRangeBar,
                 autofocusEventTitle = misc.autofocusEventTitle,
                 pastEventDisplay = misc.pastEventDisplay,
@@ -289,6 +297,7 @@ class SettingsViewModel @Inject constructor(
         val agendaShowToday: Boolean,
         val softenColors: Boolean,
         val todayButtonInToolbar: Boolean,
+        val dragToReschedule: Boolean,
     )
 
     private data class DisplayToggles(
@@ -297,6 +306,7 @@ class SettingsViewModel @Inject constructor(
         val agendaShowToday: Boolean,
         val softenColors: Boolean,
         val todayButtonInToolbar: Boolean,
+        val dragToReschedule: Boolean,
     )
 
     private data class MiscSettings(
@@ -534,6 +544,10 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setTodayButtonInToolbar(enabled) }
     }
 
+    fun setDragToReschedule(enabled: Boolean) {
+        viewModelScope.launch { prefs.setDragToReschedule(enabled) }
+    }
+
     /**
      * Switch the launcher label (#44). The card highlights at once, then settles
      * on what the component state reports; the writes are binder round-trips and

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

@@ -114,7 +114,7 @@ internal fun ViewsScreen(
         GroupedRow(
             title = stringResource(R.string.settings_dim_completed),
             summary = stringResource(R.string.settings_dim_completed_summary),
-            position = Position.Bottom,
+            position = Position.Middle,
             trailing = {
                 Switch(
                     checked = state.dimCompletedEvents,
@@ -123,6 +123,18 @@ internal fun ViewsScreen(
             },
             onClick = { viewModel.setDimCompletedEvents(!state.dimCompletedEvents) },
         )
+        GroupedRow(
+            title = stringResource(R.string.settings_drag_to_reschedule),
+            summary = stringResource(R.string.settings_drag_to_reschedule_summary),
+            position = Position.Bottom,
+            trailing = {
+                Switch(
+                    checked = state.dragToReschedule,
+                    onCheckedChange = viewModel::setDragToReschedule,
+                )
+            },
+            onClick = { viewModel.setDragToReschedule(!state.dragToReschedule) },
+        )
 
         Spacer(Modifier.height(8.dp))
         SectionHeader(stringResource(R.string.settings_month_header))

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

@@ -1,33 +1,21 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
-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.layout.Box
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
-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.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.ui.common.PickerDescription
+import de.jeanlucmakiola.calendula.ui.common.ViewPreviewFrame
 import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.floret.locale.currentLocale
 
 /**
@@ -46,39 +34,23 @@ internal fun WeekStartPicker(
     onDismiss: () -> Unit,
 ) {
     val locale = currentLocale()
-    val reduceMotion = rememberReduceMotion()
     val resolved = selected.resolveFirstDay(locale)
     FullScreenPicker(
         title = stringResource(R.string.settings_week_start),
         onDismiss = onDismiss,
         predictiveBack = true,
     ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(horizontal = 12.dp, vertical = 8.dp)
-                .height(PREVIEW_HEIGHT),
-            contentAlignment = Alignment.Center,
-        ) {
-            Crossfade(
-                targetState = resolved,
-                animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+        ViewPreviewFrame(
+            selected = resolved,
             label = "week-start-preview",
+            modifier = Modifier.padding(vertical = 8.dp),
         ) { day ->
-                Box(
-                    modifier = Modifier
-                        .clip(PREVIEW_SHAPE)
-                        .background(MaterialTheme.colorScheme.surface)
-                        .clipToBounds(),
-                ) {
             MonthStylePreview(
                 style = monthStyle,
                 weekStart = day,
                 height = PREVIEW_HEIGHT,
             )
         }
-            }
-        }
         PickerDescription(stringResource(R.string.settings_week_start_hint))
         options.forEachIndexed { index, option ->
             val isSelected = option == selected
@@ -107,4 +79,3 @@ internal fun WeekStartPicker(
 
 /** Short enough to leave the first options on screen under it. */
 private val PREVIEW_HEIGHT = 200.dp
-private val PREVIEW_SHAPE = RoundedCornerShape(12.dp)

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

@@ -47,10 +47,12 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.key
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -62,13 +64,17 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.RectangleShape
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.customActions
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -84,8 +90,28 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
+import de.jeanlucmakiola.calendula.ui.common.declinedDecoration
+import de.jeanlucmakiola.calendula.ui.common.BlockTimeLabel
+import de.jeanlucmakiola.calendula.ui.common.animatedBlockPlacement
+import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
+import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
+import de.jeanlucmakiola.calendula.ui.common.MoveRequest
+import de.jeanlucmakiola.calendula.ui.common.MoveTarget
+import de.jeanlucmakiola.calendula.ui.common.TimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.TimelineDragOverlay
+import de.jeanlucmakiola.calendula.ui.common.TimelineDrop
+import de.jeanlucmakiola.calendula.ui.common.clipOffsetMinutes
+import de.jeanlucmakiola.calendula.ui.common.continuesAfter
+import de.jeanlucmakiola.calendula.ui.common.continuesBefore
+import de.jeanlucmakiola.calendula.ui.common.timedBlockShape
+import de.jeanlucmakiola.calendula.ui.common.eventDragAllowed
+import de.jeanlucmakiola.calendula.ui.common.eventMoveAction
+import de.jeanlucmakiola.calendula.ui.common.rememberEventDragSource
+import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.startInstant
 import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
+import de.jeanlucmakiola.calendula.ui.common.EventChipShape
 import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.eventInk
 import de.jeanlucmakiola.calendula.ui.common.NowLine
@@ -104,9 +130,13 @@ import de.jeanlucmakiola.calendula.ui.common.MIN_TITLE_WRAP_WIDTH
 import de.jeanlucmakiola.calendula.ui.common.SECONDARY_INK_ALPHA
 import de.jeanlucmakiola.calendula.ui.common.hourHeight
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelinePinchZoom
-import de.jeanlucmakiola.calendula.ui.common.formatHourLabel
 import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
+import de.jeanlucmakiola.calendula.ui.common.GUTTER_CONTENT_START_INSET
+import de.jeanlucmakiola.calendula.ui.common.GUTTER_WIDTH
+import de.jeanlucmakiola.calendula.ui.common.HourGutter
+import de.jeanlucmakiola.calendula.ui.common.TIMELINE_CONTENT_END_INSET
 import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
+import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.floret.time.isoWeekNumber
@@ -121,16 +151,13 @@ import kotlin.time.Clock
 import java.time.format.TextStyle as JavaTextStyle
 import java.util.Locale
 
-private val GUTTER_WIDTH = 48.dp
-/** Start inset for the gutter's content (week badge + hour labels) so it centres
- *  on the top bar's hamburger: with a 48dp gutter, 8dp lands the centre at 28dp
- *  (the app bar's 4dp inset + 24dp half icon button). */
-private val GUTTER_CONTENT_START_INSET = 8.dp
 private val ALL_DAY_ROW_HEIGHT = 24.dp
 private val ALL_DAY_VERTICAL_PADDING = 6.dp
+/** Gap between day columns; part of the column pitch a drag maps positions through. */
+private val COLUMN_GAP = 2.dp
 
 /** Total all-day strip height for a week (0 when there are no all-day events). */
-private fun WeekUiState.Success.allDayStripHeight(): Dp {
+internal fun WeekUiState.Success.allDayStripHeight(): Dp {
     if (allDaySpans.isEmpty()) return 0.dp
     val lanes = allDaySpans.maxOf { it.lane } + 1
     return ALL_DAY_ROW_HEIGHT * lanes + ALL_DAY_VERTICAL_PADDING * 2
@@ -331,9 +358,16 @@ private fun WeekContent(
     // gestures coexist without fighting.
     val swipeModifier = rememberCalendarPageSwipe(onSwipeNext, onSwipePrev)
 
+    // Above the AnimatedContent: a page change mid-drag would strand the
+    // floating block inside the outgoing page.
+    val dragController = rememberTimelineDragController()
+    val move = LocalEventMove.current
+    val zone = remember { TimeZone.currentSystemDefault() }
+
+    Box(modifier = modifier) {
         AnimatedContent(
             targetState = state,
-        modifier = modifier.then(swipeModifier),
+            modifier = Modifier.fillMaxSize().then(swipeModifier),
             contentKey = { s ->
                 when (s) {
                     is WeekUiState.Success -> "success-${s.weekStart}"
@@ -352,23 +386,38 @@ private fun WeekContent(
                     topSectionColor = topSectionColor,
                     scrollState = scrollState,
                     allDayHeight = allDayHeight,
+                    dragController = dragController,
                     onEventClick = onEventClick,
                     onOpenDay = onOpenDay,
                     onCreateAt = onCreateAt,
+                    onDrop = { drop ->
+                        move?.move(
+                            MoveRequest(
+                                eventId = drop.event.eventId,
+                                beginMillis = drop.event.start.toEpochMilliseconds(),
+                                endMillis = drop.event.end.toEpochMilliseconds(),
+                                target = MoveTarget.Start(drop.startInstant(zone)),
+                            ),
+                        )
+                    },
                 )
             }
         }
+        TimelineDragOverlay(dragController)
+    }
 }
 
 @Composable
-private fun WeekSuccess(
+internal fun WeekSuccess(
     state: WeekUiState.Success,
     topSectionColor: Color,
     scrollState: ScrollState,
     allDayHeight: Dp,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onOpenDay: (LocalDate) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
 ) {
     Column(modifier = Modifier.fillMaxSize()) {
         Column(
@@ -385,8 +434,10 @@ private fun WeekSuccess(
         Timeline(
             state = state,
             scrollState = scrollState,
+            dragController = dragController,
             onEventClick = onEventClick,
             onCreateAt = onCreateAt,
+            onDrop = onDrop,
         )
     }
 }
@@ -458,7 +509,7 @@ private fun WeekDayHeader(
     Row(
         modifier = Modifier
             .fillMaxWidth()
-            .padding(top = 4.dp, bottom = 8.dp),
+            .padding(top = 4.dp, bottom = 8.dp, end = TIMELINE_CONTENT_END_INSET),
     ) {
         // Mirror the day-column layout (empty weekday line + spacer) so the
         // badge lines up vertically with the date numbers. The start inset centres
@@ -554,7 +605,11 @@ private fun AllDayStrip(
             // Height is hoisted + animated so it slides and resizes smoothly;
             // padding sits inside it so the content area is lanes * row height.
             .height(height)
-            .padding(vertical = ALL_DAY_VERTICAL_PADDING),
+            .padding(
+                top = ALL_DAY_VERTICAL_PADDING,
+                bottom = ALL_DAY_VERTICAL_PADDING,
+                end = TIMELINE_CONTENT_END_INSET,
+            ),
     ) {
         // Keep the gutter-width offset so the bars line up with the day columns.
         Spacer(Modifier.width(GUTTER_WIDTH))
@@ -602,7 +657,7 @@ private fun AllDayBar(
     val fill = eventFill(event.color, dark, soften)
     Box(
         modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
-            .background(fill, RoundedCornerShape(4.dp))
+            .background(fill, EventChipShape)
             .clickable(onClick = onClick)
             .padding(horizontal = 6.dp, vertical = 2.dp)
             .semantics { contentDescription = title },
@@ -614,6 +669,7 @@ private fun AllDayBar(
             maxLines = 1,
             overflow = TextOverflow.Ellipsis,
             color = eventInk(fill),
+            textDecoration = declinedDecoration(event.isDeclined),
         )
     }
 }
@@ -622,13 +678,15 @@ private fun AllDayBar(
 private fun Timeline(
     state: WeekUiState.Success,
     scrollState: ScrollState,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
 ) {
     val dark = isSystemInDarkTheme()
-    val use24Hour = LocalUse24HourFormat.current
-    val locale = currentLocale()
     val zoom = LocalTimelineZoom.current
+    val density = LocalDensity.current
+    val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
 
     // BoxWithConstraints rather than Box: the fit-the-whole-day scale needs the
     // timeline's own viewport height, which is only known here — below the top
@@ -648,45 +706,40 @@ private fun Timeline(
         Row(modifier = Modifier.fillMaxSize().then(pinch)) {
             // Hour gutter (scrolls in sync with the day columns). Same start inset
             // as the header badge so the labels sit under it and on the hamburger.
-            Column(
-                modifier = Modifier
-                    .width(GUTTER_WIDTH)
-                    .padding(start = GUTTER_CONTENT_START_INSET)
-                    .fillMaxHeight()
-                    .verticalScroll(scrollState),
-            ) {
-                (0 until 24).forEach { h ->
-                    Box(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .height(hourHeight),
-                    ) {
-                        if (h > 0) {
-                            Text(
-                                text = formatHourLabel(h, use24Hour, locale),
-                                style = MaterialTheme.typography.labelSmall,
-                                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                                modifier = Modifier
-                                    .align(Alignment.TopCenter)
-                                    .offset(y = (-6).dp),
+            HourGutter(
+                scrollState = scrollState,
+                hourHeight = hourHeight,
+                dragController = dragController,
             )
-                        }
-                    }
-                }
-            }
             // Day columns: rounded, clipped scroll viewport (permanent corners).
             Box(
                 modifier = Modifier
                     .weight(1f)
                     .fillMaxHeight()
+                    .padding(end = TIMELINE_CONTENT_END_INSET)
                     .clip(RoundedCornerShape(16.dp))
-                    .verticalScroll(scrollState),
+                    .verticalScroll(scrollState)
+                    .onGloballyPositioned { dragController.geometry.viewport = it },
             ) {
                 Row(
                     modifier = Modifier
                         .fillMaxWidth()
-                        .height(totalHeight),
-                    horizontalArrangement = Arrangement.spacedBy(2.dp),
+                        .height(totalHeight)
+                        // The scrolling content itself, so its root position
+                        // already folds in the scroll offset.
+                        .onGloballyPositioned { coords ->
+                            val gap = with(density) { COLUMN_GAP.toPx() }
+                            dragController.geometry.let {
+                                it.grid = coords
+                                it.scroll = scrollState
+                                it.hourPx = with(density) { hourHeight.toPx() }
+                                it.columnGapPx = gap
+                                it.columnWidthPx = (coords.size.width + gap) / state.days.size
+                                it.days = state.days
+                                it.isRtl = isRtl
+                            }
+                        },
+                    horizontalArrangement = Arrangement.spacedBy(COLUMN_GAP),
                 ) {
                     state.days.forEach { day ->
                         DayColumnCard(
@@ -695,8 +748,10 @@ private fun Timeline(
                             date = day,
                             today = state.today,
                             hourHeight = hourHeight,
+                            dragController = dragController,
                             onEventClick = onEventClick,
                             onCreateAt = onCreateAt,
+                            onDrop = onDrop,
                             modifier = Modifier
                                 .weight(1f)
                                 .fillMaxHeight(),
@@ -715,13 +770,25 @@ private fun DayColumnCard(
     date: LocalDate,
     today: LocalDate,
     hourHeight: Dp,
+    dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val hourPx = with(LocalDensity.current) { hourHeight.toPx() }
     val showHourLines = LocalShowHourLines.current
     val hourLineColor = MaterialTheme.colorScheme.outlineVariant
+    // Tells a settled drop when this column has caught up with it.
+    LaunchedEffect(blocks, dragController.settling) {
+        dragController.noteGrid(date, blocks)
+    }
+    // The tap detector outlives the composition that installed it — a pinch or a
+    // Settings change moves the hour height without restarting it — so it reads
+    // the height and the callback through state handles instead of capturing
+    // them, or taps land on the scale the column had before the zoom (#148).
+    val currentHourPx = rememberUpdatedState(hourPx)
+    val currentOnCreateAt = rememberUpdatedState(onCreateAt)
     Card(
         // Plain rectangular columns — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -741,31 +808,49 @@ private fun DayColumnCard(
                 // blocks are consumed by their own handler first. Snaps to hour.
                 .pointerInput(date) {
                     detectTapGestures { offset ->
-                        val hour = (offset.y / hourPx).toInt().coerceIn(0, 23)
-                        onCreateAt(date, hour * 60)
+                        currentOnCreateAt.value(
+                            date,
+                            tappedMinuteOfDay(offset.y, currentHourPx.value),
+                        )
                     }
                 },
         ) {
             val colWidth = maxWidth
             val minEventHeight = hourHeight * MIN_EVENT_FRACTION
+            // Keyed by event, so a block that changes time or lane is the *same*
+            // composable afterwards and tweens there. The ordinal disambiguates
+            // a column holding two occurrences of one series.
+            val ordinals = mutableMapOf<Long, Int>()
             blocks.forEach { block ->
+                val ordinal = ordinals.merge(block.event.eventId, 1, Int::plus)!! - 1
+                key(block.event.eventId, ordinal) {
                     val laneWidth = colWidth / block.laneCount
                     val top = hourHeight * (block.startMin / 60f)
                     val rawHeight = hourHeight * ((block.endMin - block.startMin) / 60f)
                     val height = if (rawHeight < minEventHeight) minEventHeight else rawHeight
+                    val place = animatedBlockPlacement(
+                        x = laneWidth * block.lane,
+                        y = top,
+                        width = laneWidth,
+                        height = height,
+                    )
                     EventBlock(
                         block = block,
                         dark = dark,
-                    height = height,
-                    width = laneWidth,
+                        height = place.height,
+                        width = place.width,
+                        date = date,
+                        dragController = dragController,
                         onClick = { onEventClick(block.event) },
+                        onDrop = onDrop,
                         modifier = Modifier
-                        .offset(x = laneWidth * block.lane, y = top)
-                        .width(laneWidth)
-                        .height(height)
+                            .offset(x = place.x, y = place.y)
+                            .width(place.width)
+                            .height(place.height)
                             .padding(horizontal = 1.dp),
                     )
                 }
+            }
             // Current-time line, on top of the events, only on today's column.
             if (date == today) {
                 NowLine(date = date, hourHeight = hourHeight)
@@ -780,7 +865,10 @@ private fun EventBlock(
     dark: Boolean,
     height: Dp,
     width: Dp,
+    date: LocalDate,
+    dragController: TimelineDragController,
     onClick: () -> Unit,
+    onDrop: (TimelineDrop) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
@@ -823,12 +911,41 @@ private fun EventBlock(
     val dimmed = dimCutoff != null && block.event.hasEnded(dimCutoff)
     val soften = LocalSoftenColors.current
     val fill = eventFill(block.event.color, dark, soften)
+    val zone = remember { TimeZone.currentSystemDefault() }
+    val moveAction = eventMoveAction(block.event)
+    val draggable = eventDragAllowed(block.event)
+    // The drop takes this offset back off, so a tail clipped at midnight lands
+    // where the event's own start belongs (#253).
+    val clipOffset = remember(block, date, zone) { block.clipOffsetMinutes(date, zone) }
+    val shape = remember(block, date, zone) {
+        timedBlockShape(block.continuesBefore(date, zone), block.continuesAfter(date, zone))
+    }
+    val dragModifier = rememberEventDragSource(
+        enabled = draggable,
+        key = block.event.instanceId,
+        onPickUp = { pointer, blockRoot, _ ->
+            dragController.begin(block, clipOffset, pointer, blockRoot)
+        },
+        onMove = dragController::move,
+        onDrop = { dragController.finish()?.let(onDrop) },
+        onCancel = dragController::cancel,
+    )
+    val lifted = draggable && dragController.ghosts(block)
+    val ghost = ghostAlpha(lifted)
     Box(
         modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
-            .background(fill, RoundedCornerShape(4.dp))
+            // The source stays put as a ghost while its floating copy travels.
+            .then(if (ghost < 1f) Modifier.alpha(ghost) else Modifier)
+            .background(fill, shape)
             .clickable(onClick = onClick)
+            // After clickable, so it is the inner node and wins the main pass;
+            // the tap still works, since a drag consumes the up.
+            .then(dragModifier)
             .padding(horizontal = 4.dp, vertical = 2.dp)
-            .semantics { contentDescription = "$title, $timeLabel" },
+            .semantics {
+                contentDescription = "$title, $timeLabel"
+                if (moveAction != null) customActions = listOf(moveAction)
+            },
     ) {
         Column {
             if (showTitle) {
@@ -838,14 +955,12 @@ private fun EventBlock(
                     maxLines = titleMaxLines,
                     overflow = TextOverflow.Ellipsis,
                     color = eventInk(fill, alpha = 0.85f),
+                    textDecoration = declinedDecoration(block.event.isDeclined),
                 )
             }
             if (showTime) {
-                Text(
-                    text = timeLabel,
-                    style = MaterialTheme.typography.labelSmall,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis,
+                BlockTimeLabel(
+                    label = timeLabel,
                     color = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
                 )
             }
@@ -878,7 +993,12 @@ private fun WeekLoading() {
             // Same scale resolution as the loaded timeline, so the skeleton's
             // columns don't resize the moment the real week arrives.
             val totalHeight = scale.hourHeight(maxHeight) * 24
-            Row(modifier = Modifier.fillMaxSize().verticalScroll(scrollState)) {
+            Row(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(end = TIMELINE_CONTENT_END_INSET)
+                    .verticalScroll(scrollState),
+            ) {
                 Spacer(Modifier.width(GUTTER_WIDTH))
                 repeat(7) {
                     Box(

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

@@ -206,6 +206,17 @@ internal fun EventInstance.coversDay(day: LocalDate, zone: TimeZone): Boolean {
     return start < dayEnd && end > dayStart
 }
 
+/**
+ * True if this event touches more than one calendar day in [zone] — an all-day
+ * event covering a range, or a timed one crossing midnight. Occurrences are
+ * contiguous, so covering the day after the first is the whole question.
+ */
+internal fun EventInstance.spansMultipleDays(zone: TimeZone): Boolean {
+    val anchor = if (isAllDay) TimeZone.UTC else zone
+    val secondDay = start.toLocalDateTime(anchor).date.plus(1, DateTimeUnit.DAY)
+    return coversDay(secondDay, zone)
+}
+
 /**
  * Clip [events] to a single [day] and assign lanes so overlapping events render
  * side-by-side. Lane count is computed per overlap-cluster (a maximal run of

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

@@ -0,0 +1,78 @@
+package de.jeanlucmakiola.calendula.ui.week
+
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
+import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
+import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.sampleTimelineEvents
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.coroutines.flow.first
+import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+
+/**
+ * A live, scaled-down Week view for the onboarding view chooser. The week and
+ * today's column are real; only the events are stand-ins.
+ *
+ * The timeline is scrolled to the working day rather than to midnight — the
+ * live view centres on noon once it knows its own scroll range, which a preview
+ * that is never interacted with would otherwise never do.
+ */
+@Composable
+internal fun WeekViewPreview(
+    weekStart: DayOfWeek,
+    height: Dp,
+    modifier: Modifier = Modifier,
+) {
+    val zone = remember { TimeZone.currentSystemDefault() }
+    val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
+    val state = remember(today, weekStart, zone) { sampleWeekState(today, weekStart, zone) }
+    val scrollState = rememberScrollState()
+    LaunchedEffect(Unit) {
+        snapshotFlow { scrollState.maxValue }.first { it > 0 }
+        // Half the scroll range is noon — the same centring the live view does.
+        scrollState.scrollTo(scrollState.maxValue / 2)
+    }
+
+    ScaledViewPreview(height = height, modifier = modifier) {
+        WeekSuccess(
+            state = state,
+            topSectionColor = MaterialTheme.colorScheme.surface,
+            scrollState = scrollState,
+            allDayHeight = state.allDayStripHeight(),
+            dragController = rememberTimelineDragController(),
+            onEventClick = {},
+            onOpenDay = {},
+            onCreateAt = { _, _ -> },
+            onDrop = {},
+        )
+    }
+}
+
+/** Sample week state, laid out through the same helpers the live view uses. */
+private fun sampleWeekState(
+    today: LocalDate,
+    weekStart: DayOfWeek,
+    zone: TimeZone,
+): WeekUiState.Success {
+    val start = today.startOfWeek(weekStart)
+    val days = (0 until 7).map { start.plus(it, DateTimeUnit.DAY) }
+    val events = sampleTimelineEvents(days, today, zone)
+    return WeekUiState.Success(
+        weekStart = start,
+        today = today,
+        days = days,
+        allDaySpans = layoutAllDay(events.filter { it.isAllDay }, days, zone),
+        timedByDay = days.associateWith { layoutDay(events, it, zone) },
+    )
+}

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

@@ -0,0 +1,115 @@
+package de.jeanlucmakiola.calendula.widget
+
+import android.app.AlarmManager
+import android.app.PendingIntent
+import android.appwidget.AppWidgetManager
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import androidx.core.content.getSystemService
+import de.jeanlucmakiola.calendula.widget.agenda.AgendaWidgetReceiver
+import de.jeanlucmakiola.calendula.widget.month.MonthWidgetReceiver
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.Instant
+
+/**
+ * Holds the app's own wake-up for the next local midnight, so the home-screen
+ * widgets roll "today" over on the day boundary (#228).
+ *
+ * The widgets used to lean on `ACTION_DATE_CHANGED`, which is not an exempted
+ * implicit broadcast — a manifest-declared receiver has not been given it since
+ * Android 8, leaving only the throttled `updatePeriodMillis`.
+ *
+ * Exactly one alarm exists at a time and every firing re-arms the next, the same
+ * shape as [de.jeanlucmakiola.calendula.data.reminders.ReminderAlarmScheduler].
+ * Deliberately **inexact**: `setAndAllowWhileIdle` needs no permission and
+ * survives doze (plain `set` does not), a rollover a few minutes late is
+ * invisible on a sleeping screen, and exact alarms stay reserved for snooze.
+ */
+object WidgetRolloverScheduler {
+
+    /**
+     * Fire just *after* midnight: an alarm delivered a few milliseconds early
+     * would still read the old date and re-arm for an instant later.
+     */
+    internal val ROLLOVER_SLACK = 5.seconds
+
+    /**
+     * Arm the next rollover, or cancel a pending one when no widget is placed.
+     * Idempotent, so every trigger (boot, app start, widget added/removed, the
+     * rollover itself, a clock or timezone change) can just call it.
+     */
+    fun sync(context: Context) {
+        val appContext = context.applicationContext
+        val alarmManager = appContext.getSystemService<AlarmManager>() ?: return
+        val pendingIntent = rolloverPendingIntent(appContext)
+        if (!hasPlacedWidgets(appContext)) {
+            alarmManager.cancel(pendingIntent)
+            return
+        }
+        val triggerAt = nextRolloverAt(Clock.System.now(), TimeZone.currentSystemDefault())
+        alarmManager.setAndAllowWhileIdle(
+            AlarmManager.RTC_WAKEUP, triggerAt.toEpochMilliseconds(), pendingIntent,
+        )
+    }
+
+    /**
+     * The instant just after the next local midnight following [now] in [zone].
+     *
+     * The *actual* start of day, not 00:00, so it holds where a DST jump means
+     * midnight never happens (Havana) and where a date-line move skips a whole
+     * local date (Apia, December 2011) — the loop walks on to the next real day.
+     *
+     * The mirror case — a zone rewinding *across* midnight, so the day starts
+     * twice — resolves to the earlier start and runs an hour ahead of the clock.
+     * No live tz entry does that (Brazil dropped DST in 2019) and
+     * `updatePeriodMillis` covers it, so it isn't worth state to detect.
+     */
+    fun nextRolloverAt(now: Instant, zone: TimeZone): Instant {
+        val date = now.toLocalDateTime(zone).date
+        var days = 1
+        while (days <= MAX_LOOKAHEAD_DAYS) {
+            val candidate = date.plus(days, DateTimeUnit.DAY).atStartOfDayIn(zone) + ROLLOVER_SLACK
+            if (candidate > now) return candidate
+            days++
+        }
+        // Unreachable for any zone in the tz database. Deliberately an hour and
+        // not the slack: a 5-second retry would just hit this branch again and
+        // wake the device in a loop.
+        return now + 1.hours
+    }
+
+    private fun hasPlacedWidgets(context: Context): Boolean {
+        val manager = AppWidgetManager.getInstance(context) ?: return false
+        return PROVIDERS.any {
+            manager.getAppWidgetIds(ComponentName(context, it)).isNotEmpty()
+        }
+    }
+
+    private fun rolloverPendingIntent(context: Context): PendingIntent =
+        PendingIntent.getBroadcast(
+            context,
+            ROLLOVER_REQUEST_CODE,
+            Intent(context, WidgetUpdateReceiver::class.java)
+                .setAction(WidgetUpdateReceiver.ACTION_ROLLOVER),
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+
+    private val PROVIDERS = listOf(
+        MonthWidgetReceiver::class.java,
+        AgendaWidgetReceiver::class.java,
+    )
+
+    /** Fixed: there is only ever one rollover alarm, and re-arming must replace it. */
+    private const val ROLLOVER_REQUEST_CODE = 0x0DA1
+
+    /** A gap of more than a couple of days does not exist in any tz database entry. */
+    private const val MAX_LOOKAHEAD_DAYS = 3
+}

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

@@ -4,6 +4,7 @@ import android.os.Build
 import androidx.compose.runtime.Composable
 import androidx.glance.GlanceTheme
 import androidx.glance.material3.ColorProviders
+import androidx.glance.text.TextDecoration
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaDarkFallback
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaLightFallback
 
@@ -34,3 +35,10 @@ fun CalendulaGlanceTheme(content: @Composable () -> Unit) {
     }
     GlanceTheme(colors = colors, content = content)
 }
+
+/**
+ * Glance's counterpart to the app's `declinedDecoration`: a declined invitation
+ * reads the same on the home screen as it does inside the app (#180).
+ */
+fun glanceDeclinedDecoration(isDeclined: Boolean): TextDecoration =
+    if (isDeclined) TextDecoration.LineThrough else TextDecoration.None

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

@@ -12,19 +12,40 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 
 /**
- * Redraws both home-screen widgets when their data goes stale. Triggered by:
+ * Redraws both home-screen widgets when their data goes stale, and keeps the
+ * midnight rollover alarm armed. Triggered by:
  *  - `PROVIDER_CHANGED` from the calendar provider — fires on any data change,
  *    so it covers both the app's own writes and external sync.
- *  - `DATE_CHANGED` / `TIME_SET` / `TIMEZONE_CHANGED` — so "today" highlighting
- *    and the upcoming window roll over at midnight / on a clock change.
+ *  - [ACTION_ROLLOVER], the app's own alarm from [WidgetRolloverScheduler] —
+ *    the day boundary, so "today" highlighting and the agenda's past-event
+ *    dimming move on (#228).
+ *  - `TIME_SET` / `TIMEZONE_CHANGED` — the day boundary moved, so redraw *and*
+ *    re-arm.
+ *  - `BOOT_COMPLETED` / `MY_PACKAGE_REPLACED` — both wipe pending alarms; the
+ *    latter is also what arms installs upgrading into the fix.
  *
- * Both widgets also carry an `updatePeriodMillis` backstop in their provider
- * XML, and the month widget's refresh button forces an immediate redraw.
+ * `DATE_CHANGED` is a free extra in the filter that nothing depends on — see
+ * [WidgetRolloverScheduler]. The backstops are `updatePeriodMillis` in the
+ * provider XML and the month widget's refresh button.
+ *
+ * Exported for the system broadcasts; an extra redraw from another app is
+ * harmless.
  */
 class WidgetUpdateReceiver : BroadcastReceiver() {
     override fun onReceive(context: Context, intent: Intent) {
-        val pending = goAsync()
+        // Exported, so anything can reach it with an explicit intent. Nothing
+        // here crosses a trust boundary, but narrowing to the actions we asked
+        // for keeps a stray broadcast from costing two wide provider reads.
+        if (intent.action !in HANDLED_ACTIONS) return
         val appContext = context.applicationContext
+        // Re-arm first, so the next day boundary is covered whatever the redraw
+        // does. Every handled action either dropped, consumed or invalidated it.
+        WidgetRolloverScheduler.sync(appContext)
+        // The host sends APPWIDGET_UPDATE after both of these anyway, so
+        // redrawing here would only repeat the work in a cold process, at the
+        // moment the device is most contended.
+        if (intent.action in REARM_ONLY_ACTIONS) return
+        val pending = goAsync()
         // Calendar data may have changed (sync / our own write) — drop the cached
         // month window so the widgets reload fresh. Month paging does NOT call
         // this, so arrow taps stay instant.
@@ -38,4 +59,23 @@ class WidgetUpdateReceiver : BroadcastReceiver() {
             }
         }
     }
+
+    companion object {
+        /** The app's own midnight wake-up; see [WidgetRolloverScheduler]. */
+        const val ACTION_ROLLOVER = "de.jeanlucmakiola.calendula.widget.ROLLOVER"
+
+        /** Both wipe pending alarms, and the host redraws the widgets itself after them. */
+        private val REARM_ONLY_ACTIONS = setOf(
+            Intent.ACTION_BOOT_COMPLETED,
+            Intent.ACTION_MY_PACKAGE_REPLACED,
+        )
+
+        internal val HANDLED_ACTIONS = REARM_ONLY_ACTIONS + setOf(
+            ACTION_ROLLOVER,
+            Intent.ACTION_PROVIDER_CHANGED,
+            Intent.ACTION_DATE_CHANGED,
+            Intent.ACTION_TIME_CHANGED,
+            Intent.ACTION_TIMEZONE_CHANGED,
+        )
+    }
 }

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.agenda
 
+import de.jeanlucmakiola.calendula.widget.glanceDeclinedDecoration
 import android.content.Context
 import android.content.res.Configuration
 import androidx.compose.runtime.Composable
@@ -24,7 +25,6 @@ import androidx.glance.appwidget.cornerRadius
 import androidx.glance.appwidget.lazy.LazyColumn
 import androidx.glance.appwidget.lazy.items
 import androidx.glance.appwidget.provideContent
-import androidx.glance.appwidget.updateAll
 import androidx.glance.background
 import androidx.glance.currentState
 import androidx.glance.state.PreferencesGlanceStateDefinition
@@ -74,11 +74,6 @@ import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Instant
 import java.util.Locale
 
-/**
- * "Upcoming" agenda widget — a continuously scrolling list of the next ~30 days
- * of events grouped under day headers (the Google "Schedule" widget model).
- * Reuses the app's [groupAgendaDays] grouping so it matches the in-app agenda.
- */
 /**
  * Per-instance Glance state key holding the agenda range (as [AgendaRange.storageValue]).
  * The range is read reactively in the composition ([currentState]) so a settings
@@ -113,6 +108,11 @@ internal val AGENDA_SHOW_TODAY_STATE_KEY = booleanPreferencesKey("agenda_show_to
  */
 internal val AGENDA_SIZE_KEY = stringPreferencesKey("widget_size")
 
+/**
+ * "Upcoming" agenda widget — a continuously scrolling list of the next ~30 days
+ * of events grouped under day headers (the Google "Schedule" widget model).
+ * Reuses the app's [groupAgendaDays] grouping so it matches the in-app agenda.
+ */
 class AgendaWidget : GlanceAppWidget() {
 
     override val stateDefinition = PreferencesGlanceStateDefinition
@@ -135,17 +135,23 @@ class AgendaWidget : GlanceAppWidget() {
     }
 }
 
-/** Re-reads the calendar and redraws the widget (header refresh button). */
+/**
+ * Redraws the widget (header refresh button). Targets the tapped widget's own id
+ * rather than `updateAll`, whose provider-name lookup is empty in a process a tap
+ * woke from cold — see `ShiftMonthAction` (#18). A cold process re-reads the
+ * calendar in the `provideGlance` preamble; a live session only recomposes from
+ * the snapshot it already has (see [AGENDA_RANGE_KEY]).
+ */
 class RefreshAgendaAction : ActionCallback {
     override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
-        AgendaWidget().updateAll(context.applicationContext)
+        AgendaWidget().update(context.applicationContext, glanceId)
     }
 }
 
 /**
  * Upper bound on rows handed to the [LazyColumn], so the serialized RemoteViews
  * stays well inside the binder transaction limit regardless of range and calendar
- * size (see the [SizeMode.Exact] note above). Far more than fits on screen — a
+ * size (see the [SizeMode.Single] note above). Far more than fits on screen — a
  * user scrolling a home-screen widget past a hundred rows is not a case worth
  * risking a failed update for.
  */
@@ -416,7 +422,11 @@ private fun EventRow(
             Text(
                 text = title,
                 maxLines = 1,
-                style = TextStyle(color = titleColor, fontSize = metrics.eventTitle),
+                style = TextStyle(
+                    color = titleColor,
+                    fontSize = metrics.eventTitle,
+                    textDecoration = glanceDeclinedDecoration(event.isDeclined),
+                ),
             )
             Text(
                 text = eventTimeSummary(context, event, day, is24Hour),

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

@@ -1,7 +1,10 @@
 package de.jeanlucmakiola.calendula.widget.agenda
 
+import android.appwidget.AppWidgetManager
+import android.content.Context
 import androidx.glance.appwidget.GlanceAppWidget
 import androidx.glance.appwidget.GlanceAppWidgetReceiver
+import de.jeanlucmakiola.calendula.widget.WidgetRolloverScheduler
 
 /**
  * Host-facing receiver for the agenda widget. Declared in the manifest with the
@@ -10,4 +13,32 @@ import androidx.glance.appwidget.GlanceAppWidgetReceiver
  */
 class AgendaWidgetReceiver : GlanceAppWidgetReceiver() {
     override val glanceAppWidget: GlanceAppWidget = AgendaWidget()
+
+    /** First agenda widget placed — start rolling "today" over at midnight (#228). */
+    override fun onEnabled(context: Context) {
+        super.onEnabled(context)
+        WidgetRolloverScheduler.sync(context)
+    }
+
+    /**
+     * Last agenda widget removed. [WidgetRolloverScheduler.sync] cancels only if
+     * no month widget is left either.
+     */
+    override fun onDisabled(context: Context) {
+        super.onDisabled(context)
+        WidgetRolloverScheduler.sync(context)
+    }
+
+    /**
+     * Self-heal on the system's own `updatePeriodMillis` wake-up — see
+     * [de.jeanlucmakiola.calendula.widget.month.MonthWidgetReceiver.onUpdate].
+     */
+    override fun onUpdate(
+        context: Context,
+        appWidgetManager: AppWidgetManager,
+        appWidgetIds: IntArray,
+    ) {
+        super.onUpdate(context, appWidgetManager, appWidgetIds)
+        WidgetRolloverScheduler.sync(context)
+    }
 }

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.widget.month
 
+import de.jeanlucmakiola.calendula.widget.glanceDeclinedDecoration
 import android.content.Context
 import android.content.res.Configuration
 import androidx.compose.runtime.Composable
@@ -25,7 +26,6 @@ import androidx.glance.appwidget.action.actionStartActivity
 import androidx.glance.appwidget.cornerRadius
 import androidx.glance.appwidget.provideContent
 import androidx.glance.appwidget.state.updateAppWidgetState
-import androidx.glance.appwidget.updateAll
 import androidx.glance.background
 import androidx.glance.currentState
 import androidx.glance.layout.Alignment
@@ -33,6 +33,7 @@ import androidx.glance.layout.Box
 import androidx.glance.layout.Column
 import androidx.glance.layout.Row
 import androidx.glance.layout.Spacer
+import androidx.glance.layout.fillMaxHeight
 import androidx.glance.layout.fillMaxSize
 import androidx.glance.layout.fillMaxWidth
 import androidx.glance.layout.height
@@ -97,10 +98,27 @@ private fun yearMonthOf(index: Int): YearMonth =
  * inter-cell seam, with rounded end caps. The displayed month lives in Glance
  * state and is read reactively in the composition ([currentState]) so the arrows
  * move it via plain recomposition, not a (here-unreliable) widget session reload.
+ *
+ * Everything here is written to keep the published `RemoteViews` small. A widget
+ * update reaches the launcher as a *oneway* binder call, and the host's async
+ * buffer is 1 MB for all of it; overrun throws `TransactionTooLargeException` and
+ * the system drops the whole host, freezing every widget on the home screen until
+ * the launcher rebinds. [SizeMode.Exact] serialises the grid once per size the
+ * host reports, so the ceiling arrives at half the view count you would expect: a
+ * grid that emitted a view per cell blew past it after three taps (#214). Every
+ * row here emits only what it fills.
  */
 class MonthWidget : GlanceAppWidget() {
 
     override val stateDefinition = PreferencesGlanceStateDefinition
+
+    /**
+     * Exact rather than [SizeMode.Single] or [SizeMode.Responsive], both of which
+     * return early from `GlanceAppWidget.resize` — under those the grid is never
+     * recomposed for a new size and a resized widget clips instead of reflowing.
+     * Exact costs one serialised copy per host size, which is affordable now that
+     * a rendering is ~190 views rather than ~740.
+     */
     override val sizeMode = SizeMode.Exact
 
     override suspend fun provideGlance(context: Context, id: GlanceId) {
@@ -118,15 +136,35 @@ class MonthWidget : GlanceAppWidget() {
     }
 }
 
-/** Step the displayed month by the `delta` action parameter (±1). */
+/**
+ * Step the displayed month by the `delta` action parameter (±1).
+ *
+ * Redrawn through [GlanceAppWidget.update] with the id the callback was handed,
+ * never `updateAll`. `updateAll` resolves its targets through the provider-name
+ * -> app-widget-id map Glance persists for the *receiver*, and in a process that
+ * has done nothing else yet — the one a tap wakes after a reboot — that lookup
+ * comes back empty and the redraw is dropped: the state write lands, nothing
+ * recomposes, and the arrows read as dead until something else opens the app and
+ * starts a session (#18). The tapped widget's own id needs no lookup.
+ */
 class ShiftMonthAction : ActionCallback {
     override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
         val delta = parameters[deltaKey] ?: 0
         updateAppWidgetState(context, glanceId) { prefs ->
             val cur = prefs[MONTH_INDEX_KEY] ?: currentMonthIndex(systemZone())
-            prefs[MONTH_INDEX_KEY] = cur + delta
+            val next = cur + delta
+            // Landing back on the current month clears the key, so the widget
+            // goes back to *following* the date rather than being pinned to
+            // whichever month was current at the tap. Paging out and back is the
+            // workaround #228's reporter used, and pinning it there would have
+            // stuck them on that month once it stopped being the current one.
+            if (next == currentMonthIndex(systemZone())) {
+                prefs.remove(MONTH_INDEX_KEY)
+            } else {
+                prefs[MONTH_INDEX_KEY] = next
             }
-        MonthWidget().updateAll(context.applicationContext)
+        }
+        MonthWidget().update(context.applicationContext, glanceId)
     }
 
     companion object {
@@ -134,11 +172,11 @@ class ShiftMonthAction : ActionCallback {
     }
 }
 
-/** Jump the displayed month back to the current month. */
+/** Jump the displayed month back to the current month. See [ShiftMonthAction]. */
 class ResetMonthAction : ActionCallback {
     override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
         updateAppWidgetState(context, glanceId) { prefs -> prefs.remove(MONTH_INDEX_KEY) }
-        MonthWidget().updateAll(context.applicationContext)
+        MonthWidget().update(context.applicationContext, glanceId)
     }
 }
 
@@ -286,9 +324,31 @@ private fun WeekRow(
     colW: Dp,
     modifier: GlanceModifier,
 ) {
-    Column(modifier = modifier.fillMaxWidth()) {
-        // Day numbers.
-        Row(modifier = GlanceModifier.fillMaxWidth()) {
+    val context = LocalContext.current
+    val hidden = week.hiddenPerDay()
+    Box(modifier = modifier.fillMaxWidth()) {
+        // Day-open targets, one full-height strip per column, sitting *under* the
+        // content: a tap anywhere in a day still opens it, as in the app, without
+        // every cell in the column carrying a click target of its own. The content
+        // above is not clickable, so touches fall through to this layer; only an
+        // event bar opts out to open its own detail.
+        Row(modifier = GlanceModifier.fillMaxSize()) {
+            week.days.forEach { date ->
+                Box(
+                    modifier = GlanceModifier
+                        .width(colW)
+                        .fillMaxHeight()
+                        .clickable(openDayAction(context, date)),
+                ) {}
+            }
+        }
+        Column(modifier = GlanceModifier.fillMaxWidth()) {
+            // Day numbers. Fixed height so every week's number row lines up whether
+            // or not it holds today's larger pill.
+            Row(
+                modifier = GlanceModifier.fillMaxWidth().height(DAY_NUMBER_HEIGHT),
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
                 week.days.forEach { date ->
                     DayNumber(
                         date = date,
@@ -301,12 +361,36 @@ private fun WeekRow(
             Spacer(GlanceModifier.height(2.dp))
             // One lane row per event row. A multi-day span is a single Box spanning
             // its columns (colW * n) so it's connected with no seam and rounded ends.
-        repeat(MAX_LANES) { lane ->
+            // Lanes past the last one this week fills emit nothing at all.
+            repeat(week.usedLanes()) { lane ->
                 LaneRow(week = week, lane = lane, dark = dark, soften = soften, colW = colW)
                 Spacer(GlanceModifier.height(1.dp))
             }
-        OverflowRow(week = week, colW = colW)
+            if (hidden.any { it > 0 }) OverflowRow(hidden = hidden, colW = colW)
         }
+    }
+}
+
+/**
+ * How many lanes this week actually fills, counting from the top. The grid draws
+ * that many rows instead of a fixed [MAX_LANES]; an empty lane costs three views
+ * per day and most weeks leave the last two empty.
+ */
+private fun MonthWeek.usedLanes(): Int {
+    for (lane in MAX_LANES - 1 downTo 0) {
+        val filled = spans.any { it.lane == lane } ||
+            days.indices.any { col -> timedEventAt(this, lane, col, days[col]) != null }
+        if (filled) return lane + 1
+    }
+    return 0
+}
+
+/** Events per day that no lane had room for — the "+N" counts, 0 where all fit. */
+private fun MonthWeek.hiddenPerDay(): List<Int> = days.mapIndexed { col, date ->
+    val shownSpans = spans.count { col in it.startCol..it.endCol && it.lane < MAX_LANES }
+    val freeSlots = (MAX_LANES - shownSpans).coerceAtLeast(0)
+    val timedShown = minOf(freeSlots, timedByDay[date].orEmpty().size)
+    ((countByDay[date] ?: 0) - shownSpans - timedShown).coerceAtLeast(0)
 }
 
 /**
@@ -318,25 +402,14 @@ private fun WeekRow(
 private fun openDayAction(context: Context, date: LocalDate) =
     actionStartActivity(MainActivity.openDateIntent(context, date, CalendarView.Month))
 
+/**
+ * A day's number. Every day but today is a bare centred [Text] carrying the column
+ * width itself — a wrapping Box costs three views, and there are 42 of these.
+ * Today keeps its filled circle, which does need the Box.
+ */
 @Composable
 private fun DayNumber(date: LocalDate, isToday: Boolean, inMonth: Boolean, colW: Dp) {
-    val context = LocalContext.current
-    Box(
-        modifier = GlanceModifier
-            .width(colW)
-            .height(DAY_NUMBER_HEIGHT)
-            .clickable(openDayAction(context, date)),
-        contentAlignment = Alignment.Center,
-    ) {
-        Box(
-            modifier = GlanceModifier
-                .size(DAY_NUMBER_HEIGHT)
-                .then(if (isToday) GlanceModifier.cornerRadius(DAY_NUMBER_HEIGHT / 2).background(GlanceTheme.colors.primary) else GlanceModifier),
-            contentAlignment = Alignment.Center,
-        ) {
-            Text(
-                text = date.day.toString(),
-                style = TextStyle(
+    val style = TextStyle(
         color = when {
             isToday -> GlanceTheme.colors.onPrimary
             inMonth -> GlanceTheme.colors.onSurface
@@ -344,38 +417,78 @@ private fun DayNumber(date: LocalDate, isToday: Boolean, inMonth: Boolean, colW:
         },
         fontSize = 11.sp,
         fontWeight = if (isToday) FontWeight.Bold else FontWeight.Normal,
-                ),
+        textAlign = TextAlign.Center,
     )
+    if (!isToday) {
+        Text(text = date.day.toString(), style = style, modifier = GlanceModifier.width(colW))
+        return
+    }
+    Box(modifier = GlanceModifier.width(colW), contentAlignment = Alignment.Center) {
+        Box(
+            modifier = GlanceModifier
+                .size(DAY_NUMBER_HEIGHT)
+                .cornerRadius(DAY_NUMBER_HEIGHT / 2)
+                .background(GlanceTheme.colors.primary),
+            contentAlignment = Alignment.Center,
+        ) {
+            Text(text = date.day.toString(), style = style)
         }
     }
 }
 
+/** A bar occupying [cols] columns, or — with a null event — that many blank ones. */
+private data class LaneCell(val event: EventInstance?, val cols: Int)
+
+/**
+ * A lane split into bars and the gaps between them, with consecutive blank columns
+ * merged into one gap: the week's day-open taps come from the strip underneath, so
+ * a gap needs no per-column view and a mostly-empty lane collapses to a spacer.
+ */
+private fun MonthWeek.laneCells(lane: Int): List<LaneCell> {
+    val cells = mutableListOf<LaneCell>()
+    var gap = 0
+    var col = 0
+    fun closeGap() {
+        if (gap > 0) cells += LaneCell(null, gap)
+        gap = 0
+    }
+    while (col < 7) {
+        val span = spans.firstOrNull { it.lane == lane && col in it.startCol..it.endCol }
+        val timed = if (span == null) timedEventAt(this, lane, col, days[col]) else null
+        when {
+            span != null -> {
+                closeGap()
+                cells += LaneCell(span.event, span.endCol - col + 1)
+                col = span.endCol + 1
+            }
+            timed != null -> {
+                closeGap()
+                cells += LaneCell(timed, 1)
+                col += 1
+            }
+            else -> {
+                gap += 1
+                col += 1
+            }
+        }
+    }
+    closeGap()
+    return cells
+}
+
 @Composable
 private fun LaneRow(week: MonthWeek, lane: Int, dark: Boolean, soften: Boolean, colW: Dp) {
-    val context = LocalContext.current
     Row(modifier = GlanceModifier.fillMaxWidth()) {
-        var col = 0
-        while (col < 7) {
-            val span = week.spans.firstOrNull { it.lane == lane && col in it.startCol..it.endCol }
-            if (span != null) {
-                val cols = span.endCol - col + 1
-                SpanBar(event = span.event, dark = dark, soften = soften, width = colW * cols)
-                col = span.endCol + 1
+        week.laneCells(lane).forEach { cell ->
+            if (cell.event == null) {
+                Spacer(GlanceModifier.width(colW * cell.cols).height(LANE_HEIGHT))
             } else {
-                val timed = timedEventAt(week, lane, col, week.days[col])
-                if (timed != null) {
-                    SpanBar(event = timed, dark = dark, soften = soften, width = colW)
-                } else {
-                    // Empty lane cell: a tap opens that day, so blank space in a
-                    // day column is a day-open target just like the number is.
-                    Box(
-                        GlanceModifier
-                            .width(colW)
-                            .height(LANE_HEIGHT)
-                            .clickable(openDayAction(context, week.days[col])),
-                    ) {}
-                }
-                col += 1
+                SpanBar(
+                    event = cell.event,
+                    dark = dark,
+                    soften = soften,
+                    width = colW * cell.cols,
+                )
             }
         }
     }
@@ -414,41 +527,39 @@ private fun SpanBar(event: EventInstance, dark: Boolean, soften: Boolean, width:
             Text(
                 text = event.title.ifBlank { context.getString(R.string.event_untitled) },
                 maxLines = 1,
-                style = TextStyle(color = ColorProvider(eventInk(fill)), fontSize = 9.sp),
+                style = TextStyle(
+                    color = ColorProvider(eventInk(fill)),
+                    fontSize = 9.sp,
+                    textDecoration = glanceDeclinedDecoration(event.isDeclined),
+                ),
                 modifier = GlanceModifier.padding(horizontal = 3.dp),
             )
         }
     }
 }
 
+/** The "+N" row, drawn only for weeks that hide something, gaps merged as in a lane. */
 @Composable
-private fun OverflowRow(week: MonthWeek, colW: Dp) {
-    val context = LocalContext.current
+private fun OverflowRow(hidden: List<Int>, colW: Dp) {
     Row(modifier = GlanceModifier.fillMaxWidth()) {
-        week.days.forEachIndexed { col, date ->
-            val shownSpans = week.spans.count { col in it.startCol..it.endCol && it.lane < MAX_LANES }
-            val freeSlots = (MAX_LANES - shownSpans).coerceAtLeast(0)
-            val timedShown = minOf(freeSlots, week.timedByDay[date].orEmpty().size)
-            val hidden = (week.countByDay[date] ?: 0) - shownSpans - timedShown
-            // The overflow row is part of the day column too: tapping it (whether
-            // it shows "+N" or is blank) opens that day, same as the app.
-            Box(
-                modifier = GlanceModifier
-                    .width(colW)
-                    .height(LANE_HEIGHT)
-                    .clickable(openDayAction(context, date)),
-                contentAlignment = Alignment.CenterStart,
-            ) {
-                if (hidden > 0) {
+        var gap = 0
+        hidden.forEach { count ->
+            if (count == 0) {
+                gap += 1
+                return@forEach
+            }
+            if (gap > 0) {
+                Spacer(GlanceModifier.width(colW * gap).height(LANE_HEIGHT))
+                gap = 0
+            }
             Text(
-                        text = "+$hidden",
+                text = "+$count",
                 maxLines = 1,
                 style = TextStyle(color = GlanceTheme.colors.onSurfaceVariant, fontSize = 9.sp),
-                        modifier = GlanceModifier.padding(start = 3.dp),
+                modifier = GlanceModifier.width(colW).padding(start = 3.dp),
             )
         }
-            }
-        }
+        if (gap > 0) Spacer(GlanceModifier.width(colW * gap).height(LANE_HEIGHT))
     }
 }
 

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

@@ -1,7 +1,10 @@
 package de.jeanlucmakiola.calendula.widget.month
 
+import android.appwidget.AppWidgetManager
+import android.content.Context
 import androidx.glance.appwidget.GlanceAppWidget
 import androidx.glance.appwidget.GlanceAppWidgetReceiver
+import de.jeanlucmakiola.calendula.widget.WidgetRolloverScheduler
 
 /**
  * Host-facing receiver for the month widget. Declared in the manifest with the
@@ -9,4 +12,35 @@ import androidx.glance.appwidget.GlanceAppWidgetReceiver
  */
 class MonthWidgetReceiver : GlanceAppWidgetReceiver() {
     override val glanceAppWidget: GlanceAppWidget = MonthWidget()
+
+    /** First month widget placed — start rolling "today" over at midnight (#228). */
+    override fun onEnabled(context: Context) {
+        super.onEnabled(context)
+        WidgetRolloverScheduler.sync(context)
+    }
+
+    /**
+     * Last month widget removed. [WidgetRolloverScheduler.sync] cancels only if
+     * no agenda widget is left either.
+     */
+    override fun onDisabled(context: Context) {
+        super.onDisabled(context)
+        WidgetRolloverScheduler.sync(context)
+    }
+
+    /**
+     * The `updatePeriodMillis` backstop is the one wake-up the *system* still
+     * owns, so it doubles as the alarm's self-heal: anything that drops a
+     * pending alarm without a broadcast (force-stop, battery restriction, an OEM
+     * freeze) is repaired here rather than on the next app open. Re-arming
+     * closer to midnight also narrows the inexact delivery window.
+     */
+    override fun onUpdate(
+        context: Context,
+        appWidgetManager: AppWidgetManager,
+        appWidgetIds: IntArray,
+    ) {
+        super.onUpdate(context, appWidgetManager, appWidgetIds)
+        WidgetRolloverScheduler.sync(context)
+    }
 }