release: cut v2.4.0 — per-event colors

Optional per-event color in the event form. The read/render path already
resolved EVENT_COLOR with a calendar fallback; this adds the write side and
the picker.

- Palette-backed calendars (Google, some CalDAV) pick from the account's
  Colors (TYPE_EVENT) and write EVENT_COLOR_KEY, so the color round-trips
  through sync; local calendars write a raw EVENT_COLOR from the shared
  CALENDAR_COLOR_PALETTE. Never writes a raw color to a palette calendar.
- Swatch row + palette extracted to ui/common/ColorSwatchRow.kt (shared with
  the calendar editor). Switching calendars resets the choice (keys are
  account-scoped); a "Reset" action returns to the calendar color.
- New "Allow colors on unsupported calendars" setting (off by default)
  extends the raw path to no-palette synced calendars, with an honest
  "may not survive sync" warning on the picker and in Settings.
- Color flows through insert / dirty-checked update / occurrence-exception;
  mapper, form, and repository tests added.

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

.gitea/workflows/ci.yaml

@@ -6,7 +6,11 @@ on:
       - '**'
     tags-ignore:
       - '**'
-  pull_request:
+
+# Cancel superseded runs on the same branch.
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
 
 jobs:
   ci:
@@ -26,30 +30,25 @@ jobs:
 
       - name: Setup Android SDK
         uses: android-actions/setup-android@v3
+        with:
+          # Default ("tools platform-tools") drags in the Android Emulator
+          # (~300 MB) which the build never uses.
+          packages: ''
+
+      - name: Setup Android SDK cache
+        uses: actions/cache@v4
+        with:
+          path: /opt/android-sdk
+          key: ${{ runner.os }}-android-sdk-37-36.0.0
 
       - name: Install Android SDK packages
         run: |
           yes | sdkmanager --licenses >/dev/null || true
           sdkmanager \
             "platform-tools" \
-            "platforms;android-36" \
             "platforms;android-37.0" \
             "build-tools;36.0.0"
 
-      - name: Install jq
-        run: |
-          set -e
-          SUDO=""
-          if command -v sudo >/dev/null 2>&1; then
-            SUDO="sudo"
-          fi
-          if command -v apt-get >/dev/null 2>&1; then
-            $SUDO apt-get update
-            $SUDO apt-get install -y jq
-          elif command -v apk >/dev/null 2>&1; then
-            $SUDO apk add --no-cache jq
-          fi
-
       - name: Setup Gradle cache
         uses: actions/cache@v4
         with:
@@ -63,16 +62,19 @@ jobs:
       - name: Grant execute permission for gradlew
         run: chmod +x ./gradlew
 
+      # No --no-daemon: the daemon lives only as long as this job container
+      # and lets the following steps skip JVM startup + reconfiguration.
       - name: Lint (debug variant only)
-        run: ./gradlew lintDebug --no-daemon
+        run: ./gradlew lintDebug
 
       - name: Unit tests
-        run: ./gradlew testDebugUnitTest --no-daemon
+        run: ./gradlew testDebugUnitTest
 
       - name: Assemble debug APK
-        run: ./gradlew assembleDebug --no-daemon
+        run: ./gradlew assembleDebug
 
       - name: Trivy filesystem scan
+        if: github.ref == 'refs/heads/main'
         run: |
           set -e
           SUDO=""

.gitea/workflows/release.yaml

@@ -1,4 +1,4 @@
-name: Build and Release to F-Droid
+name: Release — F-Droid repo + Gitea release
 
 on:
   push:
@@ -24,16 +24,33 @@ jobs:
 
       - name: Setup Android SDK
         uses: android-actions/setup-android@v3
+        with:
+          packages: ''
+
+      - name: Setup Android SDK cache
+        uses: actions/cache@v4
+        with:
+          path: /opt/android-sdk
+          key: ${{ runner.os }}-android-sdk-37-36.0.0
 
       - name: Install Android SDK packages
         run: |
           yes | sdkmanager --licenses >/dev/null || true
           sdkmanager \
             "platform-tools" \
-            "platforms;android-36" \
             "platforms;android-37.0" \
             "build-tools;36.0.0"
 
+      - name: Setup Gradle cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties', 'gradle/libs.versions.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
       - name: Grant execute permission for gradlew
         run: chmod +x ./gradlew
 
@@ -42,10 +59,10 @@ jobs:
       # any tag-resolved drift (e.g. version code substitution issues).
 
       - name: Unit tests
-        run: ./gradlew testDebugUnitTest --no-daemon
+        run: ./gradlew testDebugUnitTest
 
       - name: Assemble debug APK (sanity)
-        run: ./gradlew assembleDebug --no-daemon
+        run: ./gradlew assembleDebug
 
   build-and-deploy:
     needs: ci
@@ -65,16 +82,33 @@ jobs:
 
       - name: Setup Android SDK
         uses: android-actions/setup-android@v3
+        with:
+          packages: ''
+
+      - name: Setup Android SDK cache
+        uses: actions/cache@v4
+        with:
+          path: /opt/android-sdk
+          key: ${{ runner.os }}-android-sdk-37-36.0.0
 
       - name: Install Android SDK packages
         run: |
           yes | sdkmanager --licenses >/dev/null || true
           sdkmanager \
             "platform-tools" \
-            "platforms;android-36" \
             "platforms;android-37.0" \
             "build-tools;36.0.0"
 
+      - name: Setup Gradle cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties', 'gradle/libs.versions.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
       - name: Install jq
         run: |
           set -e
@@ -87,7 +121,12 @@ jobs:
             $SUDO apk add --no-cache jq
           fi
 
+      # Tag-only build steps. On a manual workflow_dispatch (ref = a branch,
+      # not a tag) these are skipped: the job then just re-signs the existing
+      # index with the configured repo key and re-uploads — used for key
+      # rotation / repo recovery without publishing a new APK.
       - name: Set version from git tag
+        if: startsWith(github.ref, 'refs/tags/')
         run: |
           set -e
           RAW_TAG="${GITHUB_REF_NAME:-${GITHUB_REF##*/}}"
@@ -101,8 +140,12 @@ jobs:
           sed -i "s/versionName = \".*\"/versionName = \"$VERSION\"/" app/build.gradle.kts
           sed -i "s/versionCode = .*/versionCode = $VERSION_CODE/" app/build.gradle.kts
           grep -E 'versionName|versionCode' app/build.gradle.kts
+          # Export for later steps (F-Droid changelog, mapping asset name).
+          echo "VERSION=$VERSION" >> "$GITHUB_ENV"
+          echo "VERSION_CODE=$VERSION_CODE" >> "$GITHUB_ENV"
 
       - name: Setup Android Keystore
+        if: startsWith(github.ref, 'refs/tags/')
         env:
           KEYSTORE_BASE64: ${{ secrets.KEYSTORE_BASE64 }}
           KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
@@ -121,7 +164,8 @@ jobs:
         run: chmod +x ./gradlew
 
       - name: Build release APK
-        run: ./gradlew assembleRelease --no-daemon
+        if: startsWith(github.ref, 'refs/tags/')
+        run: ./gradlew assembleRelease
 
       - name: Setup F-Droid Server Tools
         run: |
@@ -131,29 +175,48 @@ jobs:
           $SUDO apt-get install -y sshpass python3-pip
           pip3 install --break-system-packages --upgrade fdroidserver
 
-      - name: Initialize or fetch F-Droid Repository
+      - name: Fetch existing F-Droid repo from Hetzner
         env:
           HOST: ${{ secrets.HETZNER_HOST }}
           USER: ${{ secrets.HETZNER_USER }}
           PASS: ${{ secrets.HETZNER_PASS }}
         run: |
+          set -euo pipefail
+          SSH_OPTS="-o StrictHostKeyChecking=no -o ConnectTimeout=20"
           mkdir -p fdroid
-          sshpass -p "$PASS" sftp -o StrictHostKeyChecking=no "$USER@$HOST" <<'SFTP'
-          -mkdir dev
-          -mkdir dev/fdroid
-          -mkdir dev/fdroid/repo
-          SFTP
-          sshpass -p "$PASS" scp -o StrictHostKeyChecking=no -r "$USER@$HOST:dev/fdroid/." fdroid/ || (cd fdroid && fdroid init)
+          # Pull only the published repo/ (all apps' APKs), any per-app
+          # metadata, and the repo icon — enough to rebuild the index without
+          # dropping the other apps. The signing key is deliberately NOT pulled
+          # from the box; it comes from CI secrets in the next step so it never
+          # has to live in the web-served tree.
+          sshpass -p "$PASS" scp $SSH_OPTS -r "$USER@$HOST:dev/fdroid/repo" fdroid/ 2>/dev/null || true
+          sshpass -p "$PASS" scp $SSH_OPTS -r "$USER@$HOST:dev/fdroid/metadata" fdroid/ 2>/dev/null || true
+          sshpass -p "$PASS" scp $SSH_OPTS "$USER@$HOST:dev/fdroid/icon.png" fdroid/ 2>/dev/null || true
+          mkdir -p fdroid/repo fdroid/metadata
 
-      - name: Ensure F-Droid repo signing key and icon
+      - name: Restore F-Droid signing key and config from secrets
+        env:
+          FDROID_KEYSTORE_BASE64: ${{ secrets.FDROID_KEYSTORE_BASE64 }}
+          FDROID_CONFIG_BASE64: ${{ secrets.FDROID_CONFIG_BASE64 }}
         run: |
-          cd fdroid
-          mkdir -p repo/icons
-          if [ ! -f keystore.p12 ]; then
-            fdroid update --create-key
+          set -euo pipefail
+          # Fail loudly if the repo key is not configured. NEVER auto-generate
+          # one: a fresh key changes the repo fingerprint and breaks every
+          # user's pinned repo. (Replaces the old `fdroid update --create-key`
+          # path, which silently rotated the key on a wiped server.)
+          if [ -z "${FDROID_KEYSTORE_BASE64:-}" ] || [ -z "${FDROID_CONFIG_BASE64:-}" ]; then
+            echo "ERROR: FDROID_KEYSTORE_BASE64 / FDROID_CONFIG_BASE64 secrets are not set." >&2
+            echo "Refusing to continue — will not auto-generate a new repo key." >&2
+            exit 1
           fi
+          echo "$FDROID_KEYSTORE_BASE64" | base64 --decode > fdroid/keystore.p12
+          echo "$FDROID_CONFIG_BASE64"   | base64 --decode > fdroid/config.yml
+          test -s fdroid/keystore.p12
+          test -s fdroid/config.yml
+          mkdir -p fdroid/repo/icons
 
       - name: Copy new APK to repo
+        if: startsWith(github.ref, 'refs/tags/')
         run: |
           set -e
           mkdir -p fdroid/repo
@@ -169,12 +232,33 @@ jobs:
           mkdir -p fdroid/metadata
           cp -r fdroid-metadata/* fdroid/metadata/
 
+      # Per-version "What's New" for F-Droid clients: the tag's CHANGELOG
+      # section written to changelogs/<versionCode>.txt (same extraction as the
+      # Gitea release notes). en-US only — F-Droid falls back to it for locales
+      # without their own changelog. fdroid update bakes this into the index.
+      - name: Generate F-Droid changelog for this version
+        if: startsWith(github.ref, 'refs/tags/')
+        run: |
+          set -e
+          awk -v ver="$VERSION" '
+            $0 ~ "^## \\[" ver "\\]" { flag = 1; next }
+            /^## \[/ { flag = 0 }
+            flag' CHANGELOG.md > /tmp/changelog.txt
+          sed -i -e '/./,$!d' /tmp/changelog.txt
+          if [ ! -s /tmp/changelog.txt ]; then
+            echo "See CHANGELOG.md for $VERSION." > /tmp/changelog.txt
+          fi
+          CL_DIR="fdroid/metadata/de.jeanlucmakiola.calendula/en-US/changelogs"
+          mkdir -p "$CL_DIR"
+          cp /tmp/changelog.txt "$CL_DIR/${VERSION_CODE}.txt"
+          echo "Wrote $CL_DIR/${VERSION_CODE}.txt"
+
       - name: Generate F-Droid Index
         run: |
           cd fdroid
           fdroid update -c
 
-      - name: Upload Repo to Hetzner
+      - name: Upload repo/ to Hetzner
         env:
           HOST: ${{ secrets.HETZNER_HOST }}
           USER: ${{ secrets.HETZNER_USER }}
@@ -185,6 +269,113 @@ jobs:
           sshpass -p "$PASS" sftp $SSH_OPTS "$USER@$HOST" <<'SFTP'
           -mkdir dev
           -mkdir dev/fdroid
-          -mkdir dev/fdroid/repo
           SFTP
-          sshpass -p "$PASS" scp $SSH_OPTS -r fdroid/. "$USER@$HOST:dev/fdroid/"
+          # Publish the signed repo/ plus metadata/ (descriptions, screenshots,
+          # per-version changelogs) so changelog history survives across
+          # releases. keystore.p12 and config.yml are NEVER uploaded, so they
+          # can't re-enter the web-served tree; nginx serves only repo/ anyway.
+          sshpass -p "$PASS" scp $SSH_OPTS -r fdroid/repo fdroid/metadata "$USER@$HOST:dev/fdroid/"
+
+      # Archive the R8 mapping so user crash stacktraces stay deobfuscatable.
+      # Attached to the Gitea release (it's not an APK, so it fits the
+      # no-binaries rule). Best-effort: never fail a release over it.
+      - name: Attach R8 mapping to Gitea release
+        if: startsWith(github.ref, 'refs/tags/')
+        continue-on-error: true
+        env:
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
+        run: |
+          set -e
+          MAP="app/build/outputs/mapping/release/mapping.txt"
+          if [ ! -f "$MAP" ]; then echo "No mapping.txt (R8 off?) — skipping."; exit 0; fi
+          TAG="${GITHUB_REF_NAME:-${GITHUB_REF##*/}}"
+          ASSET="mapping-${VERSION:-$TAG}.txt.gz"
+          gzip -c "$MAP" > "/tmp/$ASSET"
+          # The release is created by the gitea-release job; ensure it exists
+          # (idempotent) so this job doesn't race it to a 404.
+          ID=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/tags/$TAG" | jq -r '.id // empty')
+          if [ -z "$ID" ]; then
+            ID=$(curl -s -X POST -H "Authorization: token $TOKEN" \
+              -H "Content-Type: application/json" \
+              -d "{\"tag_name\":\"$TAG\",\"name\":\"$TAG\"}" \
+              "$API/releases" | jq -r '.id // empty')
+          fi
+          if [ -z "$ID" ]; then echo "Could not resolve release id — skipping."; exit 0; fi
+          # Replace any prior asset of the same name (re-run safe).
+          OLD=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/$ID/assets" \
+            | jq -r --arg n "$ASSET" '.[] | select(.name==$n) | .id')
+          [ -n "$OLD" ] && curl -s -X DELETE -H "Authorization: token $TOKEN" "$API/releases/$ID/assets/$OLD" >/dev/null || true
+          curl -s -X POST -H "Authorization: token $TOKEN" \
+            -F "attachment=@/tmp/$ASSET" \
+            "$API/releases/$ID/assets?name=$ASSET" -o /dev/null -w "asset upload HTTP %{http_code}\n"
+
+  # A Gitea release per tag, carrying the tag's CHANGELOG section as its
+  # notes. Deliberately no APK assets — distribution stays with the F-Droid
+  # repo; the release is the human-readable record. Gated on the tests-only
+  # ci job (not the deploy) so notes appear even if the F-Droid upload has
+  # an infrastructure hiccup.
+  gitea-release:
+    needs: ci
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: docker
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Extract changelog section for this tag
+        run: |
+          set -e
+          TAG="${GITHUB_REF_NAME:-${GITHUB_REF##*/}}"
+          VERSION="${TAG#v}"
+          # Everything between "## [<version>]" and the next "## [" heading.
+          awk -v ver="$VERSION" '
+            $0 ~ "^## \\[" ver "\\]" { flag = 1; next }
+            /^## \[/ { flag = 0 }
+            flag' CHANGELOG.md > release-notes.md
+          # Trim leading blank lines.
+          sed -i -e '/./,$!d' release-notes.md
+          if [ ! -s release-notes.md ]; then
+            echo "_No changelog entry for ${VERSION} — see CHANGELOG.md._" > release-notes.md
+          fi
+          echo "--- release notes ---"
+          cat release-notes.md
+
+      - name: Create Gitea release
+        env:
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
+        run: |
+          set -e
+          TAG="${GITHUB_REF_NAME:-${GITHUB_REF##*/}}"
+          python3 - "$TAG" <<'PY' > payload.json
+          import json, sys
+          print(json.dumps({
+              "tag_name": sys.argv[1],
+              "name": sys.argv[1],
+              "body": open("release-notes.md").read(),
+              "draft": False,
+              "prerelease": False,
+          }))
+          PY
+          # Upsert: the build-and-deploy job may have created a bare release
+          # first (to attach the mapping asset), so PATCH the notes if it
+          # exists, otherwise POST a new one. Both paths are re-run safe.
+          curl -s -H "Authorization: token $TOKEN" "$API/releases/tags/$TAG" > existing.json
+          ID=$(python3 -c "import json,sys; d=json.load(open('existing.json')); print(d.get('id',''))" 2>/dev/null || true)
+          if [ -n "$ID" ]; then
+            CODE=$(curl -s -o response.json -w '%{http_code}' -X PATCH \
+              -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
+              -d @payload.json "$API/releases/$ID")
+            OK=200
+          else
+            CODE=$(curl -s -o response.json -w '%{http_code}' -X POST \
+              -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
+              -d @payload.json "$API/releases")
+            OK=201
+          fi
+          cat response.json
+          if [ "$CODE" != "$OK" ]; then
+            echo "Release upsert failed with HTTP $CODE (expected $OK)"
+            exit 1
+          fi

.gitignore

@@ -40,6 +40,7 @@ captures/
 # Keystore files
 *.jks
 *.keystore
+*.p12
 /key.properties
 
 # Google Services (e.g. APIs or Firebase)
@@ -50,8 +51,7 @@ google-services.json
 Thumbs.db
 
 # F-Droid local artifacts (the pipeline generates them in CI)
-fdroid/repo/
-fdroid/keystore.p12
+/fdroid/
 
 # KSP
 .ksp/

.planning/PROJECT.md

@@ -2,11 +2,12 @@
 
 ## What This Is
 
-A modern Material 3 Expressive Android calendar app, read-only V1. Lives
-entirely on top of Android's `CalendarContract` — any calendar synced to the
-device (CalDAV via DAVx5, Google, local, WebCal, …) shows up automatically.
-The differentiator is visual: real Material 3 Expressive design that no
-existing FOSS calendar app delivers.
+A modern Material 3 Expressive Android calendar app. Lives entirely on top
+of Android's `CalendarContract` — any calendar synced to the device (CalDAV
+via DAVx5, Google, local, WebCal, …) shows up automatically; creating,
+editing, and deleting writes straight back, and reminders are delivered by
+the app itself (Etar model). The differentiator is visual: real Material 3
+Expressive design that no existing FOSS calendar app delivers.
 
 ## Core Value
 
@@ -15,8 +16,10 @@ re-inventing the calendar sync stack — leave that to DAVx5 and the system.
 
 ## Current Milestone
 
-**v0.1 — Foundation & CI:** Buildable Android project scaffold with theme,
-icon, i18n, Hilt, DataStore, green CI.
+Milestones 1 (read, v1.0) and 2 (write support, v1.1–v2.0.0 incl. reminder
+delivery) are **complete** — v2.0.0 shipped 2026-06-11. Next is v3.0
+(power-user features) plus an undecided "Locations & People" idea backlog;
+see `ROADMAP.md`.
 
 ## Stack
 
@@ -26,9 +29,8 @@ Expressive 1.5.0-alpha21 (alpha is intentional — Expressive APIs only
 live in the 1.5 alpha line). Hilt 2.59.2, DataStore. Gradle Kotlin DSL
 with Version Catalog. AGP 9.1.1, Gradle 9.5.1. JVM target 17.
 
-Read-only V1, write support V2.
-
-Android-only (minSdk 29, targetSdk 36). No iOS.
+Android-only (minSdk 29, targetSdk 36). No iOS. No `INTERNET` permission —
+any feature that would need one is an explicit product decision first.
 
 ## Naming
 

.planning/REQUIREMENTS.md

@@ -2,36 +2,43 @@
 
 See full design spec: `docs/superpowers/specs/2026-06-08-calendar-app-design.md`
 
-## V1 Scope (Variant "B")
+## V1 Scope (Variant "B") — shipped in full (v1.0.0, 2026-06-11)
 
-### Validated (shipped)
-- Foundation & CI infrastructure — v0.1.0 (2026-06-08)
-
-### Active (V1)
-
-- [x] Foundation & CI infrastructure
+- [x] Foundation & CI infrastructure — v0.1.0 (2026-06-08)
 - [x] Data Layer over `CalendarContract`
 - [x] Permission flow (`READ_CALENDAR`)
-- [ ] Month view (S1)
-- [ ] Week view (S2)
-- [ ] Day view (S3)
-- [ ] Event Detail Sheet (S4)
-- [ ] Multi-Calendar Filter (M3)
+- [x] Month view (S1)
+- [x] Week view (S2)
+- [x] Day view (S3)
+- [x] Event Detail Sheet (S4) — became a full screen, plus full event read (v0.6)
+- [x] Multi-Calendar Filter (M3)
 - [x] Today button (M2) — shipped v0.5; Jump-to-Date **cut from scope**
-- [ ] View-Switcher (M1)
-- [ ] Settings screen (M4)
-- [ ] Empty / no-permission / no-calendars states
-- [ ] German + English localization
-- [ ] Loading/Failure/Success states per screen (architectural pattern)
+- [x] View-Switcher (M1)
+- [x] Settings screen (M4)
+- [x] Empty / no-permission / no-calendars states
+- [x] German + English localization
+- [x] Loading/Failure/Success states per screen (architectural pattern)
 
-### Out of Scope (V2+)
+## V2 Scope — write support, shipped in full (v2.0.0, 2026-06-11)
+
+- [x] Write foundation: `WRITE_CALENDAR`, read-only-calendar detection, delete (v1.1)
+- [x] Create event: form, FAB, last-used calendar (v1.2; polish v1.2.1)
+- [x] Edit event: shared form, scoped recurring writes, recurrence picker (v1.3)
+- [x] Reminder notifications (v1.4) — **reversal of the original
+  "system handles reminders" assumption:** Calendula targets
+  sole-calendar-app users, so it posts reminder notifications itself
+  (Etar model), incl. `POST_NOTIFICATIONS` onboarding
+- [x] Conflict dialog on save + store polish (v2.0)
+- Quick-add — **cut from scope** (the prefilled form covers it)
+- Calendar switching while editing — moved to v3 backlog
+
+### Out of Scope (V3+)
 
-- Event create / edit / delete (V2)
 - Home-screen widget
 - Full-text search
-- Quick-add
-- Custom notifications/reminders (system already handles these)
 - Tablet/foldable-specific layouts
+- Locations & People ideas (contact picker, OSM autocomplete) — see
+  `ROADMAP.md` idea backlog, undecided
 - iOS support (Android-only by design)
 
 ## Constraints

.planning/ROADMAP.md

@@ -53,17 +53,286 @@ after v0.6 (full event read) plus the onboarding-screen polish pass.
 - ~~Redesign the initial grant-access (permission) screen~~ — **done**
   (Material 3 Expressive onboarding, shipped in v0.6.0 / v1.0.0)
 
-## v2.0 — Write Support
+## v2.0 — Write Support (complete, shipped 2026-06-11)
 
-- Event create / edit / delete via `CalendarContract` writes
-- Quick-add sheet
-- Conflict UX (event modified externally during edit)
+Delivered in four releasable slices (plan:
+`docs/superpowers/plans/2026-06-11-03-write-support.md`). The V1 spec is a
+guide here, not a contract — scope per slice is decided as we go.
 
-## v3.0 — Power-User Features
+| Version | Milestone | Status |
+|---|---|---|
+| v1.1 | Write foundation — `WRITE_CALENDAR`, read-only-calendar detection, delete (series + single occurrence) | complete (shipped 2026-06-11) |
+| v1.2 | Create event — form, FAB, last-used-calendar preselect | complete (shipped 2026-06-11) |
+| v1.2.1 | Form polish after on-device review — card design system, optional fields + settings defaults, OptionCard dialogs, expressive motion | complete (shipped 2026-06-11) |
+| v1.3 | Edit event — shared form, scoped recurring writes (this / following / all), recurrence picker | complete (shipped 2026-06-11) |
+| v1.4 | Reminder notifications — see below | complete (shipped 2026-06-11) |
+| v2.0 | Conflict dialog, polish pass (store copy refresh, F-Droid screenshots), release | complete (shipped 2026-06-11) |
 
-- Home-screen widget
-- Full-text search
-- Tablet / foldable layouts
-- Optional: ICS file import (drag-and-drop)
+v2.0 scope was re-cut on 2026-06-11, after v1.4:
+- **Occurrence edit** already shipped early, in v1.3.
+- **Quick-add** is **cut from scope**: the full form already opens prefilled
+  (visible day, last-used calendar, optional fields hidden), so the sheet
+  would only save one screen transition while adding a second create-surface
+  to maintain. Revisit only if real-world feedback says creation feels heavy.
+- **Calendar switching while editing** moves to the v3 backlog (sync-adapter
+  minefield: `CALENDAR_ID` is sync-adapter-owned, AOSP locks the field; an
+  honest implementation is copy+delete like Google Calendar, with sync-identity
+  and attendee side effects).
+- **Conflict dialog** stays (plan 03, decision 5): on save, compare against
+  the row as it was when the form loaded; on external change, ask
+  overwrite / discard. Closes the silent-clobber gap on synced calendars.
 
-Order is indicative — community feedback after V1 may re-prioritize.
+## v1.4 — Reminder Notifications
+
+**Essential**, not nice-to-have: Calendula targets users for whom it is their
+*only* calendar app, so reminder delivery can't be delegated to Google/OEM
+Calendar. The calendar provider schedules reminders and broadcasts
+`android.intent.action.EVENT_REMINDER`, but it does **not** post the visible
+notification — a calendar app must. We become that app (the Etar model).
+
+Scope:
+- Manifest-registered `BroadcastReceiver` for `EVENT_REMINDER`
+  (data scheme `content://com.android.calendar`) — wakes us at reminder time,
+  no foreground service.
+- Read `CalendarContract.CalendarAlerts` / `Reminders`, filter to
+  `METHOD_ALERT` / `METHOD_DEFAULT` (skip `METHOD_EMAIL`); post on a dedicated
+  notification channel; tap opens event detail.
+- `POST_NOTIFICATIONS` runtime permission (API 33+) — requested in onboarding.
+- Onboarding step: (a) request `POST_NOTIFICATIONS`, (b) in-app reminders
+  toggle, **default ON**, with copy warning that a second calendar app with
+  notifications on will cause duplicate reminders. Mirrored into Settings
+  (reversible).
+
+Deliberately deferred (add only if needed):
+- Snooze / dismiss notification actions (Etar has them)
+- Battery-optimization exemption prompt for delivery reliability
+
+## v2.1 — Month event grid + drawer view tabs (shipped 2026-06-15)
+
+- Month grid shows real events as continuous multi-day bars (not just dots)
+- View section in the navigation drawer to switch Month / Week / Day
+- Fix: text cursor no longer jumps in event text fields
+
+## v2.2 — Tap-to-create + local calendar management (shipped 2026-06-16)
+
+- Tap an empty slot in day/week → create form prefilled with that day + the
+  tapped hour (snapped to the hour, 1 h long)
+- Local (device-only) calendar management in a full-screen editor from
+  Settings → Calendars: create / rename / recolor / delete, with name,
+  pastel-previewed colour, and description (stored in `CAL_SYNC1`)
+- Synced calendars listed read-only, grouped by account, each with a
+  per-account "manage in source app" deep-link (resolved from the account's
+  authenticator — DAVx5/ICSx5/…) + an add-account shortcut
+- Shared `InlineTextField` extracted to `ui.common` (event form + calendar
+  editor share one input style)
+
+## v2.3 — Material 3 grouped-list redesign (shipped 2026-06-16)
+
+A structural + visual pass adopting one shared blueprint (modelled on the ReFra
+gallery app) across Settings, the calendar manager and the navigation drawer.
+
+- Shared `ui/common/GroupedList.kt`: `CollapsingScaffold` (a `LargeTopAppBar`
+  whose title collapses on scroll) + `GroupedRow` (Position-based corner
+  grouping, press-animated corners, `selected` + `minHeight` knobs).
+- Settings: category hub with About card on top and sliding sub-pages
+  (Appearance / New event form / Notifications); theme/week-start/language
+  pickers moved from `DropdownMenu` to OptionCard dialogs; token-based icon
+  chips; `ic_gitea.xml` for the About "Source" button.
+- Calendar manager + drawer restyled to match; shared `CalendarColorChip`;
+  drawer scrolls as one with the active view highlighted.
+- Cards use `surfaceContainerHigh` for readable contrast.
+- Donate button on the About card deferred (target TBD).
+
+---
+
+# Backlog (theme-based, post-v2.1)
+
+The old v3.0 / "daily-driver polish" / "Locations & People" lists are
+consolidated here by theme. Within a group, **(in progress)** /
+**(next)** mark what is being or about to be worked; everything else is an
+approved-but-unscheduled idea unless tagged **(idea)** /
+**(go/no-go)** / **(rejected)**. Order across groups is not a commitment.
+
+## Near-term sequence (ranked, 2026-06-16)
+
+The theme groups below are the full menu; this is the committed *order* for
+the next stretch. Ranking favours finishing the current create/edit + calendar
+arc before opening new fronts, then cheap-relative-to-value items and ones that
+unblock a later item. Order is a plan, not a contract — revisit after each lands.
+
+**Tier 1 — finish the current arc (create/edit + calendars)**
+1. Tap-to-create in day/week *(shipped v2.2.0)* — prefilled create from an empty slot
+2. Local calendar management + "manage in source app" deep-links *(shipped v2.2.0)*
+3. ~~Settings redesign & restructure~~ *(shipped v2.3.0 — grew into the full
+   grouped-list blueprint across Settings + calendars + drawer; see "v2.3"
+   above)*
+4. ~~Per-event color~~ *(shipped v2.4.0)* — palette calendars write
+   `EVENT_COLOR_KEY` (sync-safe); local/opted-in calendars write a raw
+   `EVENT_COLOR`; off-by-default setting for no-palette synced calendars
+5. **Duplicate event** *(next)* — detail action → prefilled create form; near-free on the tap-to-create prefill infra
+
+(Tier 2+ numbering below shifts accordingly; ranking unchanged.)
+
+### Settings redesign & restructure *(shipped v2.3.0)*
+
+The original scope below is kept as a record; the implementation expanded from a
+sub-screen restructure into the shared grouped-list blueprint (see "v2.3" above).
+
+The settings screen has grown into a flat vertical scroll of divider-separated
+sections (Appearance, Event form, Notifications, Calendars, Language, About) and
+will keep accreting rows (per-event-color defaults, default reminder, more
+calendar entries are all queued). It needs structure before it gets unwieldy.
+
+**Decided (2026-06-16): sub-screens**, not flat-but-carded. The top level
+becomes a category list; each category opens its own destination. More
+M3-idiomatic for a settings surface that will keep growing, and it mirrors the
+existing Calendars row, which already navigates out to its own screen.
+
+Structure — top-level settings list → category destinations:
+- **Appearance** → theme, dynamic colour, week start
+- **Event form** → the 6 default-field toggles + the hint text
+- **Notifications** → reminders toggle (POST_NOTIFICATIONS flow stays)
+- **Calendars** → already its own screen (`CalendarsScreen`); just becomes a
+  peer category row, no change to that screen
+- **Language** → single control; keep as a top-level row that opens an
+  OptionCard directly (a whole sub-screen for one choice is overkill)
+- **About** → kept inline on the top-level list as a card (read-only info,
+  not worth a navigation hop). Card layout, top → bottom:
+  - **Identity** — app logo + name "Calendula", with "by Jean-Luc Makiola"
+    as a subtitle beneath the name
+  - **Action buttons** (small, button-styled, sit in a row):
+    - **Source** — Gitea logo, opens the repo (`about_source_url`)
+    - **License** — opens the LICENSE file on Gitea
+    - **Donate** *(tentative)* — sits next to Source; target TBD (decide
+      before building: Liberapay / Ko-fi / Gitea sponsor / etc.)
+  - **Version** — small version number at the bottom of the card
+
+Scope:
+- **Navigation** — add the settings sub-screen destinations alongside the
+  existing settings/calendars routes in `CalendarHost`; back pops to the
+  settings list (mind the existing `BackHandler` that guards against falling
+  through to the activity).
+- **Fix the dialog-pattern violation** — theme, week-start and language use
+  `DropdownMenu`; the project default is the full-width tonal OptionCard modal
+  (radio/dropdown/text-list dialogs are banned, see
+  `option-card-modal-style-default`). Migrate these selectors to OptionCard.
+- **Visual pass** — top-level category rows with leading icons; consistent
+  spacing and row affordances aligned with the event-form card design system.
+
+Out of scope (no new settings *features* here) — this is a structure + style
+pass on the existing controls; new toggles ride in with their own features.
+
+**Tier 2 — navigation & daily-driver completeness**
+5. Jump-to-date — drawer date picker (un-cut from V1); cheap, fills the nav gap
+6. Agenda view — the missing 4th view; serves daily-driver users *and* becomes the data source for the widget
+
+**Tier 3 — platform reach (depends on Tier 2)**
+7. Home-screen widget — built on the agenda data source from #6
+8. App shortcuts (launcher long-press → New event); cheap, optional quick-settings tile
+
+**Tier 4 — interop & bigger-ticket**
+9. Share event as .ics + receive/open .ics into a prefilled create form
+10. Default reminder applied to new events; then snooze/dismiss notification actions
+11. Drag & drop rescheduling in day/week — big-ticket, own slice (recurring drops reuse the scope dialog)
+
+**Gated — explicit go/no-go before any work (mostly INTERNET-permission calls)**
+- Remote calendar create/edit (re-implements DAVx5; INTERNET + credential storage)
+- Locations & People — contact address picker (no-permission, one-shot) is the safe entry; OSM autocomplete needs INTERNET
+- Move event to another calendar — sync-adapter minefield (copy+delete model)
+
+**Unranked / fill-in** — pinch-to-zoom time scale, tablet/foldable layouts,
+full-text search, ICS file import. Pulled in opportunistically, not sequenced.
+
+Debatable calls worth a second look: widget (#7) vs .ics interop (#9) ordering;
+whether drag-drop (#11) jumps ahead given its daily-driver impact.
+
+## Navigation & views
+
+- ~~Tap an empty slot in day/week → create form prefilled with that
+  date+time, snapped to the hour~~ **shipped v2.2.0** (long-press variant
+  not added — single tap covers it)
+- Agenda view (fourth view: upcoming events grouped by day; also the
+  natural data source for a future widget)
+- Jump to date — drawer date picker (un-cut from V1)
+- Pinch-to-zoom time scale in day/week
+- Tablet / foldable layouts *(was v3.0)*
+- Full-text search *(was v3.0)*
+
+## Event editing & creation
+
+- Drag & drop rescheduling in day/week (recurring drops reuse the scope
+  dialog) — big-ticket, own slice
+- Duplicate event (detail action → prefilled create form)
+- **Per-event color** (`Events.EVENT_COLOR`, OptionCard picker in the form)
+  *(next)* — chosen to follow the in-progress tap-to-create + calendar
+  management work: reuses the color-picker component and palette plumbing
+  being built for local calendar management, and finishes the create/edit
+  theme. `EVENT_COLOR` / `EVENT_COLOR_KEY` from the calendar's color list
+  (`Colors` table, `TYPE_EVENT`); falls back to the calendar color when unset.
+
+## Calendars & accounts
+
+- ~~Create / manage local (device-only) calendars~~ **shipped v2.2.0** —
+  name + color + description; rename / recolor / delete the calendars the app
+  owns. Inserted under `ACCOUNT_TYPE_LOCAL` as a sync adapter; description in
+  `CAL_SYNC1`. Full-screen "Calendars" editor reached from Settings.
+- ~~Per-calendar "manage in source app" deep-link~~ **shipped v2.2.0** — for
+  synced calendars, open the app the calendar actually came from based on
+  its `ACCOUNT_TYPE` (DAVx5 `bitfire.at.davdroid`, Google `com.google`,
+  …); fall back to system account/sync settings. Plus an "add account"
+  entry into system Accounts. Honest boundary for remote calendars.
+- **Remote calendar create/edit** *(go/no-go)* — creating a CalDAV
+  collection (`MKCALENDAR`) or a Google calendar means an in-app sync
+  client: **INTERNET permission, credential storage, the full server
+  round-trip** — i.e. re-implementing DAVx5. DAVx5 exposes no public
+  intent to delegate the create to it. Cosmetic local edits (color/name)
+  to an existing synced row are possible but don't propagate to the server
+  and may be overwritten on next sync — not promised. Same explicit
+  go/no-go gate as the OSM/INTERNET item below.
+- Move event to another calendar (copy+delete model with a consequences
+  warning — deferred from v2.0; `CALENDAR_ID` is sync-adapter-owned) *(was v3.0)*
+
+## Reminders, round two
+
+- Snooze + dismiss actions on the notification (snooze needs an
+  exact-alarm / WorkManager decision)
+- Settings default reminder applied to new events
+
+## Sharing & interop
+
+- Share event as .ics + open/receive .ics into a prefilled create form
+  (front-runs the import below)
+- ICS file import (drag-and-drop) *(was v3.0, optional)*
+
+## Platform & launchers
+
+- Home-screen widget *(was v3.0)*
+- App shortcuts (launcher long-press → New event), maybe a quick-settings tile
+
+## Locations & People *(go/no-go, captured 2026-06-11)*
+
+Beyond classic calendar-client scope; discussed, deliberately not planned
+in detail yet:
+
+- **Contact address picker** for the location field via the system picker
+  (`ACTION_PICK` on postal addresses) — one-shot, needs no READ_CONTACTS,
+  fits the privacy story. Same mechanism later for picking emails.
+- **OSM address autocomplete** in the location field (type "Brandenburger
+  Tor" → tap suggestion → resolved address inserted). Backend would be
+  Photon (Nominatim's public policy forbids autocomplete). **Requires the
+  INTERNET permission** — first dent in the "no network access" promise;
+  if built: opt-in (off by default), honest copy, configurable endpoint
+  for self-hosters, onboarding footnote + F-Droid copy reworded. This
+  trade-off is an explicit go/no-go decision before any work starts.
+- **Inline contact suggestions** while typing (needs READ_CONTACTS) — only
+  if the picker proves clunky.
+- **Attendee editing / invites from contacts** — own milestone; writing
+  `Attendees` rows touches sync-adapter invitation behavior (Google vs
+  DAVx5 differ).
+
+## Consciously rejected
+
+- Travel time / weather / smart suggestions (network, core-promise conflict)
+- Natural-language quick entry (high effort, locale-fragile; the prefilled
+  form already covers fast entry)
+- Quick-add sheet (the prefilled full form already covers it — cut in v2.0)

.planning/STATE.md

@@ -1,13 +1,15 @@
 # Calendula — Current State
 
-*Last updated: 2026-06-11*
+*Last updated: 2026-06-17*
 
 ## Status
 
-**Milestone:** v1.0.0 — First public release (shipped 2026-06-11)
-**Phase:** V1 is complete and released. All screens done, the read model
-surfaces every readable `CalendarContract` field, and the onboarding screen
-got its Material 3 Expressive polish pass. Next horizon is v2.0 (write support)
+**Milestone:** 2 (write support) **complete** — v2.0.0 shipped 2026-06-11;
+v2.1.0 (month event grid, drawer view tabs, cursor fix) shipped 2026-06-15.
+**Phase:** post-2.1 backlog work. v2.2.0 (tap-to-create in day/week + local
+calendar management) and v2.3.0 (Material 3 grouped-list redesign of Settings,
+the calendar manager and the navigation drawer) both shipped 2026-06-16. The
+backlog is now organised by theme in `ROADMAP.md`.
 
 ## Progress
 
@@ -28,7 +30,99 @@ got its Material 3 Expressive polish pass. Next horizon is v2.0 (write support)
   URLs in the detail view; new domain enums + mapper unit tests. (A dedicated
   URL field was cut — no `CalendarContract` column backs it.)
 
+- [x] v1.1 write foundation — `WRITE_CALENDAR` (onboarding asks READ+WRITE,
+  only READ gates; contextual upgrade for v1.0 installs), read-only-calendar
+  detection (`CALENDAR_ACCESS_LEVEL` → `canModifyContents`, actions hidden for
+  WebCal/birthday calendars), delete from the detail screen (recurring:
+  "only this event" via cancelled exception / "all events in the series"),
+  repository + mapper tests
+
+- [x] v1.2 create event — full-screen `EventEditScreen` (title, all-day,
+  M3 date/time pickers with duration-preserving start moves, writable-only
+  calendar picker preselecting the last-used calendar, location, description),
+  "+" FAB on all three views prefilled with the visible day, `insertEvent`
+  with provider-correct all-day normalisation (UTC midnights, exclusive end),
+  domain/mapper/repository tests
+
+- [x] v1.3 edit event (shipped 2026-06-11) — `EventEditScreen` reused for
+  edit (detail-screen Edit action, `canModify`-gated, contextual WRITE
+  upgrade), dirty-checked partial `update` on the Events row (recurring:
+  series DTSTART moves by the user's delta, DURATION instead of DTEND),
+  reminder diff by minutes (kept rows keep their method), simple recurrence
+  picker (FREQ/INTERVAL/UNTIL/COUNT; complex RRULEs preserved verbatim and
+  shown humanized), `EventFormField.Recurrence` incl. settings default,
+  recurrence also available on create; domain/mapper/repository tests.
+  Review round 1: weekly BYDAY day-toggles in the custom picker ("every week
+  on Mon+Fri"). Review rounds 2–4: occurrence edit pulled forward from v2.0
+  and made three-way like delete ("this" = exception row via
+  `CONTENT_EXCEPTION_URI`, "this and following" = series split, "all" =
+  series update); delete equally three-way (truncation via RRULE UNTIL);
+  the edit-scope question moved to save time (Google model) — dirty
+  recurring saves park in `SaveUiState.AwaitingScope`, a changed rule drops
+  the "only this event" option
+
+- [x] v1.4 reminder notifications (shipped 2026-06-11) — exported
+  `EVENT_REMINDER` receiver → `CalendarAlerts` (SCHEDULED & due) →
+  dedicated channel, tap opens detail (singleTop deep link); best-effort
+  FIRED marking; one-time onboarding step requesting `POST_NOTIFICATIONS`
+  with duplicate-reminders warning; Settings mirror. Provider only fires
+  `METHOD_ALERT` rows (AOSP-verified), so email reminders never reach us
+
+- [x] v2.0 conflict dialog + store polish (shipped 2026-06-11 as v2.0.0) —
+  `EditSnapshot` compare on save (overwrite/discard; deleted → close),
+  quick-add cut, calendar-switch → v3 backlog; F-Droid/README copy
+  refreshed, fastlane screenshots DE+EN captured on-device
+
+- [x] v2.1 (shipped 2026-06-15) — month grid shows real events as
+  continuous multi-day bars; navigation-drawer View section
+  (Month/Week/Day); cursor-jump fix in event text fields
+
+- [x] v2.2 (shipped 2026-06-16) — tap an empty slot in day/week to create
+  (prefilled with that day + tapped hour, snapped to the hour); local
+  calendar management in a full-screen editor from Settings →
+  Calendars: create/rename/recolor/delete device-only calendars
+  (`ACCOUNT_TYPE_LOCAL`, sync-adapter insert) with name, pastel-previewed
+  colour, and description (stored in `CAL_SYNC1`); synced calendars listed
+  read-only grouped by account with a per-account "manage in source app"
+  deep-link (resolved from the account's authenticator: DAVx5/ICSx5/…) and
+  an add-account shortcut. Shared `InlineTextField` extracted to `ui.common`
+
+- [x] v2.3 settings/calendars/drawer redesign (shipped 2026-06-16) — adopted a
+  shared Material 3 grouped-list blueprint, modelled on the ReFra gallery app
+  and extracted to `ui/common/GroupedList.kt` (`CollapsingScaffold` with a
+  `LargeTopAppBar` exit-until-collapsed title; `GroupedRow` with Position-based
+  corner grouping, press-animated corners, `selected` + `minHeight` knobs).
+    - Settings: category hub (About card on top → version mark at the foot) with
+      sliding sub-pages (Appearance / New event form / Notifications); token-
+      based icon chips; theme/week-start/language pickers migrated from
+      `DropdownMenu` to OptionCard dialogs. New `ic_gitea.xml` (Simple Icons,
+      verbatim path) for the About "Source" button; en+de strings.
+    - Calendar manager: same collapsing scaffold + grouped rows; shared
+      `CalendarColorChip` (neutral chip, pastelised calendar glyph).
+    - Navigation drawer: branded header, grouped View switcher (active view
+      highlighted via `secondaryContainer`), the filter list restyled to
+      grouped rows with a trailing checkbox; the whole drawer scrolls as one.
+    - Cards use `surfaceContainerHigh` for readable contrast against `surface`.
+    - Donate button on the About card deferred (target still TBD).
+
+- [x] v2.4 per-event color (shipped 2026-06-17) — an optional "Color" field in
+  the event form. Read/render already resolved `EVENT_COLOR` with a calendar
+  fallback; this adds the write side and the picker. Palette-backed calendars
+  (Google, some CalDAV) pick from the account's `Colors` (`TYPE_EVENT`) and
+  write `EVENT_COLOR_KEY` so the color round-trips through sync; local
+  calendars write a raw `EVENT_COLOR` from the shared `CALENDAR_COLOR_PALETTE`
+  (extracted with the swatch row to `ui/common/ColorSwatchRow.kt`). Switching
+  calendars resets the choice (a key is account-scoped). A settings toggle
+  ("Allow colors on unsupported calendars", off by default) extends the raw
+  path to synced calendars with no palette, with an honest "may not survive
+  sync" warning on the picker and in Settings. Color writes flow through
+  insert / dirty-checked update / occurrence-exception; mapper + form tests.
+
 ## Next
 
-1. v1.0.0 released — monitor the F-Droid build/publish
-2. Plan v2.0 (write support: create / edit / delete, quick-add, conflict UX)
+1. Monitor the F-Droid build/publish for the v2.4.0 tag
+2. Decide the "Locations & People" and "remote calendar create/edit"
+   go/no-go calls (both hinge on the INTERNET permission) — see `ROADMAP.md`
+3. **Duplicate event** and **jump-to-date** are the cheap follow-ups; then
+   agenda view (strategic, backs a future widget). Full ranked sequence in
+   `ROADMAP.md` → "Near-term sequence".

CHANGELOG.md

@@ -7,6 +7,242 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.0] — 2026-06-17
+
+### Added
+- Per-event colors: give a single event its own color, instead of always
+  inheriting its calendar's. Add the new "Color" field from "More fields" in
+  the event form. On calendars that publish their own color set — such as
+  Google — you pick from that calendar's palette, so the color is stored
+  with the event and shows correctly on every synced device. On local
+  calendars you pick from Calendula's palette. "Reset" returns an event to
+  its calendar's color
+- A new "Allow colors on unsupported calendars" setting (New event form,
+  off by default) extends per-event colors to calendars that publish no
+  color set of their own (some CalDAV). Such a color is kept on the device
+  and may be dropped or overwritten on that calendar's next sync — a
+  limitation of those calendars, called out plainly in the setting and on
+  the color picker
+
+## [2.3.0] — 2026-06-16
+
+### Changed
+- Redesigned Settings around the Material 3 grouped-list pattern: a large
+  title that collapses into the toolbar as you scroll, category cards on the
+  main screen, and dedicated sub-pages for Appearance, the new-event form, and
+  Notifications. The theme, week-start and language pickers now use the app's
+  standard option-card dialogs instead of dropdown menus
+- About moved to the top of Settings as a card — app icon, author, and quick
+  links to the source code and licence — with the version shown plainly at the
+  foot of the list
+- The Calendars screen now uses the same grouped-card layout and collapsing
+  title, and each calendar shows a soft pastel-tinted calendar glyph rather
+  than a plain colour swatch
+- Redesigned the navigation drawer to match: a branded header, the
+  Month / Week / Day switch and your calendars as grouped cards (with the
+  active view highlighted), and the whole drawer now scrolls as one
+
+## [2.2.0] — 2026-06-16
+
+### Added
+- Tap an empty slot in the day or week view to create an event there: the
+  create form opens prefilled with that day and the tapped hour (snapped to
+  the hour, one hour long). Tapping an existing event still opens it
+- Local calendars: create and manage device-only calendars that live
+  entirely on this phone — no account, no sync — from a new "Calendars"
+  screen in Settings. Give each a name, a colour, and an optional
+  description; rename, recolour, or delete them later. Useful when you want
+  a calendar without setting up an account
+- The Calendars screen also lists your synced calendars (DAVx5, ICSx5, …)
+  grouped by account, each with a "Manage" button that opens the app the
+  calendar actually comes from, plus an "Add account" shortcut to the
+  system account settings. Calendula never touches a synced calendar's
+  server itself — that stays with its own app
+
+### Changed
+- Colour swatches in the calendar editor now preview the soft, pastel tone
+  a calendar is actually drawn with, instead of a bright raw colour
+- The calendar editor reuses the event form's field and button styling for
+  a consistent look
+
+## [2.1.0] — 2026-06-15
+
+### Added
+- The month view now shows real events in each day instead of coloured
+  dots: all-day and multi-day events render as continuous bars at the top
+  (a multi-day event is one connected bar across the days it spans, not a
+  chip per day), with single-day timed events as filled pills beneath.
+  Up to three rows show per day, then a "+N" dot indicator for the rest.
+  Each day keeps a rounded surface background, matching the week and day
+  views; today is marked with a filled circle on its number
+- The slide-out panel now has a "View" section to switch between Month,
+  Week, and Day, mirroring the top-bar switcher pill — tapping a view
+  selects it and closes the drawer. The current view is highlighted
+
+### Fixed
+- Typing in the event title, location, and description fields no longer
+  makes the cursor jump around: the form state's round-trip to the UI was
+  hopping to a background dispatcher, so the text field saw a lagging value
+  while typing. Only the calendar/preferences reads stay off the main
+  thread now; the keystroke path is synchronous again
+
+## [2.0.0] — 2026-06-11
+
+### Added
+- Conflict handling when saving an edit: if the event changed elsewhere
+  (sync, another device) while the form was open, saving now asks whether
+  to keep or discard your changes instead of silently overwriting the
+  edited fields — and tells you when the event was deleted in the meantime.
+  "Keep" still writes only the fields you touched; external changes to
+  untouched fields survive either way
+- F-Droid store screenshots (German + English), captured with demo data
+
+### Changed
+- F-Droid description and README no longer claim the app is read-only —
+  they now describe write support and reminder delivery
+
+### Fixed
+- `versionName`/`versionCode` bumped to 2.0.0 / 13 — closing out the
+  write-support milestone (v1.1 through v2.0)
+
+## [1.4.0] — 2026-06-11
+
+### Added
+- Reminder notifications (v1.4): Calendula now delivers event reminders as
+  notifications itself — the system schedules them but posts nothing, so a
+  calendar app must (essential when Calendula is the only one installed).
+  Due reminders appear on a dedicated "Event reminders" channel; tapping one
+  opens the event's detail screen. Email reminders are never posted (the
+  provider only schedules alert-type reminders)
+- A one-time onboarding step after the calendar grant introduces reminders,
+  requests the notification permission (Android 13+), and warns that a second
+  calendar app with notifications on will duplicate them. "Not now" leaves
+  the feature off
+- Settings gained a "Notifications" section mirroring the choice: an event-
+  reminders toggle (default on) with the duplicate-reminders hint; turning it
+  on re-requests the notification permission when missing
+
+### Fixed
+- `versionName`/`versionCode` bumped to 1.4.0 / 12
+
+## [1.3.0] — 2026-06-11
+
+### Added
+- Event editing: a pencil action on the detail screen (writable calendars
+  only) opens the event form prefilled with the event. Only fields you
+  actually changed are written back; saving an untouched form is a no-op.
+  Sections holding data are always shown, regardless of the form-field
+  defaults; the calendar itself can't be changed while editing
+- Recurring events — scoped writes, chosen when saving (Google model):
+  "only this event" (a modified-occurrence exception), "this and all
+  following" (the series is split at the occurrence), or "all events in
+  the series". Changing the recurrence rule rules out "only this event"
+- Deleting a recurring event gained the middle option too: "this and all
+  following events" ends the series just before the chosen occurrence
+- Recurrence picker (create and edit): one-tap daily/weekly/monthly/yearly
+  presets plus a custom step with interval + unit, weekday toggles for
+  weekly rules ("every week on Mon and Fri"), and an end condition (never /
+  on a date / after a number of times). Rules the picker can't express
+  (e.g. "second Thursday monthly") are shown humanized and preserved
+  verbatim unless replaced. Recurrence also joined the optional form
+  fields and their settings defaults
+- Validation: a repeat that would end before the event starts is flagged
+  (it would otherwise vanish from every view)
+
+### Changed
+- Editing reminders reconciles against the provider's actual rows:
+  reminders you didn't touch keep their method (e.g. email reminders on
+  synced events survive unrelated edits)
+- The contextual WRITE_CALENDAR upgrade for v1.0 installs covers the edit
+  action like delete
+
+### Fixed
+- Splitting a series ("this and following") sends the complete time-column
+  set in one update, so the provider regenerates its cached instances — an
+  RRULE-only update left a stale duplicate of the tapped occurrence on the
+  split day
+- RRULE UNTIL values are written as the local end of day expressed in UTC
+  (instead of a flat `T235959Z`), so recurrences can't leak an extra day in
+  timezones ahead of UTC
+- `versionName`/`versionCode` bumped to 1.3.0 / 11
+
+## [1.2.1] — 2026-06-11
+
+### Added
+- Optional event-form fields with user-controlled defaults: reminders,
+  availability (busy/free), and visibility (default/public/private/
+  confidential) joined location and description as form sections. Settings
+  gained a "New event form" section choosing which show by default; the rest
+  unfold via a "More fields" picker
+- Reminders editor: stacked rows with right-bound remove, full-width add
+  action; the picker offers one-tap presets and a custom amount + unit
+  (minutes/hours/days/weeks) step
+- `OptionCard` — the app's standard selection-dialog row (full-width tonal
+  card, optional icon + supporting line, highlighted selection). All dialogs
+  (calendar, visibility, more-fields, reminder presets, recurring-delete)
+  now use it; radio-row dialogs are retired
+
+### Changed
+- Event form redesigned onto the detail screen's design system: tonal cards
+  with gutter icons (top-aligned on tall cards), borderless inline text
+  fields, calendar-coloured accent bar under the title, no dividers, no
+  top-bar title; placeholders render clearly fainter than input
+- M3 Expressive motion: the theme now provides a MotionScheme
+  (`MaterialExpressiveTheme`, standard springs — expressive bounce reviewed
+  as overdone), the FAB stack and "more fields" reveals animate on theme
+  springs
+- The jump-to-today slide is direction-aware (future → today slides in from
+  the left, past → from the right)
+- `versionName`/`versionCode` bumped to 1.2.1 / 10
+
+### Fixed
+- The keyboard no longer pans the whole event form; the screen stays
+  anchored and the focused field scrolls into view (`adjustResize` +
+  `imePadding`)
+
+## [1.2.0] — 2026-06-11
+
+### Added
+- Create events (milestone 2, slice 2):
+  - A "+" FAB on the month, week, and day views opens a new full-screen event
+    form, prefilled with the visible day (today at the next full hour, or
+    09:00 on other days)
+  - The form covers title, all-day toggle, start/end with Material 3 date and
+    time pickers (moving the start drags the end along, preserving duration),
+    target calendar, location, and description
+  - The calendar picker offers only writable calendars and preselects the one
+    you last created an event in
+  - Validation on save ("ends before it starts", no writable calendar), with
+    the same contextual write-permission upgrade as delete
+  - All-day events are stored provider-correctly (UTC midnights, exclusive
+    end), timed events in the device time zone
+
+### Changed
+- The jump-to-today pill now stacks above the new "+" FAB instead of being
+  the only floating action
+- `versionName`/`versionCode` bumped to 1.2.0 / 9
+
+## [1.1.0] — 2026-06-11
+
+### Added
+- Write foundation (milestone 2, slice 1): Calendula can now **delete events**.
+  - Delete action on the event detail screen, with a confirmation dialog;
+    recurring events choose between "Only this event" (a cancelled exception,
+    so the rest of the series survives) and "All events in the series"
+  - `WRITE_CALENDAR` permission: onboarding asks for read+write in one system
+    dialog, but only read access is required — declining write keeps the app
+    fully usable read-only. Existing v1.0 installs are asked for the write
+    upgrade in place, on their first delete
+  - Read-only calendars (WebCal subscriptions, birthday calendars, …) are
+    detected via `CALENDAR_ACCESS_LEVEL` and show no edit/delete actions at all
+
+### Changed
+- Onboarding copy no longer claims "read-only"; it now says your data stays on
+  the device (still no internet permission, still zero telemetry)
+- The placeholder Edit button on the detail screen (a no-op since v0.4) is
+  removed until editing ships in a later slice
+- `versionName`/`versionCode` bumped to 1.1.0 / 8
+
 ## [1.0.0] — 2026-06-11
 
 First public release. Calendula is a read-only, Material 3 Expressive calendar

README.md

@@ -1,43 +1,120 @@
-# Calendula
+<div align="center">
 
-A modern Material 3 Expressive calendar app for Android.
+<img src="fdroid-metadata/de.jeanlucmakiola.calendula/en-US/icon.png" width="112" alt="Calendula icon">
 
-Calendula is named after the flower of the same name, whose name comes from
-the Latin *kalendae* — the first day of the month — the same root as the
-word "calendar". Calendula reads from Android's built-in `CalendarContract`,
-so any calendar source synced to your device (CalDAV via DAVx5, Google,
-local, WebCal subscriptions, ...) is shown.
+<h1>Calendula</h1>
 
-## Features (V1)
+<p><strong>A modern Material 3 Expressive calendar for Android.</strong><br>
+Reads, writes, and reminds — on top of the system calendar, with zero network access.</p>
 
-- Month, Week, and Day views
-- Read-only event details (write support comes in V2)
-- Multi-calendar visibility toggle
-- Material You Dynamic Color (Android 12+)
-- Light/Dark theme follows system
-- German + English UI
+<p>
+<a href="https://gitea.jeanlucmakiola.de/makiolaj/calendula/actions"><img src="https://gitea.jeanlucmakiola.de/makiolaj/calendula/actions/workflows/ci.yaml/badge.svg?branch=main" alt="CI"></a>
+<img src="https://img.shields.io/badge/Android-10%2B-3DDC84?logo=android&logoColor=white" alt="Android 10+">
+<img src="https://img.shields.io/badge/Kotlin-Compose-7F52FF?logo=kotlin&logoColor=white" alt="Kotlin + Compose">
+<img src="https://img.shields.io/badge/Material%203-Expressive-4285F4" alt="Material 3 Expressive">
+<a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-green" alt="MIT License"></a>
+</p>
 
-## Building
+<p>
+<img src="fdroid-metadata/de.jeanlucmakiola.calendula/en-US/phoneScreenshots/01-week.png" width="19%" alt="Week view">&nbsp;
+<img src="fdroid-metadata/de.jeanlucmakiola.calendula/en-US/phoneScreenshots/02-month.png" width="19%" alt="Month view">&nbsp;
+<img src="fdroid-metadata/de.jeanlucmakiola.calendula/en-US/phoneScreenshots/04-detail.png" width="19%" alt="Event detail">&nbsp;
+<img src="fdroid-metadata/de.jeanlucmakiola.calendula/en-US/phoneScreenshots/05-edit.png" width="19%" alt="Event form">&nbsp;
+<img src="fdroid-metadata/de.jeanlucmakiola.calendula/en-US/phoneScreenshots/06-onboarding.png" width="19%" alt="Reminder onboarding">
+</p>
 
-Requires Android SDK 36 and JDK 17. The Gradle wrapper is checked in, so no host Gradle install is needed:
+</div>
+
+Calendula is named after the flower whose name — like the word *calendar* —
+comes from the Latin *kalendae*, the first day of the month. It lives
+entirely on top of Android's `CalendarContract`: any calendar synced to your
+device (CalDAV via DAVx5, Google, local, WebCal subscriptions, …) simply
+appears, and everything you create or edit syncs back the same way. No own
+database, no sync stack reinvented.
+
+## ✨ Features
+
+**Calendar**
+
+- Month, week, and day views with a one-tap view switcher
+- Full event details — attendees and their responses, reminders, recurrence
+  (humanized), availability, visibility, foreign time zones
+- Per-calendar visibility toggle, grouped by account
+
+**Editing**
+
+- Create, edit, and delete events — including recurring events with scoped
+  writes: *only this event*, *this and all following*, or *the whole series*
+- Recurrence picker with one-tap presets and custom rules (interval, weekday
+  toggles, end conditions); rules it can't express are preserved verbatim
+- Conflict-safe saves: if an event changed elsewhere while you were editing,
+  Calendula asks instead of silently overwriting
+- Read-only calendars (WebCal, birthdays) are detected and respected
+
+**Reminders**
+
+- Event reminders delivered by Calendula itself as notifications —
+  essential when it's your only calendar app, since Android delegates
+  reminder delivery to calendar apps
+- Tap a reminder to land on the event
+
+**Design & privacy**
+
+- Real Material 3 Expressive throughout — dynamic color (Android 12+),
+  expressive motion and shapes, light/dark theme
+- German and English UI, per-app language setting
+- **Zero telemetry, zero analytics, no internet permission** — your data
+  never leaves the device
+
+## 📦 Install
+
+Calendula ships through a self-hosted F-Droid repository; every version tag
+is built, signed, and published there automatically.
+
+1. Install an F-Droid client ([F-Droid](https://f-droid.org), Droid-ify, Neo
+   Store, …).
+2. Add the repository — open this link on your phone, or paste it under
+   *Settings → Repositories → Add*:
+
+   ```
+   https://apps.dev.jeanlucmakiola.de/dev/fdroid/repo?fingerprint=C2C0640402BF458FC0ED957AF0B37AA4C14022E72F89CE90B5965B458CF73425
+   ```
+
+   <sub>Repo: `https://apps.dev.jeanlucmakiola.de/dev/fdroid/repo` ·
+   fingerprint (SHA-256):
+   `C2C0 6404 02BF 458F C0ED 957A F0B3 7AA4 C140 22E7 2F89 CE90 B596 5B45 8CF7 3425`</sub>
+
+3. Refresh, search for **Calendula**, install. Updates arrive like any
+   other F-Droid app.
+
+Alternatively, build from source — see below.
+
+## 🛠 Building
+
+Requires Android SDK 36+ and JDK 17. The Gradle wrapper is checked in:
 
 ```bash
-# Build debug APK
-./gradlew assembleDebug
-
-# Run unit tests
-./gradlew test
-
-# Run lint
-./gradlew lint
+./gradlew assembleDebug   # debug APK
+./gradlew test            # JVM unit tests
+./gradlew lint            # Android lint
 ```
 
-If your default JDK is something other than 17, set `JAVA_HOME` explicitly:
+If your default JDK is not 17, set `JAVA_HOME` explicitly.
 
-```bash
-JAVA_HOME=/path/to/jdk-17 ./gradlew assembleDebug
-```
+## 🏗 Architecture
 
-## License
+Single-activity Compose app, layered `UI → Repository → DataSource →
+CalendarContract`, observer-driven refresh, JVM-first tests. The full tour —
+including the recurring-write and reminder pipelines — lives in
+[docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
+
+## 🗺 Roadmap
+
+Shipped: read (v1.0), write (v1.1–v2.0), reminder delivery (v1.4).
+Next up: power-user features — widget, search, tablet layouts. The living
+roadmap is in [.planning/ROADMAP.md](.planning/ROADMAP.md), the release
+history in [CHANGELOG.md](CHANGELOG.md).
+
+## 📜 License
 
 [MIT](LICENSE) — Jean-Luc Makiola, 2026

app/build.gradle.kts

@@ -23,8 +23,13 @@ android {
         applicationId = "de.jeanlucmakiola.calendula"
         minSdk = 29
         targetSdk = 36
-        versionCode = 7
-        versionName = "1.0.0"
+        // The git tag is the single source of truth for released builds: at
+        // release time .gitea/workflows/release.yaml derives both fields from
+        // the tag, with versionCode = MAJOR*10000 + MINOR*100 + PATCH
+        // (e.g. v2.0.0 -> 20000). These committed values are the dev/local
+        // default; keep them matching the latest released tag. See docs/RELEASING.md.
+        versionCode = 20400
+        versionName = "2.4.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/main/AndroidManifest.xml

@@ -3,6 +3,20 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.READ_CALENDAR" />
+    <uses-permission android:name="android.permission.WRITE_CALENDAR" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <!-- Package visibility (Android 11+): without this, getLaunchIntentForPackage
+         returns null and the calendar manager's per-account "manage" button can't
+         open the source sync app (DAVx5, ICSx5, Google Calendar, …). The LAUNCHER
+         intent makes launchable apps visible so we can launch whichever app owns a
+         calendar account's authenticator. -->
+    <queries>
+        <intent>
+            <action android:name="android.intent.action.MAIN" />
+            <category android:name="android.intent.category.LAUNCHER" />
+        </intent>
+    </queries>
 
     <application
         android:name=".CalendulaApp"
@@ -17,13 +31,29 @@
         tools:targetApi="35">
         <activity
             android:name=".MainActivity"
-            android:exported="true">
+            android:exported="true"
+            android:launchMode="singleTop"
+            android:windowSoftInputMode="adjustResize">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
 
+        <!-- The provider broadcasts EVENT_REMINDER at reminder time but posts
+             no notification itself — a calendar app must (v1.4, Etar model).
+             Exported: the broadcast arrives from the provider's process. -->
+        <receiver
+            android:name=".data.reminders.EventReminderReceiver"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.EVENT_REMINDER" />
+                <data
+                    android:host="com.android.calendar"
+                    android:scheme="content" />
+            </intent-filter>
+        </receiver>
+
         <!-- Persists the per-app language (M4) on API < 33, where the platform
              per-app-languages API is unavailable. On 33+ this is a no-op. -->
         <service

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

@@ -1,5 +1,7 @@
 package de.jeanlucmakiola.calendula
 
+import android.content.Context
+import android.content.Intent
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
@@ -7,7 +9,10 @@ import androidx.activity.enableEdgeToEdge
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
+import androidx.core.net.toUri
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import dagger.hilt.android.AndroidEntryPoint
@@ -18,9 +23,16 @@ import de.jeanlucmakiola.calendula.ui.theme.CalendulaTheme
 
 @AndroidEntryPoint
 class MainActivity : ComponentActivity() {
+
+    // The occurrence a reminder notification was tapped for (eventId, begin,
+    // end — the detail screen's key shape). singleTop + onNewIntent route a
+    // tap into the running activity; CalendarHost consumes and clears it.
+    private var requestedDetailKey by mutableStateOf<LongArray?>(null)
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
+        requestedDetailKey = intent.detailKeyOrNull()
         setContent {
             // One activity-scoped SettingsViewModel drives both the theme here
             // and the Settings screen, so a theme change applies app-wide at once.
@@ -35,8 +47,51 @@ class MainActivity : ComponentActivity() {
                 darkTheme = darkTheme,
                 dynamicColor = settings.dynamicColor,
             ) {
-                RootScreen(modifier = Modifier.fillMaxSize())
+                RootScreen(
+                    modifier = Modifier.fillMaxSize(),
+                    requestedDetailKey = requestedDetailKey,
+                    onDetailKeyConsumed = { requestedDetailKey = null },
+                )
             }
         }
     }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        intent.detailKeyOrNull()?.let { requestedDetailKey = it }
+    }
+
+    private fun Intent.detailKeyOrNull(): LongArray? {
+        val eventId = getLongExtra(EXTRA_EVENT_ID, -1L)
+        if (eventId == -1L) return null
+        return longArrayOf(
+            eventId,
+            getLongExtra(EXTRA_BEGIN_MILLIS, 0L),
+            getLongExtra(EXTRA_END_MILLIS, 0L),
+        )
+    }
+
+    companion object {
+        private const val EXTRA_EVENT_ID = "de.jeanlucmakiola.calendula.extra.EVENT_ID"
+        private const val EXTRA_BEGIN_MILLIS = "de.jeanlucmakiola.calendula.extra.BEGIN"
+        private const val EXTRA_END_MILLIS = "de.jeanlucmakiola.calendula.extra.END"
+
+        /**
+         * Intent opening the detail screen of one occurrence (reminder
+         * notifications). The synthetic data URI keys the intent so
+         * PendingIntents for different occurrences never collapse into one.
+         */
+        fun eventDetailIntent(
+            context: Context,
+            eventId: Long,
+            beginMillis: Long,
+            endMillis: Long,
+        ): Intent = Intent(context, MainActivity::class.java).apply {
+            data = "calendula://event/$eventId/$beginMillis".toUri()
+            putExtra(EXTRA_EVENT_ID, eventId)
+            putExtra(EXTRA_BEGIN_MILLIS, beginMillis)
+            putExtra(EXTRA_END_MILLIS, endMillis)
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+    }
 }

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

@@ -2,18 +2,26 @@ package de.jeanlucmakiola.calendula.data.calendar
 
 import android.content.ContentResolver
 import android.content.ContentUris
+import android.content.ContentValues
 import android.content.Context
 import android.database.ContentObserver
 import android.database.Cursor
+import android.net.Uri
 import android.os.Handler
 import android.os.Looper
 import android.provider.CalendarContract
+import android.util.Log
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.domain.Attendee
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+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.Reminder
+import de.jeanlucmakiola.calendula.domain.rruleTruncatedAt
+import java.time.ZoneId
+import java.time.ZoneOffset
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -29,6 +37,79 @@ interface CalendarDataSource {
     fun calendars(): List<CalendarSource>
     fun instances(beginMillis: Long, endMillis: Long): List<EventInstance>
     fun eventDetail(eventId: Long): EventDetail?
+
+    /**
+     * The event-colour palette the calendar's account publishes
+     * (`CalendarContract.Colors`, `TYPE_EVENT`), sorted by key. Empty when the
+     * account exposes no palette (most local calendars, some CalDAV) — the
+     * signal that a custom colour can only be written as a raw `EVENT_COLOR`,
+     * which a synced calendar may drop on its next sync.
+     */
+    fun eventColorPalette(calendarId: Long): List<EventColorOption>
+
+    /**
+     * Create a new device-only (`ACCOUNT_TYPE_LOCAL`) calendar the app owns;
+     * returns its `Calendars._ID`. Inserted through the sync-adapter URI so the
+     * provider keeps the row (a plain insert is rejected for the LOCAL account).
+     */
+    fun createLocalCalendar(displayName: String, color: Int, description: String?): Long
+
+    /** Update name, color and description of a local calendar the app owns. */
+    fun updateCalendar(id: Long, displayName: String, color: Int, description: String?)
+
+    /** Permanently delete a local calendar the app owns, with all its events. */
+    fun deleteCalendar(id: Long)
+
+    /** Insert a new event; returns the new `Events._ID`. */
+    fun insertEvent(form: EventForm): Long
+
+    /**
+     * Update an existing event (for recurring events: the whole series) to
+     * match [updated]. [original] is the form as it was prefilled from the
+     * event, so only fields the user actually changed are written and the
+     * reminder rows can be diffed instead of wiped.
+     */
+    fun updateEvent(eventId: Long, original: EventForm, updated: EventForm)
+
+    /**
+     * 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`.
+     */
+    fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long
+
+    /**
+     * Change a recurring event from the occurrence at [beginMillis] onwards
+     * by splitting the series: the existing RRULE ends just before the
+     * occurrence and a new event with [updated]'s values (and rule) starts
+     * there; returns the new event's `Events._ID`. From the first occurrence
+     * this is a plain series update. A carried-over COUNT restarts counting
+     * in the new series (we don't recompute the remaining occurrences).
+     */
+    fun updateEventFromOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        original: EventForm,
+        updated: EventForm,
+    ): Long
+
+    /**
+     * Delete a recurring event from the occurrence at [beginMillis] onwards
+     * by ending the series RRULE just before it. Deleting from the first
+     * occurrence removes the whole event.
+     */
+    fun deleteEventFromOccurrence(eventId: Long, beginMillis: Long)
+
+    /** Delete the whole event (for recurring events: the entire series). */
+    fun deleteEvent(eventId: Long)
+
+    /**
+     * Cancel a single occurrence of a recurring event by inserting a
+     * cancelled exception at [beginMillis] (the occurrence's `Instances.BEGIN`).
+     */
+    fun deleteOccurrence(eventId: Long, beginMillis: Long)
+
     fun registerChangeListener(listener: () -> Unit)
     fun unregisterChangeListener(listener: () -> Unit)
 }
@@ -48,6 +129,76 @@ class AndroidCalendarDataSource @Inject constructor(
         CalendarContract.Calendars.CALENDAR_DISPLAY_NAME + " ASC",
     )?.use { it.mapAll(::toCalendarSource) } ?: emptyList()
 
+    /**
+     * Calendar-row writes must address the provider as a sync adapter and name
+     * the account in the URI; otherwise inserts/deletes for the LOCAL account
+     * are silently dropped or only soft-deleted.
+     */
+    private fun localCalendarsUri(): Uri = CalendarContract.Calendars.CONTENT_URI.buildUpon()
+        .appendQueryParameter(CalendarContract.CALLER_IS_SYNCADAPTER, "true")
+        .appendQueryParameter(CalendarContract.Calendars.ACCOUNT_NAME, LOCAL_ACCOUNT_NAME)
+        .appendQueryParameter(
+            CalendarContract.Calendars.ACCOUNT_TYPE,
+            CalendarContract.ACCOUNT_TYPE_LOCAL,
+        )
+        .build()
+
+    override fun createLocalCalendar(displayName: String, color: Int, description: String?): Long {
+        val name = displayName.trim().ifEmpty { Fallbacks.UNNAMED_CALENDAR }
+        val values = ContentValues().apply {
+            put(CalendarContract.Calendars.ACCOUNT_NAME, LOCAL_ACCOUNT_NAME)
+            put(CalendarContract.Calendars.ACCOUNT_TYPE, CalendarContract.ACCOUNT_TYPE_LOCAL)
+            put(CalendarContract.Calendars.OWNER_ACCOUNT, LOCAL_ACCOUNT_NAME)
+            // NAME is the sync-adapter id; DISPLAY_NAME is what the user sees.
+            put(CalendarContract.Calendars.NAME, name)
+            put(CalendarContract.Calendars.CALENDAR_DISPLAY_NAME, name)
+            put(CalendarContract.Calendars.CALENDAR_COLOR, color)
+            put(
+                CalendarContract.Calendars.CALENDAR_ACCESS_LEVEL,
+                CalendarContract.Calendars.CAL_ACCESS_OWNER,
+            )
+            put(CalendarContract.Calendars.VISIBLE, 1)
+            put(CalendarContract.Calendars.SYNC_EVENTS, 1)
+            putDescription(description)
+        }
+        val uri = resolver.insert(localCalendarsUri(), values)
+            ?: throw WriteFailedException("create local calendar '$name'")
+        return ContentUris.parseId(uri)
+    }
+
+    override fun updateCalendar(id: Long, displayName: String, color: Int, description: String?) {
+        val name = displayName.trim().ifEmpty { Fallbacks.UNNAMED_CALENDAR }
+        val values = ContentValues().apply {
+            put(CalendarContract.Calendars.CALENDAR_DISPLAY_NAME, name)
+            put(CalendarContract.Calendars.NAME, name)
+            put(CalendarContract.Calendars.CALENDAR_COLOR, color)
+            putDescription(description)
+        }
+        val rows = resolver.update(
+            ContentUris.withAppendedId(localCalendarsUri(), id),
+            values, null, null,
+        )
+        if (rows == 0) throw WriteFailedException("update calendar id=$id")
+    }
+
+    /** Store the description in CAL_SYNC1, or clear it when blank/absent. */
+    private fun ContentValues.putDescription(description: String?) {
+        val text = description?.trim().orEmpty()
+        if (text.isEmpty()) {
+            putNull(CalendarProjection.DESCRIPTION_COLUMN)
+        } else {
+            put(CalendarProjection.DESCRIPTION_COLUMN, text)
+        }
+    }
+
+    override fun deleteCalendar(id: Long) {
+        val deleted = resolver.delete(
+            ContentUris.withAppendedId(localCalendarsUri(), id),
+            null, null,
+        )
+        if (deleted == 0) throw WriteFailedException("delete calendar id=$id")
+    }
+
     override fun instances(beginMillis: Long, endMillis: Long): List<EventInstance> {
         val uri = CalendarContract.Instances.CONTENT_URI.buildUpon().apply {
             ContentUris.appendId(this, beginMillis)
@@ -74,6 +225,299 @@ class AndroidCalendarDataSource @Inject constructor(
         }
     }
 
+    override fun eventColorPalette(calendarId: Long): List<EventColorOption> {
+        val account = calendarAccount(calendarId) ?: return emptyList()
+        return resolver.query(
+            CalendarContract.Colors.CONTENT_URI,
+            arrayOf(CalendarContract.Colors.COLOR_KEY, CalendarContract.Colors.COLOR),
+            CalendarContract.Colors.ACCOUNT_NAME + " = ? AND " +
+                CalendarContract.Colors.ACCOUNT_TYPE + " = ? AND " +
+                CalendarContract.Colors.COLOR_TYPE + " = ?",
+            arrayOf(
+                account.name,
+                account.type,
+                CalendarContract.Colors.TYPE_EVENT.toString(),
+            ),
+            null,
+        )?.use { c ->
+            c.mapAll { EventColorOption(key = it.getString(0).orEmpty(), argb = it.getInt(1)) }
+        }
+            ?.filter { it.key.isNotEmpty() }
+            ?.sortedBy { it.key }
+            ?: emptyList()
+    }
+
+    /** 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),
+        arrayOf(
+            CalendarContract.Calendars.ACCOUNT_NAME,
+            CalendarContract.Calendars.ACCOUNT_TYPE,
+        ),
+        null, null, null,
+    )?.use { c ->
+        if (c.moveToFirst()) {
+            CalendarAccount(name = c.getString(0).orEmpty(), type = c.getString(1).orEmpty())
+        } else {
+            null
+        }
+    }
+
+    private data class CalendarAccount(val name: String, val type: String)
+
+    override fun insertEvent(form: EventForm): Long {
+        val times = form.toWriteTimes(ZoneId.systemDefault())
+        val values = ContentValues().apply {
+            put(
+                CalendarContract.Events.CALENDAR_ID,
+                requireNotNull(form.calendarId) { "EventForm.calendarId is required" },
+            )
+            put(CalendarContract.Events.TITLE, form.title.trim())
+            put(CalendarContract.Events.ALL_DAY, if (form.isAllDay) 1 else 0)
+            put(CalendarContract.Events.DTSTART, times.dtStartMillis)
+            // The provider's invariant: recurring rows carry RRULE+DURATION
+            // (and no DTEND), one-off rows carry DTEND.
+            if (form.rrule == null) {
+                put(CalendarContract.Events.DTEND, times.dtEndMillis)
+            } else {
+                put(CalendarContract.Events.RRULE, form.rrule)
+                put(CalendarContract.Events.DURATION, times.toRfc2445Duration(form.isAllDay))
+            }
+            put(CalendarContract.Events.EVENT_TIMEZONE, times.timezone)
+            put(CalendarContract.Events.AVAILABILITY, form.availability.toProviderValue())
+            put(CalendarContract.Events.ACCESS_LEVEL, form.accessLevel.toProviderValue())
+            form.location.trim().takeIf { it.isNotEmpty() }
+                ?.let { put(CalendarContract.Events.EVENT_LOCATION, it) }
+            form.description.trim().takeIf { it.isNotEmpty() }
+                ?.let { put(CalendarContract.Events.DESCRIPTION, it) }
+            // A null colour just leaves both columns unset (the event inherits
+            // its calendar's colour), so only the key/raw cases are written.
+            when {
+                form.colorKey != null ->
+                    put(CalendarContract.Events.EVENT_COLOR_KEY, form.colorKey)
+                form.color != null -> put(CalendarContract.Events.EVENT_COLOR, form.color)
+            }
+        }
+        val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values)
+            ?: throw WriteFailedException("insert event into calendar id=${form.calendarId}")
+        val eventId = ContentUris.parseId(uri)
+        // Best effort (spec §8): the event exists at this point — a reminder
+        // that fails to attach is logged, not surfaced as a failed create.
+        form.reminders.distinct().forEach { minutes ->
+            val reminder = ContentValues().apply {
+                put(CalendarContract.Reminders.EVENT_ID, eventId)
+                put(CalendarContract.Reminders.MINUTES, minutes)
+                put(CalendarContract.Reminders.METHOD, CalendarContract.Reminders.METHOD_ALERT)
+            }
+            if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder) == null) {
+                Log.w(TAG, "Failed to attach reminder ($minutes min) to event $eventId")
+            }
+        }
+        return eventId
+    }
+
+    override fun updateEvent(eventId: Long, original: EventForm, updated: EventForm) {
+        val values = buildEventUpdateValues(
+            original = original,
+            updated = updated,
+            seriesDtStartMillis = querySeriesRow(eventId).dtStartMillis,
+            zone = ZoneId.systemDefault(),
+        )
+        if (values.isNotEmpty()) {
+            val rows = resolver.update(
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+                values.toContentValues(),
+                null, null,
+            )
+            if (rows == 0) throw WriteFailedException("update event id=$eventId")
+        }
+        // Untouched reminder sets are left alone so unrelated edits can't
+        // disturb provider rows the form never knew about.
+        if (updated.reminders.toSet() != original.reminders.toSet()) {
+            reconcileReminders(eventId, updated.reminders)
+        }
+    }
+
+    override fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long {
+        // The provider clones the series row and applies these values on top.
+        val values = buildOccurrenceExceptionValues(
+            form = form,
+            originalInstanceMillis = beginMillis,
+            zone = ZoneId.systemDefault(),
+        )
+        val uri = resolver.insert(
+            ContentUris.withAppendedId(CalendarContract.Events.CONTENT_EXCEPTION_URI, eventId),
+            values.toContentValues(),
+        ) ?: throw WriteFailedException("modify occurrence event id=$eventId begin=$beginMillis")
+        val exceptionId = ContentUris.parseId(uri)
+        // Whether the provider copied the parent's reminder rows is its
+        // business — reconciling against the actual rows handles both ways.
+        reconcileReminders(exceptionId, form.reminders)
+        return exceptionId
+    }
+
+    override fun updateEventFromOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        original: EventForm,
+        updated: EventForm,
+    ): Long {
+        val row = querySeriesRow(eventId)
+        // From the first occurrence on (or with no rule to split) this is
+        // just a series update.
+        if (row.rrule.isNullOrBlank() || beginMillis <= row.dtStartMillis) {
+            updateEvent(eventId, original, updated)
+            return eventId
+        }
+        // Insert the new series first: if it fails, the original is untouched.
+        val newEventId = insertEvent(updated)
+        truncateSeries(eventId, row, beginMillis)
+        return newEventId
+    }
+
+    override fun deleteEventFromOccurrence(eventId: Long, beginMillis: Long) {
+        val row = querySeriesRow(eventId)
+        // From the first occurrence on = the whole series; also the fallback
+        // when there is no RRULE to truncate.
+        if (row.rrule.isNullOrBlank() || beginMillis <= row.dtStartMillis) {
+            deleteEvent(eventId)
+            return
+        }
+        truncateSeries(eventId, row, beginMillis)
+    }
+
+    /**
+     * End [row]'s series just before the occurrence at [beginMillis]. The
+     * provider regenerates an event's cached instances only from the values
+     * carried by the update itself — an RRULE-only update leaves the old
+     * instances standing (observed on-device: the truncated occurrence kept
+     * showing) — so the entire time-related set travels together, with only
+     * the RRULE actually changing.
+     */
+    private fun truncateSeries(eventId: Long, row: SeriesRow, beginMillis: Long) {
+        requireNotNull(row.rrule) { "truncateSeries needs a recurring row" }
+        val values = ContentValues().apply {
+            put(CalendarContract.Events.DTSTART, row.dtStartMillis)
+            put(CalendarContract.Events.DURATION, row.duration)
+            put(CalendarContract.Events.EVENT_TIMEZONE, row.timezone)
+            put(CalendarContract.Events.ALL_DAY, row.allDay)
+            put(
+                CalendarContract.Events.RRULE,
+                rruleTruncatedAt(row.rrule, untilUtcMillis = row.truncationCutoff(beginMillis)),
+            )
+        }
+        val rows = resolver.update(
+            ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+            values,
+            null, null,
+        )
+        if (rows == 0) {
+            throw WriteFailedException("truncate series event id=$eventId begin=$beginMillis")
+        }
+    }
+
+    /** The series anchor: every time-related column of the Events row. */
+    private fun querySeriesRow(eventId: Long): SeriesRow = resolver.query(
+        ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+        arrayOf(
+            CalendarContract.Events.DTSTART,
+            CalendarContract.Events.RRULE,
+            CalendarContract.Events.EVENT_TIMEZONE,
+            CalendarContract.Events.DURATION,
+            CalendarContract.Events.ALL_DAY,
+        ),
+        null, null, null,
+    )?.use { c ->
+        if (c.moveToFirst()) {
+            SeriesRow(
+                dtStartMillis = c.getLong(0),
+                rrule = c.getString(1),
+                timezone = c.getString(2),
+                duration = c.getString(3),
+                allDay = c.getInt(4),
+            )
+        } else {
+            null
+        }
+    } ?: throw WriteFailedException("read series row of event id=$eventId")
+
+    private data class SeriesRow(
+        val dtStartMillis: Long,
+        val rrule: String?,
+        val timezone: String?,
+        val duration: String?,
+        val allDay: Int,
+    ) {
+        /** UNTIL cutoff for ending the series before the occurrence at [beginMillis]. */
+        fun truncationCutoff(beginMillis: Long): Long = previousLocalDayEndUtcMillis(
+            beginMillis = beginMillis,
+            zone = runCatching { ZoneId.of(timezone ?: "UTC") }.getOrDefault(ZoneOffset.UTC),
+        )
+    }
+
+    /**
+     * Make the event's reminder rows match [targetMinutes]: rows with other
+     * lead times are deleted, missing ones inserted as best-effort ALERTs
+     * (like insertEvent). Rows whose minutes survive keep their method.
+     */
+    private fun reconcileReminders(eventId: Long, targetMinutes: List<Int>) {
+        val target = targetMinutes.toSet()
+        val existing = queryReminders(eventId).map { it.minutes }.toSet()
+        (existing - target).forEach { minutes ->
+            resolver.delete(
+                CalendarContract.Reminders.CONTENT_URI,
+                CalendarContract.Reminders.EVENT_ID + " = ? AND " +
+                    CalendarContract.Reminders.MINUTES + " = ?",
+                arrayOf(eventId.toString(), minutes.toString()),
+            )
+        }
+        (target - existing).forEach { minutes ->
+            val reminder = ContentValues().apply {
+                put(CalendarContract.Reminders.EVENT_ID, eventId)
+                put(CalendarContract.Reminders.MINUTES, minutes)
+                put(CalendarContract.Reminders.METHOD, CalendarContract.Reminders.METHOD_ALERT)
+            }
+            if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder) == null) {
+                Log.w(TAG, "Failed to attach reminder ($minutes min) to event $eventId")
+            }
+        }
+    }
+
+    private fun Map<String, Any?>.toContentValues(): ContentValues =
+        ContentValues().also { cv ->
+            forEach { (column, value) ->
+                when (value) {
+                    null -> cv.putNull(column)
+                    is String -> cv.put(column, value)
+                    is Long -> cv.put(column, value)
+                    is Int -> cv.put(column, value)
+                    else -> error("Unsupported value for $column: $value")
+                }
+            }
+        }
+
+    override fun deleteEvent(eventId: Long) {
+        val deleted = resolver.delete(
+            ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+            null, null,
+        )
+        if (deleted == 0) throw WriteFailedException("delete event id=$eventId")
+    }
+
+    override fun deleteOccurrence(eventId: Long, beginMillis: Long) {
+        // A cancelled exception row hides exactly this occurrence; the sync
+        // adapter turns it into an EXDATE/cancelled VEVENT upstream.
+        val values = ContentValues().apply {
+            put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, beginMillis)
+            put(CalendarContract.Events.STATUS, CalendarContract.Events.STATUS_CANCELED)
+        }
+        val uri = ContentUris.withAppendedId(
+            CalendarContract.Events.CONTENT_EXCEPTION_URI, eventId,
+        )
+        resolver.insert(uri, values)
+            ?: throw WriteFailedException("cancel occurrence event id=$eventId begin=$beginMillis")
+    }
+
     override fun registerChangeListener(listener: () -> Unit) {
         val obs = object : ContentObserver(Handler(Looper.getMainLooper())) {
             override fun onChange(selfChange: Boolean) {
@@ -119,4 +563,14 @@ class AndroidCalendarDataSource @Inject constructor(
     private inline fun <T : Any> Cursor.mapAllNotNull(mapper: (Cursor) -> T?): List<T> = buildList {
         while (moveToNext()) mapper(this@mapAllNotNull)?.let(::add)
     }
+
+    private companion object {
+        const val TAG = "CalendarDataSource"
+
+        /**
+         * Shared account for every app-created local calendar, so they group
+         * together (by account) in the filter sheet and calendar manager.
+         */
+        const val LOCAL_ACCOUNT_NAME = "Calendula"
+    }
 }

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

@@ -1,13 +1,28 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
+import android.provider.CalendarContract
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 
-internal fun ColumnReader.toCalendarSource(): CalendarSource = CalendarSource(
+internal fun ColumnReader.toCalendarSource(): CalendarSource {
+    val accountType = getString(CalendarProjection.IDX_ACCOUNT_TYPE).orEmpty()
+    val isLocal = accountType == CalendarContract.ACCOUNT_TYPE_LOCAL
+    return CalendarSource(
         id = getLong(CalendarProjection.IDX_ID),
         displayName = getString(CalendarProjection.IDX_DISPLAY_NAME)
             ?: Fallbacks.UNNAMED_CALENDAR,
         accountName = getString(CalendarProjection.IDX_ACCOUNT_NAME).orEmpty(),
-    accountType = getString(CalendarProjection.IDX_ACCOUNT_TYPE).orEmpty(),
+        accountType = accountType,
         color = getInt(CalendarProjection.IDX_COLOR),
         isVisibleInSystem = getInt(CalendarProjection.IDX_VISIBLE) != 0,
-)
+        canModifyContents = getInt(CalendarProjection.IDX_ACCESS_LEVEL) >=
+            CalendarContract.Calendars.CAL_ACCESS_CONTRIBUTOR,
+        isLocal = isLocal,
+        // CAL_SYNC1 holds the sync token for synced rows, so only treat it as a
+        // user description on the local calendars the app owns.
+        description = if (isLocal) {
+            getString(CalendarProjection.IDX_DESCRIPTION)?.takeIf { it.isNotBlank() }
+        } else {
+            null
+        },
+    )
+}

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

@@ -1,7 +1,9 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+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 kotlinx.coroutines.flow.Flow
 import kotlin.time.Instant
@@ -10,7 +12,61 @@ interface CalendarRepository {
     fun calendars(): Flow<List<CalendarSource>>
     fun instances(range: ClosedRange<Instant>): Flow<List<EventInstance>>
     suspend fun eventDetail(eventId: Long): EventDetail
+
+    /**
+     * The event-colour palette a calendar's account publishes; empty when it
+     * exposes none (see [CalendarDataSource.eventColorPalette]).
+     */
+    suspend fun eventColorPalette(calendarId: Long): List<EventColorOption>
+
+    /** Create a device-only (LOCAL) calendar the app owns; returns its id. */
+    suspend fun createLocalCalendar(displayName: String, color: Int, description: String?): Long
+
+    /** Update name, color and description of a local calendar the app owns. */
+    suspend fun updateCalendar(id: Long, displayName: String, color: Int, description: String?)
+
+    /** Permanently delete a local calendar the app owns, with all its events. */
+    suspend fun deleteCalendar(id: Long)
+
+    /** Create a new event from a validated form; returns the new `Events._ID`. */
+    suspend fun createEvent(form: EventForm): Long
+
+    /**
+     * Update an event (recurring: the whole series) from a validated form.
+     * [original] is the prefilled form, used to write only what changed.
+     */
+    suspend fun updateEvent(eventId: Long, original: EventForm, updated: EventForm)
+
+    /**
+     * Change a single occurrence of a recurring event (exception row with the
+     * form's values); returns the exception's `Events._ID`.
+     */
+    suspend fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long
+
+    /**
+     * Change a recurring event from [beginMillis] onwards (series split);
+     * returns the new event's `Events._ID`.
+     */
+    suspend fun updateEventFromOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        original: EventForm,
+        updated: EventForm,
+    ): Long
+
+    /** Delete the whole event (for recurring events: the entire series). */
+    suspend fun deleteEvent(eventId: Long)
+
+    /** Cancel a single occurrence of a recurring event at its `Instances.BEGIN` time. */
+    suspend fun deleteOccurrence(eventId: Long, beginMillis: Long)
+
+    /** Delete a recurring event from the occurrence at [beginMillis] onwards. */
+    suspend fun deleteEventFromOccurrence(eventId: Long, beginMillis: Long)
 }
 
 class NoSuchEventException(eventId: Long) :
     NoSuchElementException("No event with id=$eventId")
+
+/** A ContentResolver write affected no rows or returned no URI. */
+class WriteFailedException(operation: String) :
+    RuntimeException("Calendar write failed: $operation")

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

@@ -3,7 +3,9 @@ package de.jeanlucmakiola.calendula.data.calendar
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+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 kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
@@ -68,6 +70,71 @@ class CalendarRepositoryImpl @Inject constructor(
     override suspend fun eventDetail(eventId: Long): EventDetail = withContext(io) {
         dataSource.eventDetail(eventId) ?: throw NoSuchEventException(eventId)
     }
+
+    override suspend fun eventColorPalette(calendarId: Long): List<EventColorOption> =
+        withContext(io) { dataSource.eventColorPalette(calendarId) }
+
+    override suspend fun createLocalCalendar(
+        displayName: String,
+        color: Int,
+        description: String?,
+    ): Long = withContext(io) {
+        dataSource.createLocalCalendar(displayName, color, description)
+    }
+
+    override suspend fun updateCalendar(
+        id: Long,
+        displayName: String,
+        color: Int,
+        description: String?,
+    ) = withContext(io) { dataSource.updateCalendar(id, displayName, color, description) }
+
+    override suspend fun deleteCalendar(id: Long) =
+        withContext(io) { dataSource.deleteCalendar(id) }
+
+    override suspend fun createEvent(form: EventForm): Long = withContext(io) {
+        dataSource.insertEvent(form)
+    }
+
+    override suspend fun updateEvent(
+        eventId: Long,
+        original: EventForm,
+        updated: EventForm,
+    ) = withContext(io) {
+        dataSource.updateEvent(eventId, original, updated)
+    }
+
+    override suspend fun deleteEvent(eventId: Long) = withContext(io) {
+        dataSource.deleteEvent(eventId)
+    }
+
+    override suspend fun updateOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        form: EventForm,
+    ): Long = withContext(io) {
+        dataSource.updateOccurrence(eventId, beginMillis, form)
+    }
+
+    override suspend fun updateEventFromOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        original: EventForm,
+        updated: EventForm,
+    ): Long = withContext(io) {
+        dataSource.updateEventFromOccurrence(eventId, beginMillis, original, updated)
+    }
+
+    override suspend fun deleteOccurrence(eventId: Long, beginMillis: Long) = withContext(io) {
+        dataSource.deleteOccurrence(eventId, beginMillis)
+    }
+
+    override suspend fun deleteEventFromOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+    ) = withContext(io) {
+        dataSource.deleteEventFromOccurrence(eventId, beginMillis)
+    }
 }
 
 private fun <T> Flow<Unit>.reQuery(block: suspend () -> T): Flow<T> = flow {

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

@@ -42,14 +42,20 @@ internal fun ColumnReader.toEventDetailCore(
         rawEnd
     }
 
-    val rawTitle = getString(EventDetailProjection.IDX_TITLE)
-    val title = if (rawTitle.isNullOrEmpty()) Fallbacks.UNTITLED_EVENT else rawTitle
+    // Kept raw (no untitled fallback): the detail screen substitutes its own
+    // localized placeholder, and the edit form must prefill the true value.
+    val title = getString(EventDetailProjection.IDX_TITLE).orEmpty()
 
-    val color = if (isNull(EventDetailProjection.IDX_EVENT_COLOR)) {
-        getInt(EventDetailProjection.IDX_CALENDAR_COLOR)
+    // The event's own colour (null = inherits the calendar's) is kept apart
+    // from the resolved display colour: the edit form needs to tell the two
+    // cases apart, while the instance carries the calendar fallback for display.
+    val eventColor = if (isNull(EventDetailProjection.IDX_EVENT_COLOR)) {
+        null
     } else {
         getInt(EventDetailProjection.IDX_EVENT_COLOR)
     }
+    val eventColorKey = getString(EventDetailProjection.IDX_EVENT_COLOR_KEY)
+    val color = eventColor ?: getInt(EventDetailProjection.IDX_CALENDAR_COLOR)
 
     val eventId = getLong(EventDetailProjection.IDX_EVENT_ID)
     val instance = EventInstance(
@@ -86,6 +92,8 @@ internal fun ColumnReader.toEventDetailCore(
         accessLevel = mapAccessLevel(getInt(EventDetailProjection.IDX_ACCESS_LEVEL)),
         eventTimezone = getString(EventDetailProjection.IDX_EVENT_TIMEZONE),
         selfStatus = mapAttendeeStatus(getInt(EventDetailProjection.IDX_SELF_ATTENDEE_STATUS)),
+        eventColor = eventColor,
+        eventColorKey = eventColorKey,
     )
 }
 

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

@@ -0,0 +1,189 @@
+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.EventForm
+import kotlinx.datetime.toJavaLocalDate
+import kotlinx.datetime.toJavaLocalDateTime
+import java.time.Instant
+import java.time.ZoneId
+import java.time.ZoneOffset
+
+/** Provider-ready DTSTART / DTEND / EVENT_TIMEZONE for an event write. */
+internal data class EventWriteTimes(
+    val dtStartMillis: Long,
+    val dtEndMillis: Long,
+    val timezone: String,
+)
+
+/**
+ * All-day events live at UTC midnights with an exclusive DTEND (the
+ * CalendarContract convention — a one-day event ends at the next midnight);
+ * timed events resolve their wall-clock values in [zone].
+ */
+internal fun EventForm.toWriteTimes(zone: ZoneId): EventWriteTimes = if (isAllDay) {
+    EventWriteTimes(
+        dtStartMillis = start.date.toJavaLocalDate()
+            .atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(),
+        dtEndMillis = end.date.toJavaLocalDate().plusDays(1)
+            .atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(),
+        timezone = "UTC",
+    )
+} else {
+    EventWriteTimes(
+        dtStartMillis = start.toJavaLocalDateTime().atZone(zone).toInstant().toEpochMilli(),
+        dtEndMillis = end.toJavaLocalDateTime().atZone(zone).toInstant().toEpochMilli(),
+        timezone = zone.id,
+    )
+}
+
+/**
+ * RFC 2445 duration for a recurring event's row (the provider requires
+ * DURATION instead of DTEND when an RRULE is set): whole days for all-day
+ * events, seconds otherwise.
+ */
+internal fun EventWriteTimes.toRfc2445Duration(isAllDay: Boolean): String = if (isAllDay) {
+    "P${(dtEndMillis - dtStartMillis) / MILLIS_PER_DAY}D"
+} else {
+    "P${(dtEndMillis - dtStartMillis) / 1_000L}S"
+}
+
+/**
+ * Dirty-checked column values for updating an existing Events row: only what
+ * the user actually changed is written, so untouched fields can't stomp
+ * concurrent external edits. Keys are `CalendarContract.Events` columns; a
+ * null value means "set the column to NULL". An empty map means nothing on
+ * the row changed.
+ *
+ * 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;
+ * - recurring result → the *series* DTSTART moves by the same delta the user
+ *   applied to the displayed occurrence ([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.
+ */
+internal fun buildEventUpdateValues(
+    original: EventForm,
+    updated: EventForm,
+    seriesDtStartMillis: Long,
+    zone: ZoneId,
+): Map<String, Any?> = buildMap {
+    if (updated.title.trim() != original.title.trim()) {
+        put(CalendarContract.Events.TITLE, updated.title.trim())
+    }
+    if (updated.location.trim() != original.location.trim()) {
+        put(CalendarContract.Events.EVENT_LOCATION, updated.location.trim().ifEmpty { null })
+    }
+    if (updated.description.trim() != original.description.trim()) {
+        put(CalendarContract.Events.DESCRIPTION, updated.description.trim().ifEmpty { null })
+    }
+    if (updated.availability != original.availability) {
+        put(CalendarContract.Events.AVAILABILITY, updated.availability.toProviderValue())
+    }
+    if (updated.accessLevel != original.accessLevel) {
+        put(CalendarContract.Events.ACCESS_LEVEL, updated.accessLevel.toProviderValue())
+    }
+    if (updated.colorKey != original.colorKey || updated.color != original.color) {
+        putAll(eventColorColumns(updated.colorKey, updated.color))
+    }
+
+    val timesChanged = updated.start != original.start ||
+        updated.end != original.end ||
+        updated.isAllDay != original.isAllDay ||
+        updated.rrule != original.rrule
+    if (!timesChanged) return@buildMap
+
+    val newTimes = updated.toWriteTimes(zone)
+    put(CalendarContract.Events.ALL_DAY, if (updated.isAllDay) 1 else 0)
+    put(CalendarContract.Events.EVENT_TIMEZONE, newTimes.timezone)
+    if (updated.rrule == null) {
+        put(CalendarContract.Events.DTSTART, newTimes.dtStartMillis)
+        put(CalendarContract.Events.DTEND, newTimes.dtEndMillis)
+        put(CalendarContract.Events.RRULE, null)
+        put(CalendarContract.Events.DURATION, null)
+    } else {
+        val startDelta = newTimes.dtStartMillis - original.toWriteTimes(zone).dtStartMillis
+        put(CalendarContract.Events.DTSTART, seriesDtStartMillis + startDelta)
+        put(CalendarContract.Events.DTEND, null)
+        put(CalendarContract.Events.RRULE, updated.rrule)
+        put(CalendarContract.Events.DURATION, newTimes.toRfc2445Duration(updated.isAllDay))
+    }
+}
+
+/**
+ * Column values for a modified-occurrence exception row ("edit only this
+ * event"): inserting them at `Events.CONTENT_EXCEPTION_URI/<id>` makes the
+ * provider clone the series row and apply these on top. Unlike the series
+ * update there is no dirty check — the exception is a fresh row, so every
+ * form-backed column is written (empty optionals as explicit NULLs, since the
+ * clone starts from the parent's values). An exception is a single event:
+ * DTEND, never RRULE/DURATION.
+ */
+internal fun buildOccurrenceExceptionValues(
+    form: EventForm,
+    originalInstanceMillis: Long,
+    zone: ZoneId,
+): Map<String, Any?> = buildMap {
+    val times = form.toWriteTimes(zone)
+    put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, originalInstanceMillis)
+    put(CalendarContract.Events.TITLE, form.title.trim())
+    put(CalendarContract.Events.ALL_DAY, if (form.isAllDay) 1 else 0)
+    put(CalendarContract.Events.DTSTART, times.dtStartMillis)
+    put(CalendarContract.Events.DTEND, times.dtEndMillis)
+    put(CalendarContract.Events.EVENT_TIMEZONE, times.timezone)
+    put(CalendarContract.Events.AVAILABILITY, form.availability.toProviderValue())
+    put(CalendarContract.Events.ACCESS_LEVEL, form.accessLevel.toProviderValue())
+    put(CalendarContract.Events.EVENT_LOCATION, form.location.trim().ifEmpty { null })
+    put(CalendarContract.Events.DESCRIPTION, form.description.trim().ifEmpty { null })
+    putAll(eventColorColumns(form.colorKey, form.color))
+}
+
+/**
+ * The `EVENT_COLOR` / `EVENT_COLOR_KEY` columns for a colour selection. A
+ * [colorKey] writes the key alone (the provider derives `EVENT_COLOR` from the
+ * account's palette, so the colour round-trips through sync); a raw [color]
+ * writes `EVENT_COLOR` and clears any key; "no colour" clears both so the event
+ * falls back to its calendar's colour. The two are never written together —
+ * the provider rejects a raw colour on a calendar that publishes a palette,
+ * which is exactly why palette calendars only ever go through the key.
+ */
+internal fun eventColorColumns(colorKey: String?, color: Int?): Map<String, Any?> = when {
+    colorKey != null -> mapOf(CalendarContract.Events.EVENT_COLOR_KEY to colorKey)
+    color != null -> mapOf(
+        CalendarContract.Events.EVENT_COLOR_KEY to null,
+        CalendarContract.Events.EVENT_COLOR to color,
+    )
+    else -> mapOf(
+        CalendarContract.Events.EVENT_COLOR_KEY to null,
+        CalendarContract.Events.EVENT_COLOR to null,
+    )
+}
+
+/**
+ * UTC millis of the last second of the local day *before* the occurrence at
+ * [beginMillis] in [zone] — the cutoff for truncating a series with UNTIL.
+ * The provider's recurrence engine applies UNTIL coarsely (observed on a
+ * Pixel: an occurrence one second *after* UNTIL was still generated), so the
+ * series must end on the previous day, not one second before the occurrence.
+ * With no sub-daily frequencies that is semantically the same cut.
+ */
+internal fun previousLocalDayEndUtcMillis(beginMillis: Long, zone: ZoneId): Long =
+    Instant.ofEpochMilli(beginMillis).atZone(zone).toLocalDate()
+        .atStartOfDay(zone).toInstant().toEpochMilli() - 1_000L
+
+private const val MILLIS_PER_DAY = 86_400_000L
+
+internal fun Availability.toProviderValue(): Int = when (this) {
+    Availability.Busy -> CalendarContract.Events.AVAILABILITY_BUSY
+    Availability.Free -> CalendarContract.Events.AVAILABILITY_FREE
+    Availability.Tentative -> CalendarContract.Events.AVAILABILITY_TENTATIVE
+}
+
+internal fun AccessLevel.toProviderValue(): Int = when (this) {
+    AccessLevel.Default -> CalendarContract.Events.ACCESS_DEFAULT
+    AccessLevel.Confidential -> CalendarContract.Events.ACCESS_CONFIDENTIAL
+    AccessLevel.Private -> CalendarContract.Events.ACCESS_PRIVATE
+    AccessLevel.Public -> CalendarContract.Events.ACCESS_PUBLIC
+}

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

@@ -10,14 +10,23 @@ internal object CalendarProjection {
         CalendarContract.Calendars.ACCOUNT_TYPE,
         CalendarContract.Calendars.CALENDAR_COLOR,
         CalendarContract.Calendars.VISIBLE,
+        CalendarContract.Calendars.CALENDAR_ACCESS_LEVEL,
+        // CalendarContract has no description column; for the local calendars we
+        // own we stash one in CAL_SYNC1 (synced rows put their sync token here,
+        // so the mapper only reads it for local calendars).
+        DESCRIPTION_COLUMN,
     )
 
+    const val DESCRIPTION_COLUMN: String = CalendarContract.Calendars.CAL_SYNC1
+
     const val IDX_ID = 0
     const val IDX_DISPLAY_NAME = 1
     const val IDX_ACCOUNT_NAME = 2
     const val IDX_ACCOUNT_TYPE = 3
     const val IDX_COLOR = 4
     const val IDX_VISIBLE = 5
+    const val IDX_ACCESS_LEVEL = 6
+    const val IDX_DESCRIPTION = 7
 }
 
 internal object InstanceProjection {
@@ -65,6 +74,7 @@ internal object EventDetailProjection {
         CalendarContract.Events.ACCESS_LEVEL,
         CalendarContract.Events.EVENT_TIMEZONE,
         CalendarContract.Events.SELF_ATTENDEE_STATUS,
+        CalendarContract.Events.EVENT_COLOR_KEY,
     )
 
     const val IDX_EVENT_ID = 0
@@ -84,6 +94,7 @@ internal object EventDetailProjection {
     const val IDX_ACCESS_LEVEL = 14
     const val IDX_EVENT_TIMEZONE = 15
     const val IDX_SELF_ATTENDEE_STATUS = 16
+    const val IDX_EVENT_COLOR_KEY = 17
 }
 
 internal object AttendeeProjection {

app/src/main/java/de/jeanlucmakiola/calendula/data/di/DataModule.kt

@@ -14,6 +14,8 @@ import de.jeanlucmakiola.calendula.data.calendar.AndroidCalendarDataSource
 import de.jeanlucmakiola.calendula.data.calendar.CalendarDataSource
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepositoryImpl
+import de.jeanlucmakiola.calendula.data.reminders.AndroidReminderAlertStore
+import de.jeanlucmakiola.calendula.data.reminders.ReminderAlertStore
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import javax.inject.Singleton
@@ -37,6 +39,12 @@ abstract class DataBindModule {
     abstract fun bindCalendarRepository(
         impl: CalendarRepositoryImpl,
     ): CalendarRepository
+
+    @Binds
+    @Singleton
+    abstract fun bindReminderAlertStore(
+        impl: AndroidReminderAlertStore,
+    ): ReminderAlertStore
 }
 
 @Module

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

@@ -3,6 +3,7 @@ package de.jeanlucmakiola.calendula.data.prefs
 import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.longPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
@@ -38,7 +39,20 @@ class CalendarPrefs @Inject constructor(
         }
     }
 
+    /**
+     * The calendar the user last created an event in; preselected in the
+     * event form. Null until the first event is created.
+     */
+    val lastUsedCalendarId: Flow<Long?> = store.data.map { prefs ->
+        prefs[LAST_USED_CALENDAR_KEY]
+    }
+
+    suspend fun setLastUsedCalendarId(id: Long) {
+        store.edit { prefs -> prefs[LAST_USED_CALENDAR_KEY] = id }
+    }
+
     companion object {
         internal val HIDDEN_IDS_KEY = stringPreferencesKey("hidden_calendar_ids")
+        internal val LAST_USED_CALENDAR_KEY = longPreferencesKey("last_used_calendar_id")
     }
 }

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

@@ -5,6 +5,7 @@ import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.stringPreferencesKey
+import de.jeanlucmakiola.calendula.domain.EventFormField
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import kotlinx.datetime.DayOfWeek
@@ -67,10 +68,83 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[WEEK_START_KEY] = pref.name }
     }
 
+    /**
+     * Optional event-form fields shown by default (the rest hide behind
+     * "more fields"). Stored comma-joined by enum name: an absent key means
+     * the factory default, an empty string means "none". Unknown names are
+     * dropped defensively, like the other enum prefs.
+     */
+    val defaultFormFields: Flow<Set<EventFormField>> = store.data.map { prefs ->
+        parseFormFields(prefs[FORM_FIELDS_KEY])
+    }
+
+    suspend fun setFormFieldDefault(field: EventFormField, enabled: Boolean) {
+        store.edit { prefs ->
+            val current = parseFormFields(prefs[FORM_FIELDS_KEY])
+            val updated = if (enabled) current + field else current - field
+            prefs[FORM_FIELDS_KEY] = updated.joinToString(",") { it.name }
+        }
+    }
+
+    /**
+     * Whether Calendula posts reminder notifications (v1.4). Defaults to ON —
+     * for users whose only calendar app this is, reminders are essential; the
+     * onboarding step and Settings warn about duplicates from a second app.
+     */
+    val remindersEnabled: Flow<Boolean> = store.data.map { prefs ->
+        prefs[REMINDERS_ENABLED_KEY] ?: true
+    }
+
+    suspend fun setRemindersEnabled(enabled: Boolean) {
+        store.edit { it[REMINDERS_ENABLED_KEY] = enabled }
+    }
+
+    /**
+     * Whether to offer a custom event colour even on calendars that publish no
+     * colour palette (most local calendars handle it fine; synced calendars
+     * without a palette — some CalDAV — may drop or overwrite a raw colour on
+     * their next sync). Defaults to OFF: such calendars hide the colour picker
+     * until the user opts in, accepting the limitation. Local calendars and
+     * palette-backed calendars (Google, …) are unaffected by this flag.
+     */
+    val allowColorOnUnsupportedCalendars: Flow<Boolean> = store.data.map { prefs ->
+        prefs[ALLOW_COLOR_UNSUPPORTED_KEY] ?: false
+    }
+
+    suspend fun setAllowColorOnUnsupportedCalendars(enabled: Boolean) {
+        store.edit { it[ALLOW_COLOR_UNSUPPORTED_KEY] = enabled }
+    }
+
+    /**
+     * Whether the one-time reminder onboarding step (after the calendar
+     * grant) has been shown — also true for users who tapped "not now".
+     */
+    val reminderOnboardingDone: Flow<Boolean> = store.data.map { prefs ->
+        prefs[REMINDER_ONBOARDING_KEY] ?: false
+    }
+
+    suspend fun setReminderOnboardingDone() {
+        store.edit { it[REMINDER_ONBOARDING_KEY] = true }
+    }
+
+    private fun parseFormFields(stored: String?): Set<EventFormField> = when (stored) {
+        null -> DEFAULT_FORM_FIELDS
+        else -> stored.split(',')
+            .mapNotNull { name -> EventFormField.entries.firstOrNull { it.name == name.trim() } }
+            .toSet()
+    }
+
     companion object {
         internal val THEME_MODE_KEY = stringPreferencesKey("theme_mode")
         internal val DYNAMIC_COLOR_KEY = booleanPreferencesKey("dynamic_color")
         internal val WEEK_START_KEY = stringPreferencesKey("week_start")
+        internal val FORM_FIELDS_KEY = stringPreferencesKey("event_form_default_fields")
+        internal val REMINDERS_ENABLED_KEY = booleanPreferencesKey("reminders_enabled")
+        internal val REMINDER_ONBOARDING_KEY = booleanPreferencesKey("reminder_onboarding_done")
+        internal val ALLOW_COLOR_UNSUPPORTED_KEY =
+            booleanPreferencesKey("allow_color_unsupported_calendars")
+        internal val DEFAULT_FORM_FIELDS =
+            setOf(EventFormField.Location, EventFormField.Description)
     }
 }
 

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

@@ -0,0 +1,57 @@
+package de.jeanlucmakiola.calendula.data.reminders
+
+import android.Manifest
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.provider.CalendarContract
+import androidx.core.content.ContextCompat
+import dagger.hilt.android.AndroidEntryPoint
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+/**
+ * Becomes the app that turns the calendar provider's reminder alarms into
+ * visible notifications (the Etar model — the provider broadcasts
+ * `EVENT_REMINDER` at reminder time but posts nothing itself).
+ *
+ * The broadcast's data URI only carries the alarm time, so it is ignored:
+ * we query every still-scheduled, due `CalendarAlerts` row ourselves, post
+ * them, and mark them fired. Posting happens before marking — a crash in
+ * between re-posts silently (same tag) rather than losing the reminder.
+ */
+@AndroidEntryPoint
+class EventReminderReceiver : BroadcastReceiver() {
+
+    @Inject lateinit var alertStore: ReminderAlertStore
+    @Inject lateinit var notifier: ReminderNotifier
+    @Inject lateinit var settingsPrefs: SettingsPrefs
+
+    override fun onReceive(context: Context, intent: Intent) {
+        if (intent.action != CalendarContract.ACTION_EVENT_REMINDER) return
+        val readGranted = ContextCompat.checkSelfPermission(
+            context, Manifest.permission.READ_CALENDAR,
+        ) == PackageManager.PERMISSION_GRANTED
+        if (!readGranted || !notifier.canPost()) return
+
+        val pendingResult = goAsync()
+        CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
+            try {
+                if (settingsPrefs.remindersEnabled.first()) {
+                    val now = System.currentTimeMillis()
+                    val due = alertStore.dueAlerts(now)
+                    due.forEach(notifier::post)
+                    alertStore.markFired(due.map { it.alertId }, now)
+                }
+            } finally {
+                pendingResult.finish()
+            }
+        }
+    }
+}

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

@@ -0,0 +1,112 @@
+package de.jeanlucmakiola.calendula.data.reminders
+
+import android.content.ContentValues
+import android.content.Context
+import android.provider.CalendarContract
+import android.util.Log
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * One due row of the provider's `CalendarAlerts` table (a join with Events).
+ * Stays in the data layer: alerts feed the notification path only and never
+ * reach a screen, so there is no domain model for them.
+ */
+data class ReminderAlert(
+    val alertId: Long,
+    val eventId: Long,
+    val beginMillis: Long,
+    val endMillis: Long,
+    /** Raw event title; may be blank — the notifier substitutes "(no title)". */
+    val title: String,
+    val location: String?,
+    val isAllDay: Boolean,
+)
+
+/**
+ * Seam over the `CalendarAlerts` table so the receiver logic can be exercised
+ * without a ContentResolver. The provider creates these rows itself — only
+ * for `METHOD_ALERT` reminders (verified in AOSP `CalendarAlarmManager`), so
+ * email reminders never show up here.
+ */
+interface ReminderAlertStore {
+
+    /** Alerts that are due (`ALARM_TIME` has passed) and still unhandled. */
+    fun dueAlerts(nowMillis: Long): List<ReminderAlert>
+
+    /**
+     * Mark the given alerts handled (`STATE_FIRED`) so a later broadcast does
+     * not surface them again. Best effort: this write needs `WRITE_CALENDAR`,
+     * which the user may have declined — then re-broadcasts silently replace
+     * the already-posted notifications instead (same tag, alert-once).
+     */
+    fun markFired(alertIds: List<Long>, nowMillis: Long)
+}
+
+@Singleton
+class AndroidReminderAlertStore @Inject constructor(
+    @ApplicationContext private val context: Context,
+) : ReminderAlertStore {
+
+    override fun dueAlerts(nowMillis: Long): List<ReminderAlert> = context.contentResolver.query(
+        CalendarContract.CalendarAlerts.CONTENT_URI,
+        PROJECTION,
+        CalendarContract.CalendarAlerts.STATE + " = ? AND " +
+            CalendarContract.CalendarAlerts.ALARM_TIME + " <= ?",
+        arrayOf(
+            CalendarContract.CalendarAlerts.STATE_SCHEDULED.toString(),
+            nowMillis.toString(),
+        ),
+        CalendarContract.CalendarAlerts.BEGIN + " ASC",
+    )?.use { c ->
+        buildList {
+            while (c.moveToNext()) {
+                add(
+                    ReminderAlert(
+                        alertId = c.getLong(0),
+                        eventId = c.getLong(1),
+                        beginMillis = c.getLong(2),
+                        endMillis = c.getLong(3),
+                        title = c.getString(4).orEmpty(),
+                        location = c.getString(5)?.takeIf { it.isNotBlank() },
+                        isAllDay = c.getInt(6) == 1,
+                    ),
+                )
+            }
+        }
+    } ?: emptyList()
+
+    override fun markFired(alertIds: List<Long>, nowMillis: Long) {
+        if (alertIds.isEmpty()) return
+        val values = ContentValues().apply {
+            put(CalendarContract.CalendarAlerts.STATE, CalendarContract.CalendarAlerts.STATE_FIRED)
+            put(CalendarContract.CalendarAlerts.RECEIVED_TIME, nowMillis)
+            put(CalendarContract.CalendarAlerts.NOTIFY_TIME, nowMillis)
+        }
+        try {
+            context.contentResolver.update(
+                CalendarContract.CalendarAlerts.CONTENT_URI,
+                values,
+                CalendarContract.CalendarAlerts._ID +
+                    " IN (" + alertIds.joinToString(",") + ")",
+                null,
+            )
+        } catch (e: SecurityException) {
+            Log.w(TAG, "Cannot mark alerts fired without WRITE_CALENDAR", e)
+        }
+    }
+
+    private companion object {
+        const val TAG = "ReminderAlertStore"
+        val PROJECTION = arrayOf(
+            CalendarContract.CalendarAlerts._ID,
+            CalendarContract.CalendarAlerts.EVENT_ID,
+            CalendarContract.CalendarAlerts.BEGIN,
+            CalendarContract.CalendarAlerts.END,
+            CalendarContract.CalendarAlerts.TITLE,
+            CalendarContract.CalendarAlerts.EVENT_LOCATION,
+            CalendarContract.CalendarAlerts.ALL_DAY,
+        )
+    }
+}

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

@@ -0,0 +1,101 @@
+package de.jeanlucmakiola.calendula.data.reminders
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
+import dagger.hilt.android.qualifiers.ApplicationContext
+import de.jeanlucmakiola.calendula.MainActivity
+import de.jeanlucmakiola.calendula.R
+import java.time.ZoneId
+import java.util.Locale
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Posts one notification per due reminder alert on a dedicated channel.
+ * Tapping opens the event's detail screen; the tag is the alert id, so a
+ * re-broadcast of an alert we couldn't mark fired replaces its notification
+ * silently ([NotificationCompat.Builder.setOnlyAlertOnce]) instead of
+ * duplicating it.
+ */
+@Singleton
+class ReminderNotifier @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+
+    /** False when the user declined `POST_NOTIFICATIONS` or muted the app. */
+    fun canPost(): Boolean {
+        val granted = Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
+            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) ==
+            PackageManager.PERMISSION_GRANTED
+        return granted && NotificationManagerCompat.from(context).areNotificationsEnabled()
+    }
+
+    fun post(alert: ReminderAlert) {
+        ensureChannel()
+        val title = alert.title.ifBlank { context.getString(R.string.event_untitled) }
+        val time = reminderTimeText(
+            beginMillis = alert.beginMillis,
+            endMillis = alert.endMillis,
+            isAllDay = alert.isAllDay,
+            zone = ZoneId.systemDefault(),
+            locale = Locale.getDefault(),
+        )
+        val text = listOfNotNull(time, alert.location).joinToString(" · ")
+        val notification = NotificationCompat.Builder(context, CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_notification)
+            .setContentTitle(title)
+            .setContentText(text)
+            .setWhen(alert.beginMillis)
+            .setShowWhen(false)
+            .setCategory(NotificationCompat.CATEGORY_EVENT)
+            .setPriority(NotificationCompat.PRIORITY_HIGH)
+            .setAutoCancel(true)
+            .setOnlyAlertOnce(true)
+            .setContentIntent(detailIntent(alert))
+            .build()
+        try {
+            NotificationManagerCompat.from(context)
+                .notify(alert.alertId.toString(), NOTIFICATION_ID, notification)
+        } catch (e: SecurityException) {
+            // POST_NOTIFICATIONS was revoked between canPost() and here.
+            Log.w(TAG, "Could not post reminder for event ${alert.eventId}", e)
+        }
+    }
+
+    private fun detailIntent(alert: ReminderAlert): PendingIntent = PendingIntent.getActivity(
+        context,
+        /* requestCode = */ alert.alertId.toInt(),
+        MainActivity.eventDetailIntent(context, alert.eventId, alert.beginMillis, alert.endMillis),
+        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+    )
+
+    /** Channel creation is idempotent; re-running refreshes the localized name. */
+    private fun ensureChannel() {
+        val channel = NotificationChannel(
+            CHANNEL_ID,
+            context.getString(R.string.reminder_channel_name),
+            NotificationManager.IMPORTANCE_HIGH,
+        ).apply {
+            description = context.getString(R.string.reminder_channel_description)
+        }
+        NotificationManagerCompat.from(context).createNotificationChannel(channel)
+    }
+
+    private companion object {
+        const val TAG = "ReminderNotifier"
+        const val CHANNEL_ID = "reminders"
+
+        // One id, distinct tags: the tag (alert id) already keys the
+        // notification, so a fixed id keeps cancellation/replacement simple.
+        const val NOTIFICATION_ID = 1
+    }
+}

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

@@ -0,0 +1,56 @@
+package de.jeanlucmakiola.calendula.data.reminders
+
+import java.time.Instant
+import java.time.ZoneId
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
+import java.time.format.FormatStyle
+import java.util.Locale
+
+/**
+ * The one line of time context in a reminder notification. Pure so it can be
+ * JVM-tested:
+ *
+ * - timed, same day:      "09:30 – 10:00"
+ * - timed, crossing days: "11 Jun, 23:30 – 12 Jun, 00:30" (medium date + short time)
+ * - all-day, one day:     "11 Jun 2026"
+ * - all-day, multi-day:   "11 Jun 2026 – 12 Jun 2026"
+ *
+ * All-day instances store UTC midnights with an exclusive end, so they are
+ * read in UTC and the end day is the last *covered* day.
+ */
+fun reminderTimeText(
+    beginMillis: Long,
+    endMillis: Long,
+    isAllDay: Boolean,
+    zone: ZoneId,
+    locale: Locale,
+): String {
+    if (isAllDay) {
+        val dateFormat = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
+        // (atZone().toLocalDate() instead of LocalDate.ofInstant — API 34+)
+        val firstDay = Instant.ofEpochMilli(beginMillis).atZone(ZoneOffset.UTC).toLocalDate()
+        val lastDay = Instant.ofEpochMilli(endMillis).atZone(ZoneOffset.UTC).toLocalDate()
+            .minusDays(1)
+            .coerceAtLeast(firstDay)
+        return if (lastDay == firstDay) {
+            dateFormat.format(firstDay)
+        } else {
+            dateFormat.format(firstDay) + RANGE + dateFormat.format(lastDay)
+        }
+    }
+
+    val timeFormat = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
+    val begin = Instant.ofEpochMilli(beginMillis).atZone(zone)
+    val end = Instant.ofEpochMilli(endMillis).atZone(zone)
+    return if (begin.toLocalDate() == end.toLocalDate()) {
+        timeFormat.format(begin) + RANGE + timeFormat.format(end)
+    } else {
+        val dateTimeFormat = DateTimeFormatter
+            .ofLocalizedDateTime(FormatStyle.MEDIUM, FormatStyle.SHORT)
+            .withLocale(locale)
+        dateTimeFormat.format(begin) + RANGE + dateTimeFormat.format(end)
+    }
+}
+
+private const val RANGE = " – "

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

@@ -0,0 +1,163 @@
+package de.jeanlucmakiola.calendula.domain
+
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
+
+/**
+ * User input for creating an event (and, from v1.3, editing one). Times are
+ * wall-clock values in the device zone; the data layer translates them to
+ * provider millis (all-day events normalise to UTC midnights there).
+ */
+data class EventForm(
+    val calendarId: Long?,
+    val title: String = "",
+    val isAllDay: Boolean = false,
+    val start: LocalDateTime,
+    val end: LocalDateTime,
+    val location: String = "",
+    val description: String = "",
+    /** Reminder lead times in minutes before the start, deduplicated. */
+    val reminders: List<Int> = emptyList(),
+    val availability: Availability = Availability.Busy,
+    val accessLevel: AccessLevel = AccessLevel.Default,
+    /**
+     * Bare RRULE value (`Events.RRULE` convention, no "RRULE:" prefix); null
+     * means a one-off event. May hold rules the simple picker can't express —
+     * those are kept verbatim until the user picks something else.
+     */
+    val rrule: String? = null,
+    /**
+     * The event's own colour, or null to inherit the calendar's colour.
+     * [colorKey] is a `Colors.COLOR_KEY` from the calendar account's published
+     * event palette (Google, some CalDAV) — written as `EVENT_COLOR_KEY` so it
+     * round-trips through sync. When it is null but [color] is set, [color] is
+     * a raw ARGB written as `EVENT_COLOR` (local calendars, or synced ones the
+     * user opted into despite no palette). [color] mirrors the key's swatch when
+     * [colorKey] is set, so the picker can highlight it.
+     */
+    val colorKey: String? = null,
+    val color: Int? = null,
+)
+
+/**
+ * The form's optional sections. Which ones show by default is a user setting;
+ * the rest unfold behind a "more fields" button.
+ */
+enum class EventFormField {
+    Location,
+    Description,
+    Reminders,
+    Recurrence,
+    Availability,
+    Visibility,
+    Color,
+}
+
+enum class EventFormProblem {
+    /** No target calendar — none picked and no writable calendar exists. */
+    NoCalendar,
+    EndBeforeStart,
+    /** The recurrence's UNTIL date lies before the event's first day. */
+    RecurrenceEndsBeforeStart,
+}
+
+/**
+ * Validation; an empty set means the form can be saved. A blank title is
+ * allowed (display falls back to "(No title)", matching the provider), and a
+ * zero-length timed event is allowed (spec §8: instant events exist).
+ */
+/**
+ * Prefill the edit form from a loaded event. [beginMillis]/[endMillis] are the
+ * tapped occurrence's own times (`Instances.BEGIN`/`END`), not the series
+ * start — the data layer later turns a time edit into a delta on the series.
+ *
+ * All-day provider times are UTC midnights with an exclusive end; the form
+ * shows the last covered day and keeps placeholder wall-clock times in case
+ * the user switches the event to timed.
+ */
+fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone): EventForm {
+    val (start, end) = if (instance.isAllDay) {
+        val startDate = Instant.fromEpochMilliseconds(beginMillis)
+            .toLocalDateTime(TimeZone.UTC).date
+        val endExclusive = Instant.fromEpochMilliseconds(endMillis)
+            .toLocalDateTime(TimeZone.UTC).date
+        val endDate = maxOf(startDate, LocalDate.fromEpochDays(endExclusive.toEpochDays() - 1))
+        LocalDateTime(startDate, LocalTime(9, 0)) to LocalDateTime(endDate, LocalTime(10, 0))
+    } else {
+        Instant.fromEpochMilliseconds(beginMillis).toLocalDateTime(zone) to
+            Instant.fromEpochMilliseconds(endMillis).toLocalDateTime(zone)
+    }
+    return EventForm(
+        calendarId = instance.calendarId,
+        title = instance.title,
+        isAllDay = instance.isAllDay,
+        start = start,
+        end = end,
+        location = instance.location.orEmpty(),
+        description = description.orEmpty(),
+        reminders = reminders.map { it.minutes }.distinct().sorted(),
+        availability = availability,
+        accessLevel = accessLevel,
+        rrule = rrule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
+        // The provider fills EVENT_COLOR from the key, so [color] is the
+        // swatch either way; a null colour means the event inherits its
+        // calendar's colour.
+        colorKey = eventColorKey,
+        color = eventColor,
+    )
+}
+
+/**
+ * What the edit form saw when it loaded — compared against a fresh read at
+ * save time to detect external changes (sync, another device) that landed
+ * while the form was open. The raw row times ride along because
+ * [toEditForm] derives the form's times from the *tapped occurrence*, so
+ * re-deriving with the same occurrence would mask an externally moved
+ * event. Not covered (the form can't write them, and the dirty-checked
+ * write can't clobber them): attendees, status, the user's own response,
+ * reminder methods, and a recurring event's duration.
+ */
+data class EditSnapshot(
+    val form: EventForm,
+    /** The raw Events-row times (for recurring events: the series anchor). */
+    val rowStart: Instant,
+    val rowEnd: Instant,
+)
+
+fun EventDetail.toEditSnapshot(beginMillis: Long, endMillis: Long, zone: TimeZone): EditSnapshot =
+    EditSnapshot(
+        form = toEditForm(beginMillis, endMillis, zone),
+        rowStart = instance.start,
+        rowEnd = instance.end,
+    )
+
+/**
+ * The optional sections that hold a value in [form] — when editing, these
+ * must be visible regardless of the user's default-fields setting, or the
+ * data they carry would be invisible (though still preserved).
+ */
+fun EventForm.populatedFields(): Set<EventFormField> = buildSet {
+    if (location.isNotBlank()) add(EventFormField.Location)
+    if (description.isNotBlank()) add(EventFormField.Description)
+    if (reminders.isNotEmpty()) add(EventFormField.Reminders)
+    if (rrule != null) add(EventFormField.Recurrence)
+    if (availability != Availability.Busy) add(EventFormField.Availability)
+    if (accessLevel != AccessLevel.Default) add(EventFormField.Visibility)
+    if (colorKey != null || color != null) add(EventFormField.Color)
+}
+
+fun EventForm.problems(): Set<EventFormProblem> = buildSet {
+    if (calendarId == null) add(EventFormProblem.NoCalendar)
+    val endsTooEarly = if (isAllDay) end.date < start.date else end < start
+    if (endsTooEarly) add(EventFormProblem.EndBeforeStart)
+    // An UNTIL before the first day would make the provider generate zero
+    // occurrences — the event would silently vanish from every view.
+    val recurrenceEnd = rrule?.let(::parseSimpleRecurrence)?.end
+    if (recurrenceEnd is RecurrenceEnd.Until && recurrenceEnd.date < start.date) {
+        add(EventFormProblem.RecurrenceEndsBeforeStart)
+    }
+}

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

@@ -9,6 +9,23 @@ data class CalendarSource(
     val accountType: String,
     val color: Int,
     val isVisibleInSystem: Boolean,
+    /**
+     * Whether events in this calendar can be created/edited/deleted
+     * (`Calendars.CALENDAR_ACCESS_LEVEL` >= contributor). False for WebCal
+     * subscriptions, birthday calendars and other read-only sources.
+     */
+    val canModifyContents: Boolean = false,
+    /**
+     * A device-only calendar the app itself owns (`ACCOUNT_TYPE_LOCAL`): it has
+     * no sync backend, so the app can rename / recolor / delete it. Synced
+     * calendars (Google, DAVx5, …) are managed in their own source app instead.
+     */
+    val isLocal: Boolean = false,
+    /**
+     * Free-text note for a local calendar (stored in `CAL_SYNC1`, which the app
+     * owns for its own calendars). Always null for synced calendars.
+     */
+    val description: String? = null,
 )
 
 data class EventInstance(
@@ -41,8 +58,25 @@ data class EventDetail(
     val eventTimezone: String? = null,
     /** This device user's own response (`Events.SELF_ATTENDEE_STATUS`). */
     val selfStatus: AttendeeStatus = AttendeeStatus.Unknown,
+    /**
+     * The event's own raw colour (`Events.EVENT_COLOR`), null when the event
+     * inherits its calendar's colour. Unlike [EventInstance.color] (which
+     * already folds in the calendar fallback for display) this stays null so
+     * the edit form can tell "has own colour" from "inherits".
+     */
+    val eventColor: Int? = null,
+    /** The event's `Events.EVENT_COLOR_KEY` (a calendar-palette key), or null. */
+    val eventColorKey: String? = null,
 )
 
+/**
+ * One selectable event colour published by a calendar's account
+ * (`CalendarContract.Colors`, `TYPE_EVENT`): [key] is the account-scoped
+ * `COLOR_KEY` written as `EVENT_COLOR_KEY` (so the colour survives sync),
+ * [argb] is the swatch it renders as.
+ */
+data class EventColorOption(val key: String, val argb: Int)
+
 data class Attendee(
     val name: String,
     val email: String?,
@@ -109,6 +143,16 @@ enum class AccessLevel {
     Confidential,
 }
 
+/**
+ * How far a write to a recurring event reaches. Non-recurring events always
+ * use [AllEvents] (there is only one).
+ */
+enum class RecurringWriteScope {
+    ThisEvent,
+    ThisAndFollowing,
+    AllEvents,
+}
+
 enum class FailureReason {
     PermissionRevoked,
     NoCalendarsConfigured,

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

@@ -0,0 +1,197 @@
+package de.jeanlucmakiola.calendula.domain
+
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.isoDayNumber
+import kotlinx.datetime.number
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
+
+/**
+ * The recurrence shapes the simple picker can express (v1.3): a frequency,
+ * an interval, weekly weekday picks, and an optional end. Anything beyond
+ * that (ordinal BYDAY like "2TH", BYMONTHDAY, EXDATE rules, …) stays a raw
+ * RRULE string the picker shows as "custom" and leaves untouched unless the
+ * user replaces it.
+ */
+data class SimpleRecurrence(
+    val freq: RecurrenceFreq,
+    val interval: Int = 1,
+    val end: RecurrenceEnd = RecurrenceEnd.Never,
+    /**
+     * Weekly only: the weekdays the rule fires on (RRULE BYDAY). Empty means
+     * no BYDAY part — the provider derives the day from DTSTART.
+     */
+    val byDays: Set<DayOfWeek> = emptySet(),
+)
+
+enum class RecurrenceFreq {
+    Daily,
+    Weekly,
+    Monthly,
+    Yearly,
+}
+
+sealed interface RecurrenceEnd {
+    data object Never : RecurrenceEnd
+
+    /** Last day on which an occurrence may fall (inclusive). */
+    data class Until(val date: LocalDate) : RecurrenceEnd
+
+    /** Total number of occurrences, counting the first. */
+    data class Count(val times: Int) : RecurrenceEnd
+}
+
+/**
+ * Parse an RRULE into the picker's simple shape, or null when the rule uses
+ * parts the picker can't represent (so the UI preserves the original string).
+ * Accepts an optional leading "RRULE:" and an ignored WKST part. A datetime
+ * UNTIL is converted from UTC into [zone] before its date is taken, mirroring
+ * [toRRule].
+ */
+fun parseSimpleRecurrence(
+    rrule: String,
+    zone: TimeZone = TimeZone.currentSystemDefault(),
+): SimpleRecurrence? {
+    val parts = rrule.removePrefix("RRULE:").split(';')
+        .filter { it.isNotBlank() }
+        .associate { token ->
+            val eq = token.indexOf('=')
+            if (eq <= 0) return null
+            token.substring(0, eq).uppercase() to token.substring(eq + 1)
+        }
+    if (parts.keys.any { it !in setOf("FREQ", "INTERVAL", "UNTIL", "COUNT", "WKST", "BYDAY") }) {
+        return null
+    }
+
+    val freq = when (parts["FREQ"]?.uppercase()) {
+        "DAILY" -> RecurrenceFreq.Daily
+        "WEEKLY" -> RecurrenceFreq.Weekly
+        "MONTHLY" -> RecurrenceFreq.Monthly
+        "YEARLY" -> RecurrenceFreq.Yearly
+        else -> return null
+    }
+    val interval = parts["INTERVAL"]?.let { it.toIntOrNull()?.takeIf { n -> n >= 1 } ?: return null } ?: 1
+
+    // BYDAY is simple only as plain weekday picks on a weekly rule; ordinal
+    // forms ("2TH" = second Thursday) and BYDAY on other frequencies are not.
+    val byDays = parts["BYDAY"]?.let { raw ->
+        if (freq != RecurrenceFreq.Weekly) return null
+        raw.split(',').map { token -> rruleDay(token.trim()) ?: return null }.toSet()
+    } ?: emptySet()
+
+    val until = parts["UNTIL"]
+    val count = parts["COUNT"]
+    if (until != null && count != null) return null
+    val end = when {
+        until != null -> RecurrenceEnd.Until(parseUntilDate(until, zone) ?: return null)
+        count != null -> RecurrenceEnd.Count(count.toIntOrNull()?.takeIf { it >= 1 } ?: return null)
+        else -> RecurrenceEnd.Never
+    }
+    return SimpleRecurrence(freq, interval, end, byDays)
+}
+
+/**
+ * Render as a provider-ready RRULE value (no "RRULE:" prefix —
+ * `CalendarContract.Events.RRULE` stores the bare value). UNTIL is written as
+ * the end of the chosen day *in [zone]*, expressed in UTC: the recurrence
+ * engine has been observed applying UNTIL coarsely after converting it into
+ * the event's timezone, so a plain `T235959Z` can leak one extra day for
+ * zones ahead of UTC.
+ */
+fun SimpleRecurrence.toRRule(zone: TimeZone = TimeZone.currentSystemDefault()): String = buildString {
+    append("FREQ=")
+    append(
+        when (freq) {
+            RecurrenceFreq.Daily -> "DAILY"
+            RecurrenceFreq.Weekly -> "WEEKLY"
+            RecurrenceFreq.Monthly -> "MONTHLY"
+            RecurrenceFreq.Yearly -> "YEARLY"
+        },
+    )
+    if (interval > 1) append(";INTERVAL=$interval")
+    if (freq == RecurrenceFreq.Weekly && byDays.isNotEmpty()) {
+        append(";BYDAY=")
+        append(
+            byDays.sortedBy { it.isoDayNumber }
+                .joinToString(",") { RRULE_DAY_CODES.getValue(it) },
+        )
+    }
+    when (val e = end) {
+        RecurrenceEnd.Never -> Unit
+        is RecurrenceEnd.Until -> {
+            val utc = LocalDateTime(e.date, LocalTime(23, 59, 59))
+                .toInstant(zone)
+                .toLocalDateTime(TimeZone.UTC)
+            append(
+                ";UNTIL=%04d%02d%02dT%02d%02d%02dZ".format(
+                    utc.year, utc.month.number, utc.day,
+                    utc.hour, utc.minute, utc.second,
+                ),
+            )
+        }
+        is RecurrenceEnd.Count -> append(";COUNT=${e.times}")
+    }
+}
+
+private val RRULE_DAY_CODES: Map<DayOfWeek, String> = mapOf(
+    DayOfWeek.MONDAY to "MO",
+    DayOfWeek.TUESDAY to "TU",
+    DayOfWeek.WEDNESDAY to "WE",
+    DayOfWeek.THURSDAY to "TH",
+    DayOfWeek.FRIDAY to "FR",
+    DayOfWeek.SATURDAY to "SA",
+    DayOfWeek.SUNDAY to "SU",
+)
+
+/** Exact two-letter BYDAY token → weekday; ordinal forms ("2TH") return null. */
+private fun rruleDay(token: String): DayOfWeek? =
+    RRULE_DAY_CODES.entries.firstOrNull { it.value == token.uppercase() }?.key
+
+/**
+ * End an arbitrary RRULE (simple or not) at [untilUtcMillis]: any existing
+ * UNTIL/COUNT is dropped, every other part (BYDAY, INTERVAL, …) survives.
+ * Used for "delete this and all following occurrences" — the caller passes a
+ * moment just before the first occurrence to remove.
+ */
+fun rruleTruncatedAt(rrule: String, untilUtcMillis: Long): String {
+    val kept = rrule.removePrefix("RRULE:").split(';')
+        .filter { it.isNotBlank() }
+        .filterNot { part ->
+            val key = part.substringBefore('=').trim().uppercase()
+            key == "UNTIL" || key == "COUNT"
+        }
+    val until = Instant.fromEpochMilliseconds(untilUtcMillis).toLocalDateTime(TimeZone.UTC)
+    val untilPart = "UNTIL=%04d%02d%02dT%02d%02d%02dZ".format(
+        until.year, until.month.number, until.day,
+        until.hour, until.minute, until.second,
+    )
+    return (kept + untilPart).joinToString(";")
+}
+
+/**
+ * Date of an RRULE UNTIL value ("20260801" or "20260801T215959Z"). Datetime
+ * forms are UTC (RFC 5545); the date is taken after converting into [zone] so
+ * a [toRRule]-rendered value round-trips to the day the user picked.
+ */
+private fun parseUntilDate(raw: String, zone: TimeZone): LocalDate? = runCatching {
+    val date = LocalDate(
+        raw.substring(0, 4).toInt(),
+        raw.substring(4, 6).toInt(),
+        raw.substring(6, 8).toInt(),
+    )
+    if (raw.length >= 15 && raw[8] == 'T') {
+        val time = LocalTime(
+            raw.substring(9, 11).toInt(),
+            raw.substring(11, 13).toInt(),
+            raw.substring(13, 15).toInt(),
+        )
+        LocalDateTime(date, time).toInstant(TimeZone.UTC).toLocalDateTime(zone).date
+    } else {
+        date
+    }
+}.getOrNull()

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

@@ -8,6 +8,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.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -15,10 +16,12 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.ui.calendars.CalendarsScreen
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.day.DayScreen
 import de.jeanlucmakiola.calendula.ui.detail.EventDetailScreen
+import de.jeanlucmakiola.calendula.ui.edit.EventEditScreen
 import de.jeanlucmakiola.calendula.ui.month.MonthScreen
 import de.jeanlucmakiola.calendula.ui.settings.SettingsScreen
 import de.jeanlucmakiola.calendula.ui.week.WeekScreen
@@ -28,9 +31,18 @@ import kotlinx.datetime.LocalDate
  * Holds the active top-level view (spec M1) and swaps between the calendar
  * screens. Each screen owns its own ViewModel and date anchor; the view-switcher
  * pill in their top bars writes back here via [onSelectView].
+ *
+ * [requestedDetailKey] is an externally requested occurrence (a tapped
+ * reminder notification routed through MainActivity): it opens the detail
+ * overlay exactly like an event tap and is cleared via [onDetailKeyConsumed]
+ * so a later recomposition can't re-open it.
  */
 @Composable
-fun CalendarHost(modifier: Modifier = Modifier) {
+fun CalendarHost(
+    modifier: Modifier = Modifier,
+    requestedDetailKey: LongArray? = null,
+    onDetailKeyConsumed: () -> Unit = {},
+) {
     var view by rememberSaveable { mutableStateOf(CalendarView.Week) }
     val onSelectView: (CalendarView) -> Unit = { view = it }
 
@@ -60,12 +72,49 @@ fun CalendarHost(modifier: Modifier = Modifier) {
         detailKey = key
     }
 
+    // A tapped reminder notification asks for a specific occurrence.
+    LaunchedEffect(requestedDetailKey) {
+        if (requestedDetailKey != null) {
+            heldKey = requestedDetailKey
+            detailKey = requestedDetailKey
+            onDetailKeyConsumed()
+        }
+    }
+
     // Settings (M4) is hoisted here so it overlays whichever calendar view is
     // active and survives view switches. (The calendar filter now lives inline
     // in the navigation drawer, so no overlay state is needed for it.)
     var showSettings by rememberSaveable { mutableStateOf(false) }
     val onOpenSettings = { showSettings = true }
 
+    // Calendar manager (reached from Settings) — its own overlay so it slides
+    // over Settings and survives view switches.
+    var showCalendars by rememberSaveable { mutableStateOf(false) }
+
+    // Event form (v1.2 create) — same held-key pattern as the detail screen:
+    // [heldCreateIso] keeps the prefill date alive through the slide-out.
+    // [createStartMinutes] is the tapped slot's start (minutes from midnight)
+    // when the form is opened from a day/week grid tap; null from the FAB.
+    var createDateIso by rememberSaveable { mutableStateOf<String?>(null) }
+    var heldCreateIso by remember { mutableStateOf<String?>(null) }
+    var createStartMinutes by rememberSaveable { mutableStateOf<Int?>(null) }
+    var heldCreateMinutes by remember { mutableStateOf<Int?>(null) }
+    val onCreateEvent: (LocalDate, Int?) -> Unit = { date, startMinutes ->
+        heldCreateIso = date.toString()
+        createDateIso = date.toString()
+        heldCreateMinutes = startMinutes
+        createStartMinutes = startMinutes
+    }
+
+    // Edit form (v1.3) — reuses the detail screen's occurrence key; for
+    // recurring events the form itself asks for the write scope at save
+    // time. A saved edit closes the detail screen too: the occurrence the
+    // user tapped may not exist anymore (time moved, recurrence changed), so
+    // falling back to the auto-refreshing calendar is the only honest
+    // destination.
+    var editKey by rememberSaveable { mutableStateOf<LongArray?>(null) }
+    var heldEditKey by remember { mutableStateOf<LongArray?>(null) }
+
     val slideSpec = rememberCalendarSlideSpec()
 
     Box(modifier = modifier.fillMaxSize()) {
@@ -75,12 +124,14 @@ fun CalendarHost(modifier: Modifier = Modifier) {
                 onSelectView = onSelectView,
                 onEventClick = onEventClick,
                 onOpenSettings = onOpenSettings,
+                onCreateEvent = onCreateEvent,
             )
             CalendarView.Day -> DayScreen(
                 selectedView = view,
                 onSelectView = onSelectView,
                 onEventClick = onEventClick,
                 onOpenSettings = onOpenSettings,
+                onCreateEvent = onCreateEvent,
                 initialDateIso = pendingDayIso,
             )
             CalendarView.Month -> MonthScreen(
@@ -88,6 +139,7 @@ fun CalendarHost(modifier: Modifier = Modifier) {
                 onSelectView = onSelectView,
                 onOpenDay = onOpenDay,
                 onOpenSettings = onOpenSettings,
+                onCreateEvent = onCreateEvent,
             )
         }
 
@@ -104,6 +156,45 @@ fun CalendarHost(modifier: Modifier = Modifier) {
                     beginMillis = key[1],
                     endMillis = key[2],
                     onBack = { detailKey = null },
+                    onEdit = {
+                        heldEditKey = key
+                        editKey = key
+                    },
+                )
+            }
+        }
+
+        // Event form (v1.2) — full-screen destination, slides over the calendar.
+        AnimatedVisibility(
+            visible = createDateIso != null,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
+        ) {
+            (createDateIso ?: heldCreateIso)?.let { iso ->
+                EventEditScreen(
+                    initialDateIso = iso,
+                    initialStartMinutes = createStartMinutes ?: heldCreateMinutes,
+                    onClose = { createDateIso = null },
+                    onSaved = { createDateIso = null },
+                )
+            }
+        }
+
+        // Edit form (v1.3) — slides over the detail screen.
+        AnimatedVisibility(
+            visible = editKey != null,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
+        ) {
+            (editKey ?: heldEditKey)?.let { key ->
+                EventEditScreen(
+                    initialDateIso = null,
+                    editKey = key,
+                    onClose = { editKey = null },
+                    onSaved = {
+                        editKey = null
+                        detailKey = null
+                    },
                 )
             }
         }
@@ -114,7 +205,19 @@ fun CalendarHost(modifier: Modifier = Modifier) {
             enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
             exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
         ) {
-            SettingsScreen(onBack = { showSettings = false })
+            SettingsScreen(
+                onBack = { showSettings = false },
+                onManageCalendars = { showCalendars = true },
+            )
+        }
+
+        // Calendar manager — slides over Settings.
+        AnimatedVisibility(
+            visible = showCalendars,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
+        ) {
+            CalendarsScreen(onBack = { showCalendars = false })
         }
     }
 }

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

@@ -10,14 +10,22 @@ import androidx.compose.runtime.setValue
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
+import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import de.jeanlucmakiola.calendula.ui.permission.PermissionScreen
+import de.jeanlucmakiola.calendula.ui.permission.ReminderOnboardingScreen
+import de.jeanlucmakiola.calendula.ui.permission.ReminderOnboardingViewModel
 
 @Composable
-fun RootScreen(modifier: Modifier = Modifier) {
+fun RootScreen(
+    modifier: Modifier = Modifier,
+    requestedDetailKey: LongArray? = null,
+    onDetailKeyConsumed: () -> Unit = {},
+) {
     val context = LocalContext.current
     var hasPermission by remember {
         mutableStateOf(
@@ -40,7 +48,23 @@ fun RootScreen(modifier: Modifier = Modifier) {
     }
 
     if (hasPermission) {
-        CalendarHost(modifier = modifier)
+        // 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()
+        when (onboardingDone) {
+            true -> CalendarHost(
+                modifier = modifier,
+                requestedDetailKey = requestedDetailKey,
+                onDetailKeyConsumed = onDetailKeyConsumed,
+            )
+            false -> ReminderOnboardingScreen(
+                onFinished = reminderOnboarding::finish,
+                modifier = modifier,
+            )
+            null -> {}
+        }
     } else {
         PermissionScreen(
             onGranted = { hasPermission = true },

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

@@ -0,0 +1,500 @@
+package de.jeanlucmakiola.calendula.ui.calendars
+
+import android.accounts.AccountManager
+import android.content.Context
+import android.content.Intent
+import android.provider.Settings
+import androidx.activity.compose.BackHandler
+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.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.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.automirrored.filled.Notes
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.CalendarMonth
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material.icons.filled.OpenInNew
+import androidx.compose.material.icons.filled.Palette
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
+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.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.ui.common.CALENDAR_COLOR_PALETTE
+import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
+import de.jeanlucmakiola.calendula.ui.common.CollapsingScaffold
+import de.jeanlucmakiola.calendula.ui.common.ColorSwatchRow
+import de.jeanlucmakiola.calendula.ui.common.GroupedRow
+import de.jeanlucmakiola.calendula.ui.common.InlineTextField
+import de.jeanlucmakiola.calendula.ui.common.Position
+import de.jeanlucmakiola.calendula.ui.common.pastelize
+import de.jeanlucmakiola.calendula.ui.common.positionOf
+
+/** Sentinel [editorId] meaning "the editor is composing a new calendar". */
+private const val NEW_CALENDAR_ID = Long.MIN_VALUE
+
+/**
+ * Calendar manager (reached from Settings). Lists the app's own device-only
+ * calendars with create / rename / recolor / delete (via a full-screen editor),
+ * and lists synced calendars read-only with a per-account "manage in the source
+ * app" deep-link — the app never touches a synced calendar's server. A
+ * full-screen destination; [onBack] pops it.
+ */
+@Composable
+fun CalendarsScreen(
+    onBack: () -> Unit,
+    viewModel: CalendarsViewModel = hiltViewModel(),
+) {
+    val calendars by viewModel.calendars.collectAsStateWithLifecycle()
+    val error by viewModel.error.collectAsStateWithLifecycle()
+
+    // null = list; NEW_CALENDAR_ID = create; any other id = edit that calendar.
+    // [editorSession] bumps on every open so the editor's field state resets for
+    // a fresh open while still surviving configuration changes within one open.
+    var editorId by rememberSaveable { mutableStateOf<Long?>(null) }
+    var editorSession by rememberSaveable { mutableStateOf(0) }
+
+    if (editorId != null) {
+        val editing = calendars.firstOrNull { it.id == editorId }
+        CalendarEditor(
+            sessionKey = editorSession,
+            isNew = editorId == NEW_CALENDAR_ID,
+            initialName = editing?.displayName.orEmpty(),
+            initialColor = editing?.color ?: CALENDAR_COLOR_PALETTE.first(),
+            initialDescription = editing?.description.orEmpty(),
+            onSave = { name, color, description ->
+                val id = editorId
+                if (id == null || id == NEW_CALENDAR_ID) {
+                    viewModel.createCalendar(name, color, description)
+                } else {
+                    viewModel.updateCalendar(id, name, color, description)
+                }
+                editorId = null
+            },
+            onDelete = {
+                editorId?.takeIf { it != NEW_CALENDAR_ID }?.let(viewModel::deleteCalendar)
+                editorId = null
+            },
+            onClose = { editorId = null },
+        )
+    } else {
+        CalendarsList(
+            local = calendars.filter { it.isLocal },
+            synced = calendars.filterNot { it.isLocal },
+            error = error,
+            onConsumeError = viewModel::consumeError,
+            onBack = onBack,
+            onAdd = { editorSession++; editorId = NEW_CALENDAR_ID },
+            onEdit = { calendar -> editorSession++; editorId = calendar.id },
+        )
+    }
+}
+
+@Composable
+private fun CalendarsList(
+    local: List<CalendarSource>,
+    synced: List<CalendarSource>,
+    error: Boolean,
+    onConsumeError: () -> Unit,
+    onBack: () -> Unit,
+    onAdd: () -> Unit,
+    onEdit: (CalendarSource) -> Unit,
+) {
+    val context = LocalContext.current
+    val snackbarHostState = remember { SnackbarHostState() }
+    val writeErrorText = stringResource(R.string.calendars_write_error)
+
+    LaunchedEffect(error) {
+        if (error) {
+            snackbarHostState.showSnackbar(writeErrorText)
+            onConsumeError()
+        }
+    }
+
+    CollapsingScaffold(
+        title = stringResource(R.string.calendars_title),
+        onBack = onBack,
+        snackbarHost = { SnackbarHost(snackbarHostState) },
+    ) {
+        // Local (device-only) calendars — the calendars the app owns. The
+        // "Add calendar" entry closes the group as its final row.
+        SectionHeader(stringResource(R.string.calendars_local_header))
+        if (local.isEmpty()) {
+            HintText(stringResource(R.string.calendars_local_empty))
+        }
+        val localCount = local.size + 1
+        local.forEachIndexed { index, calendar ->
+            GroupedRow(
+                title = calendar.displayName,
+                summary = calendar.description,
+                position = positionOf(index, localCount),
+                leading = { CalendarColorChip(calendar.color) },
+                trailing = {
+                    Icon(
+                        Icons.Default.Edit,
+                        contentDescription = stringResource(R.string.calendars_edit_title),
+                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier.size(20.dp),
+                    )
+                },
+                onClick = { onEdit(calendar) },
+            )
+        }
+        GroupedRow(
+            title = stringResource(R.string.calendars_add),
+            position = positionOf(local.size, localCount),
+            leading = { AddAvatar() },
+            onClick = onAdd,
+        )
+
+        Spacer(Modifier.height(16.dp))
+
+        // Synced calendars — read-only, grouped by account, each with a
+        // per-account "manage in source app" link.
+        SectionHeader(stringResource(R.string.calendars_synced_header))
+        HintText(stringResource(R.string.calendars_synced_hint))
+        synced
+            .groupBy { it.accountName.ifBlank { it.accountType } }
+            .forEach { (account, cals) ->
+                AccountHeader(account = account, accountType = cals.first().accountType)
+                cals.forEachIndexed { index, calendar ->
+                    GroupedRow(
+                        title = calendar.displayName,
+                        position = positionOf(index, cals.size),
+                        leading = { CalendarColorChip(calendar.color) },
+                    )
+                }
+            }
+        Spacer(Modifier.height(8.dp))
+        GroupedRow(
+            title = stringResource(R.string.calendars_add_account),
+            position = Position.Alone,
+            leading = { AddAvatar() },
+            onClick = {
+                runCatching { context.startActivity(Intent(Settings.ACTION_ADD_ACCOUNT)) }
+            },
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun CalendarEditor(
+    sessionKey: Int,
+    isNew: Boolean,
+    initialName: String,
+    initialColor: Int,
+    initialDescription: String,
+    onSave: (name: String, color: Int, description: String?) -> Unit,
+    onDelete: () -> Unit,
+    onClose: () -> Unit,
+) {
+    var name by rememberSaveable(sessionKey) { mutableStateOf(initialName) }
+    var color by rememberSaveable(sessionKey) { mutableStateOf(initialColor) }
+    var description by rememberSaveable(sessionKey) { mutableStateOf(initialDescription) }
+    var confirmDelete by remember { mutableStateOf(false) }
+    val dark = isSystemInDarkTheme()
+
+    BackHandler(onBack = onClose)
+
+    Scaffold(
+        modifier = Modifier
+            .fillMaxSize()
+            .background(MaterialTheme.colorScheme.surface),
+        topBar = {
+            TopAppBar(
+                title = {
+                    Text(
+                        stringResource(
+                            if (isNew) R.string.calendars_new_title
+                            else R.string.calendars_edit_title,
+                        ),
+                    )
+                },
+                navigationIcon = {
+                    IconButton(onClick = onClose) {
+                        Icon(
+                            Icons.Default.Close,
+                            contentDescription = stringResource(R.string.event_edit_close),
+                        )
+                    }
+                },
+                actions = {
+                    if (!isNew) {
+                        IconButton(onClick = { confirmDelete = true }) {
+                            Icon(
+                                Icons.Default.Delete,
+                                contentDescription = stringResource(R.string.event_detail_delete),
+                                tint = MaterialTheme.colorScheme.error,
+                            )
+                        }
+                    }
+                    // Filled save button, matching the event editor's top bar.
+                    Button(
+                        onClick = {
+                            onSave(name.trim(), color, description.trim().ifEmpty { null })
+                        },
+                        enabled = name.isNotBlank(),
+                        modifier = Modifier.padding(end = 12.dp),
+                    ) {
+                        Text(stringResource(R.string.event_edit_save))
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.surface,
+                ),
+            )
+        },
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .padding(innerPadding)
+                .fillMaxSize()
+                .verticalScroll(rememberScrollState())
+                .padding(horizontal = 16.dp, vertical = 8.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            EditorCard(icon = Icons.Default.CalendarMonth, iconTint = pastelize(color, dark)) {
+                InlineTextField(
+                    value = name,
+                    onValueChange = { name = it },
+                    placeholder = stringResource(R.string.calendars_name_label),
+                    textStyle = MaterialTheme.typography.titleLarge,
+                    capitalization = KeyboardCapitalization.Sentences,
+                )
+            }
+            EditorCard(
+                icon = Icons.Default.Palette,
+                iconTint = MaterialTheme.colorScheme.onSurfaceVariant,
+                iconAtTop = true,
+            ) {
+                Text(
+                    text = stringResource(R.string.calendars_color_label),
+                    style = MaterialTheme.typography.labelLarge,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+                Spacer(Modifier.height(12.dp))
+                ColorSwatchRow(
+                    colors = CALENDAR_COLOR_PALETTE,
+                    selected = color,
+                    onSelect = { color = it },
+                    dark = dark,
+                )
+            }
+            EditorCard(
+                icon = Icons.AutoMirrored.Filled.Notes,
+                iconTint = MaterialTheme.colorScheme.onSurfaceVariant,
+                iconAtTop = true,
+            ) {
+                InlineTextField(
+                    value = description,
+                    onValueChange = { description = it },
+                    placeholder = stringResource(R.string.calendars_description_hint),
+                    singleLine = false,
+                    minLines = 2,
+                    capitalization = KeyboardCapitalization.Sentences,
+                )
+            }
+        }
+    }
+
+    if (confirmDelete) {
+        AlertDialog(
+            onDismissRequest = { confirmDelete = false },
+            title = { Text(stringResource(R.string.calendars_delete_confirm_title)) },
+            text = {
+                Text(stringResource(R.string.calendars_delete_confirm_message, initialName))
+            },
+            confirmButton = {
+                TextButton(onClick = {
+                    confirmDelete = false
+                    onDelete()
+                }) {
+                    Text(
+                        stringResource(R.string.event_detail_delete),
+                        color = MaterialTheme.colorScheme.error,
+                    )
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { confirmDelete = false }) {
+                    Text(stringResource(R.string.dialog_cancel))
+                }
+            },
+        )
+    }
+}
+
+/** Tonal field card matching the event editor's design (icon + content). */
+@Composable
+private fun EditorCard(
+    icon: ImageVector,
+    iconTint: Color,
+    iconAtTop: Boolean = false,
+    content: @Composable () -> Unit,
+) {
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        shape = RoundedCornerShape(16.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            verticalAlignment = if (iconAtTop) Alignment.Top else Alignment.CenterVertically,
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = null,
+                tint = iconTint,
+                modifier = Modifier
+                    .padding(top = if (iconAtTop) 2.dp else 0.dp)
+                    .size(24.dp),
+            )
+            Spacer(Modifier.width(16.dp))
+            Column(modifier = Modifier.weight(1f)) { content() }
+        }
+    }
+}
+
+@Composable
+private fun AccountHeader(account: String, accountType: String) {
+    val context = LocalContext.current
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(start = 28.dp, end = 16.dp, top = 16.dp, bottom = 4.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            text = account,
+            style = MaterialTheme.typography.titleSmall,
+            fontWeight = FontWeight.SemiBold,
+            modifier = Modifier.weight(1f),
+        )
+        OutlinedButton(onClick = {
+            runCatching { context.startActivity(sourceAppIntent(context, accountType)) }
+        }) {
+            Icon(Icons.Default.OpenInNew, contentDescription = null, modifier = Modifier.size(16.dp))
+            Spacer(Modifier.width(6.dp))
+            Text(stringResource(R.string.calendars_manage_in_app))
+        }
+    }
+}
+
+/** Neutral circular chip with a "+" — the leading icon for add-actions. */
+@Composable
+private fun AddAvatar() {
+    Box(
+        modifier = Modifier
+            .size(40.dp)
+            .clip(CircleShape)
+            .background(MaterialTheme.colorScheme.surfaceContainerHighest),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            Icons.Default.Add,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.size(22.dp),
+        )
+    }
+}
+
+@Composable
+private fun SectionHeader(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.labelLarge,
+        color = MaterialTheme.colorScheme.primary,
+        modifier = Modifier.padding(start = 24.dp, end = 24.dp, top = 16.dp, bottom = 4.dp),
+    )
+}
+
+@Composable
+private fun HintText(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.bodySmall,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        modifier = Modifier.padding(horizontal = 24.dp, vertical = 4.dp),
+    )
+}
+
+/**
+ * Pick the app to open for managing a synced calendar's account. The account's
+ * own authenticator package (resolved from [AccountManager], no permission
+ * needed) handles any sync provider — DAVx5, ICSx5, Nextcloud, … — and a small
+ * curated map redirects the few cases where the authenticator isn't the app to
+ * open (Google's authenticator is Play Services, but users want the Calendar
+ * app). Falls back to the system account settings when nothing launchable is
+ * found, so the button always lands somewhere sensible.
+ */
+private fun sourceAppIntent(context: Context, accountType: String): Intent {
+    val pm = context.packageManager
+    val candidates = buildList {
+        AccountManager.get(context).authenticatorTypes
+            .firstOrNull { it.type.equals(accountType, ignoreCase = true) }
+            ?.packageName
+            ?.let { add(it) }
+        curatedSourcePackage(accountType)?.let { add(it) }
+    }
+    for (pkg in candidates) {
+        pm.getLaunchIntentForPackage(pkg)?.let { return it }
+    }
+    return Intent(Settings.ACTION_SYNC_SETTINGS)
+}
+
+/** Preferred app for account types whose authenticator isn't the app to open. */
+private fun curatedSourcePackage(accountType: String): String? = when {
+    accountType.equals("com.google", ignoreCase = true) -> "com.google.android.calendar"
+    else -> null
+}
+

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

@@ -0,0 +1,71 @@
+package de.jeanlucmakiola.calendula.ui.calendars
+
+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.di.IoDispatcher
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+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.stateIn
+import kotlinx.coroutines.launch
+import kotlin.coroutines.cancellation.CancellationException
+import javax.inject.Inject
+
+/**
+ * Backs the calendar manager: lists every calendar (the screen splits them into
+ * the app's own local calendars and read-only/synced ones) and creates,
+ * renames, recolors or deletes the local calendars the app owns. Write failures
+ * flip [error] so the screen can surface a one-shot message.
+ */
+@HiltViewModel
+class CalendarsViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    val calendars: StateFlow<List<CalendarSource>> =
+        repository.calendars()
+            .catch { emit(emptyList()) }
+            .flowOn(io)
+            .stateIn(
+                scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(5_000L),
+                initialValue = emptyList(),
+            )
+
+    private val _error = MutableStateFlow(false)
+    val error: StateFlow<Boolean> = _error.asStateFlow()
+
+    fun consumeError() { _error.value = false }
+
+    fun createCalendar(displayName: String, color: Int, description: String?) = write {
+        repository.createLocalCalendar(displayName, color, description)
+    }
+
+    fun updateCalendar(id: Long, displayName: String, color: Int, description: String?) = write {
+        repository.updateCalendar(id, displayName, color, description)
+    }
+
+    fun deleteCalendar(id: Long) = write {
+        repository.deleteCalendar(id)
+    }
+
+    private inline fun write(crossinline block: suspend () -> Unit) {
+        viewModelScope.launch {
+            try {
+                block()
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                _error.value = true
+            }
+        }
+    }
+}

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

@@ -1,6 +1,20 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.CalendarMonth
+import androidx.compose.material3.Icon
+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.graphics.Color
+import androidx.compose.ui.unit.dp
 
 /**
  * Soften a raw calendar color toward a pastel that fits the active theme.
@@ -15,3 +29,27 @@ fun pastelize(rawArgb: Int, dark: Boolean): Color {
     hsv[2] = if (dark) 0.82f else 0.72f
     return Color(android.graphics.Color.HSVToColor(hsv))
 }
+
+/**
+ * Leading avatar for a calendar: a neutral chip holding a calendar glyph tinted
+ * in the calendar's (pastelised) colour. Shared by the calendar manager and the
+ * visibility filter so they read identically.
+ */
+@Composable
+fun CalendarColorChip(color: Int, modifier: Modifier = Modifier) {
+    val dark = isSystemInDarkTheme()
+    Box(
+        modifier = modifier
+            .size(40.dp)
+            .clip(CircleShape)
+            .background(MaterialTheme.colorScheme.surfaceContainerHighest),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            Icons.Filled.CalendarMonth,
+            contentDescription = null,
+            tint = pastelize(color, dark),
+            modifier = Modifier.size(22.dp),
+        )
+    }
+}

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

@@ -1,21 +1,33 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredSize
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Settings
-import androidx.compose.material.icons.filled.Today
-import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.ModalDrawerSheet
-import androidx.compose.material3.NavigationDrawerItem
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+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
@@ -24,59 +36,89 @@ import de.jeanlucmakiola.calendula.ui.filter.CalendarFilterList
 /**
  * Navigation drawer shared by every top-level calendar screen.
  *
- * Visual language (kept deliberately small so sizes don't drift):
- *  - Drawer title — `titleLarge`
- *  - Section headers (e.g. "Calendars") — `titleSmall`, primary, text only
- *  - Nav items (Today / Settings) — Material `NavigationDrawerItem`
- *    (`labelLarge` label + a single 24dp leading icon)
- *
- * Hosts the per-calendar visibility filter (M3) inline — the calendar list with
- * its checkboxes lives here rather than in a separate sheet — plus the "today"
- * jump and a Settings entry (M4). The host screen owns the drawer state.
+ * Uses the app's grouped-card design system (see [GroupedRow]): a branded
+ * header, the View switcher as a grouped card (the active view highlighted),
+ * the per-calendar visibility filter (M3) inline, and a pinned Settings row.
+ * The "View" section mirrors the top-bar switcher pill — tapping a view here
+ * selects it (and closes the drawer) rather than cycling. The host screen owns
+ * the drawer state.
  */
 @Composable
 fun CalendarDrawer(
-    onToday: () -> Unit,
+    currentView: CalendarView,
+    onSelectView: (CalendarView) -> Unit,
     onSettings: () -> Unit,
 ) {
     ModalDrawerSheet {
-        Column(Modifier.fillMaxHeight()) {
-            Text(
-                text = stringResource(R.string.app_name),
-                style = MaterialTheme.typography.titleLarge,
-                modifier = Modifier.padding(horizontal = 28.dp, vertical = 24.dp),
-            )
-            HorizontalDivider()
-            Spacer(Modifier.height(8.dp))
-            NavigationDrawerItem(
-                icon = { Icon(Icons.Filled.Today, contentDescription = null) },
-                label = { Text(stringResource(R.string.month_today_action)) },
-                selected = false,
-                onClick = onToday,
-                modifier = Modifier.padding(horizontal = 12.dp),
-            )
-            Spacer(Modifier.height(8.dp))
-            HorizontalDivider()
+        // The whole sidebar scrolls as one — header, views, the calendar filter
+        // and Settings all flow in a single scroll container.
+        Column(
+            Modifier
+                .fillMaxHeight()
+                .verticalScroll(rememberScrollState()),
+        ) {
+            DrawerHeader()
+
+            DrawerSectionHeader(stringResource(R.string.view_section))
+            IMPLEMENTED_VIEWS.forEachIndexed { index, view ->
+                GroupedRow(
+                    title = stringResource(view.labelRes),
+                    position = positionOf(index, IMPLEMENTED_VIEWS.size),
+                    selected = view == currentView,
+                    minHeight = 56.dp,
+                    leading = { Icon(view.icon, contentDescription = null) },
+                    onClick = { onSelectView(view) },
+                )
+            }
+
+            Spacer(Modifier.height(16.dp))
 
-            // Calendars (M3) — visibility checkboxes, scrollable, takes the slack
-            // between the top actions and the pinned Settings entry.
             DrawerSectionHeader(stringResource(R.string.filter_title))
-            CalendarFilterList(modifier = Modifier.weight(1f))
+            CalendarFilterList()
 
-            HorizontalDivider()
-            Spacer(Modifier.height(8.dp))
-            NavigationDrawerItem(
-                icon = { Icon(Icons.Filled.Settings, contentDescription = null) },
-                label = { Text(stringResource(R.string.month_action_settings)) },
-                selected = false,
+            Spacer(Modifier.height(16.dp))
+            GroupedRow(
+                title = stringResource(R.string.month_action_settings),
+                position = Position.Alone,
+                minHeight = 56.dp,
+                leading = { Icon(Icons.Filled.Settings, contentDescription = null) },
                 onClick = onSettings,
-                modifier = Modifier.padding(horizontal = 12.dp),
             )
             Spacer(Modifier.height(8.dp))
         }
     }
 }
 
+/** Branded header: the app-icon chip beside the app name. */
+@Composable
+private fun DrawerHeader() {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(start = 28.dp, end = 28.dp, top = 24.dp, bottom = 16.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Box(
+            modifier = Modifier
+                .size(44.dp)
+                .clip(RoundedCornerShape(14.dp))
+                .background(colorResource(R.color.ic_launcher_background)),
+            contentAlignment = Alignment.Center,
+        ) {
+            Image(
+                painter = painterResource(R.drawable.ic_launcher_foreground),
+                contentDescription = null,
+                modifier = Modifier.requiredSize(66.dp),
+            )
+        }
+        Spacer(Modifier.width(16.dp))
+        Text(
+            text = stringResource(R.string.app_name),
+            style = MaterialTheme.typography.titleLarge,
+        )
+    }
+}
+
 /** Top-level grouping label in the drawer. Text only, so it never reads as a
  *  tappable nav item. */
 @Composable

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

@@ -0,0 +1,58 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.scaleIn
+import androidx.compose.animation.scaleOut
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.ExtendedFloatingActionButton
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+
+/**
+ * The FAB stack shared by the three calendar views: a persistent "+" to
+ * create an event, with the jump-to-today pill appearing above it whenever
+ * the view isn't anchored on today.
+ */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun CalendarFabColumn(
+    todayVisible: Boolean,
+    todayText: String,
+    onToday: () -> Unit,
+    onCreate: () -> Unit,
+) {
+    Column(
+        horizontalAlignment = Alignment.End,
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        AnimatedVisibility(
+            visible = todayVisible,
+            enter = scaleIn(MaterialTheme.motionScheme.fastSpatialSpec()),
+            exit = scaleOut(MaterialTheme.motionScheme.fastSpatialSpec()),
+        ) {
+            ExtendedFloatingActionButton(
+                onClick = onToday,
+                icon = { Icon(Icons.Default.Refresh, contentDescription = null) },
+                text = { Text(todayText) },
+            )
+        }
+        FloatingActionButton(onClick = onCreate) {
+            Icon(
+                imageVector = Icons.Default.Add,
+                contentDescription = stringResource(R.string.event_edit_new_title),
+            )
+        }
+    }
+}

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

@@ -1,5 +1,13 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.annotation.StringRes
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.CalendarViewDay
+import androidx.compose.material.icons.filled.CalendarViewMonth
+import androidx.compose.material.icons.filled.CalendarViewWeek
+import androidx.compose.ui.graphics.vector.ImageVector
+import de.jeanlucmakiola.calendula.R
+
 /**
  * The top-level calendar views the user can switch between (spec M1).
  * Day is declared but not yet implemented (v0.5) — see [IMPLEMENTED_VIEWS].
@@ -10,6 +18,23 @@ enum class CalendarView {
     Day,
 }
 
+/** Switcher label, shared by the top-bar pill and the drawer's View section. */
+@get:StringRes
+val CalendarView.labelRes: Int
+    get() = when (this) {
+        CalendarView.Month -> R.string.view_month
+        CalendarView.Week -> R.string.view_week
+        CalendarView.Day -> R.string.view_day
+    }
+
+/** Leading icon for the view in the drawer's View section. */
+val CalendarView.icon: ImageVector
+    get() = when (this) {
+        CalendarView.Month -> Icons.Filled.CalendarViewMonth
+        CalendarView.Week -> Icons.Filled.CalendarViewWeek
+        CalendarView.Day -> Icons.Filled.CalendarViewDay
+    }
+
 /**
  * Views that actually have a screen today. The view-switcher pill cycles
  * through these in order.

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

@@ -0,0 +1,82 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material3.Icon
+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.graphics.Color
+import androidx.compose.ui.unit.dp
+
+/**
+ * A wrapping row of round colour swatches; the one matching [selected] is
+ * ringed and checked. Shared by the calendar editor and the event-colour
+ * picker so both pick a colour the same way. Swatches render through
+ * [pastelize] — the softened colour the app actually paints, not the raw hue.
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun ColorSwatchRow(
+    colors: List<Int>,
+    selected: Int?,
+    onSelect: (Int) -> Unit,
+    dark: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    FlowRow(modifier = modifier, horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+        colors.forEach { argb ->
+            val isSelected = argb == selected
+            Box(
+                contentAlignment = Alignment.Center,
+                modifier = Modifier
+                    .padding(vertical = 4.dp)
+                    .size(40.dp)
+                    .clip(CircleShape)
+                    .background(pastelize(argb, dark))
+                    .then(
+                        if (isSelected) {
+                            Modifier.border(2.dp, MaterialTheme.colorScheme.onSurface, CircleShape)
+                        } else {
+                            Modifier
+                        },
+                    )
+                    .clickable { onSelect(argb) },
+            ) {
+                if (isSelected) {
+                    Icon(
+                        Icons.Default.Check,
+                        contentDescription = null,
+                        tint = Color.Black.copy(alpha = 0.7f),
+                        modifier = Modifier.size(20.dp),
+                    )
+                }
+            }
+        }
+    }
+}
+
+/** Google-Calendar-style palette; ARGB ints for a raw `CALENDAR_COLOR` / `EVENT_COLOR`. */
+val CALENDAR_COLOR_PALETTE: List<Int> = listOf(
+    0xFFD50000, // red
+    0xFFE67C00, // orange
+    0xFFF6BF26, // amber
+    0xFF33B679, // green
+    0xFF0B8043, // dark green
+    0xFF039BE5, // blue
+    0xFF3F51B5, // indigo
+    0xFF8E24AA, // purple
+    0xFF616161, // graphite
+).map { it.toInt() }

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

@@ -0,0 +1,191 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsPressedAsState
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LargeTopAppBar
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.rememberTopAppBarState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+
+/**
+ * Position of a row within a grouped list, after the Android-15 settings
+ * pattern: a run of rows shares one rounded container, with full corners at the
+ * group's outer edges and small corners between, separated by small gaps.
+ */
+enum class Position { Top, Middle, Bottom, Alone }
+
+/** Maps an index within a group of [count] rows to its [Position]. */
+fun positionOf(index: Int, count: Int): Position = when {
+    count <= 1 -> Position.Alone
+    index == 0 -> Position.Top
+    index == count - 1 -> Position.Bottom
+    else -> Position.Middle
+}
+
+/**
+ * The app's standard full-screen list scaffold: a collapsing [LargeTopAppBar]
+ * whose title shrinks into the bar (next to the back button) as the content
+ * scrolls. Content is a scrollable column that feeds the toolbar via nested
+ * scroll. Used by Settings and the calendar manager so they share one shell.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun CollapsingScaffold(
+    title: String,
+    onBack: () -> Unit,
+    modifier: Modifier = Modifier,
+    snackbarHost: @Composable () -> Unit = {},
+    actions: @Composable RowScope.() -> Unit = {},
+    content: @Composable ColumnScope.() -> Unit,
+) {
+    BackHandler(onBack = onBack)
+    val scrollBehavior =
+        TopAppBarDefaults.exitUntilCollapsedScrollBehavior(rememberTopAppBarState())
+    Scaffold(
+        modifier = modifier
+            .fillMaxSize()
+            .background(MaterialTheme.colorScheme.surface)
+            .nestedScroll(scrollBehavior.nestedScrollConnection),
+        topBar = {
+            LargeTopAppBar(
+                title = { Text(title) },
+                navigationIcon = {
+                    IconButton(onClick = onBack) {
+                        Icon(
+                            Icons.AutoMirrored.Filled.ArrowBack,
+                            contentDescription = stringResource(R.string.settings_back),
+                        )
+                    }
+                },
+                actions = actions,
+                scrollBehavior = scrollBehavior,
+                colors = TopAppBarDefaults.topAppBarColors(
+                    scrolledContainerColor = MaterialTheme.colorScheme.surface,
+                ),
+            )
+        },
+        snackbarHost = snackbarHost,
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .padding(innerPadding)
+                .fillMaxSize()
+                .verticalScroll(rememberScrollState())
+                .padding(top = 8.dp, bottom = 24.dp),
+            content = content,
+        )
+    }
+}
+
+/**
+ * One row in a grouped list: an M3 [ListItem] over a tonal [Surface] whose
+ * corner radii come from its [position] (so a run of rows reads as a single
+ * rounded card). Corners round further on press. A null [onClick] makes the
+ * row non-interactive (e.g. read-only entries).
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun GroupedRow(
+    title: String,
+    position: Position,
+    modifier: Modifier = Modifier,
+    summary: String? = null,
+    selected: Boolean = false,
+    minHeight: Dp = 72.dp,
+    leading: @Composable (() -> Unit)? = null,
+    trailing: @Composable (() -> Unit)? = null,
+    onClick: (() -> Unit)? = null,
+) {
+    val interaction = remember { MutableInteractionSource() }
+    val pressed by interaction.collectIsPressedAsState()
+    val full by animateDpAsState(if (pressed) 36.dp else 22.dp, label = "fullCorner")
+    val small by animateDpAsState(if (pressed) 36.dp else 6.dp, label = "smallCorner")
+    val shape = when (position) {
+        Position.Alone -> RoundedCornerShape(full)
+        Position.Top -> RoundedCornerShape(
+            topStart = full, topEnd = full, bottomStart = small, bottomEnd = small,
+        )
+        Position.Middle -> RoundedCornerShape(small)
+        Position.Bottom -> RoundedCornerShape(
+            topStart = small, topEnd = small, bottomStart = full, bottomEnd = full,
+        )
+    }
+    val gap = when (position) {
+        Position.Top, Position.Middle -> Modifier.padding(bottom = 2.dp)
+        Position.Bottom, Position.Alone -> Modifier
+    }
+    val itemColors = if (selected) {
+        ListItemDefaults.colors(
+            containerColor = Color.Transparent,
+            headlineColor = MaterialTheme.colorScheme.onSecondaryContainer,
+            leadingIconColor = MaterialTheme.colorScheme.onSecondaryContainer,
+            supportingColor = MaterialTheme.colorScheme.onSecondaryContainer,
+            trailingIconColor = MaterialTheme.colorScheme.onSecondaryContainer,
+        )
+    } else {
+        ListItemDefaults.colors(containerColor = Color.Transparent)
+    }
+    val item: @Composable () -> Unit = {
+        ListItem(
+            headlineContent = { Text(title) },
+            supportingContent = summary?.let { text -> { Text(text) } },
+            leadingContent = leading,
+            trailingContent = trailing,
+            colors = itemColors,
+            modifier = Modifier.heightIn(min = minHeight),
+        )
+    }
+    val base = modifier
+        .fillMaxWidth()
+        .padding(horizontal = 16.dp)
+        .then(gap)
+    val containerColor = if (selected) {
+        MaterialTheme.colorScheme.secondaryContainer
+    } else {
+        MaterialTheme.colorScheme.surfaceContainerHigh
+    }
+    if (onClick != null) {
+        Surface(
+            onClick = onClick,
+            color = containerColor,
+            shape = shape,
+            interactionSource = interaction,
+            modifier = base,
+        ) { item() }
+    } else {
+        Surface(color = containerColor, shape = shape, modifier = base) { item() }
+    }
+}

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

@@ -0,0 +1,74 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.graphics.isSpecified
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.dp
+
+/**
+ * The app's borderless text input: no underline, no outline, just the tonal
+ * card behind it. This is the standard input across the app — we deliberately
+ * don't use Material's outlined/filled text fields, so anything that takes text
+ * (the event form, the calendar manager, dialogs) uses this inside a tonal
+ * [androidx.compose.material3.Surface].
+ */
+@Composable
+fun InlineTextField(
+    value: String,
+    onValueChange: (String) -> Unit,
+    placeholder: String,
+    modifier: Modifier = Modifier
+        .fillMaxWidth()
+        .padding(vertical = 4.dp),
+    textStyle: TextStyle = MaterialTheme.typography.titleMedium,
+    singleLine: Boolean = true,
+    minLines: Int = 1,
+    keyboardType: KeyboardType = KeyboardType.Text,
+    capitalization: KeyboardCapitalization = KeyboardCapitalization.None,
+) {
+    val resolvedStyle = textStyle.copy(
+        color = if (textStyle.color.isSpecified) {
+            textStyle.color
+        } else {
+            MaterialTheme.colorScheme.onSurface
+        },
+    )
+    BasicTextField(
+        value = value,
+        onValueChange = onValueChange,
+        textStyle = resolvedStyle,
+        singleLine = singleLine,
+        minLines = minLines,
+        keyboardOptions = KeyboardOptions(
+            keyboardType = keyboardType,
+            capitalization = capitalization,
+        ),
+        cursorBrush = SolidColor(MaterialTheme.colorScheme.primary),
+        decorationBox = { innerTextField ->
+            Box {
+                if (value.isEmpty()) {
+                    // Clearly fainter than typed text, so a hint never reads as
+                    // prefilled content.
+                    Text(
+                        text = placeholder,
+                        style = resolvedStyle,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f),
+                    )
+                }
+                innerTextField()
+            }
+        },
+        modifier = modifier,
+    )
+}

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

@@ -0,0 +1,94 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.isSpecified
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.unit.dp
+
+/**
+ * The app's standard pick in a selection dialog: a full-width tonal card,
+ * optionally with a leading icon and a supporting line; the selected option
+ * is highlighted. Stack with 8dp gaps inside an AlertDialog — this is the
+ * only sanctioned selection-modal style (no radio rows, no bare text lists).
+ */
+@Composable
+fun OptionCard(
+    label: String,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    icon: ImageVector? = null,
+    /** Icon tint override, e.g. a calendar colour; unspecified follows selection. */
+    iconTint: Color = Color.Unspecified,
+    supportingText: String? = null,
+    selected: Boolean = false,
+    /** Label colour override, e.g. primary for an emphasised "Custom" entry. */
+    labelColor: Color = Color.Unspecified,
+) {
+    val contentColor = if (selected) {
+        MaterialTheme.colorScheme.onSecondaryContainer
+    } else {
+        MaterialTheme.colorScheme.onSurface
+    }
+    Surface(
+        onClick = onClick,
+        color = if (selected) {
+            MaterialTheme.colorScheme.secondaryContainer
+        } else {
+            MaterialTheme.colorScheme.surfaceContainerHighest
+        },
+        shape = RoundedCornerShape(12.dp),
+        modifier = modifier.fillMaxWidth(),
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier.padding(horizontal = 16.dp, vertical = 14.dp),
+        ) {
+            if (icon != null) {
+                Icon(
+                    imageVector = icon,
+                    contentDescription = null,
+                    tint = when {
+                        iconTint.isSpecified -> iconTint
+                        selected -> MaterialTheme.colorScheme.onSecondaryContainer
+                        else -> MaterialTheme.colorScheme.onSurfaceVariant
+                    },
+                    modifier = Modifier.size(20.dp),
+                )
+                Spacer(Modifier.width(12.dp))
+            }
+            Column {
+                Text(
+                    text = label,
+                    style = MaterialTheme.typography.titleMedium,
+                    color = if (labelColor.isSpecified) labelColor else contentColor,
+                )
+                if (supportingText != null) {
+                    Text(
+                        text = supportingText,
+                        style = MaterialTheme.typography.bodySmall,
+                        color = if (selected) {
+                            MaterialTheme.colorScheme.onSecondaryContainer.copy(alpha = 0.8f)
+                        } else {
+                            MaterialTheme.colorScheme.onSurfaceVariant
+                        },
+                    )
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,126 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import android.icu.text.ListFormatter
+import androidx.compose.runtime.Composable
+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.FontStyle
+import de.jeanlucmakiola.calendula.R
+import java.time.DayOfWeek
+import java.time.format.DateTimeFormatter
+import java.time.format.FormatStyle
+import java.time.format.TextStyle as JavaTextStyle
+import java.util.Locale
+
+/**
+ * Humanise an RFC 5545 RRULE into a localized phrase, e.g.
+ * "Every week on Tue and Thu until 31 Dec 2026" or "Every day, 10 times".
+ * Falls back to a generic label for rules we don't render in full (ordinal
+ * monthly/yearly BYDAY, etc.). Shared by the detail screen and the edit
+ * form's repeat card.
+ */
+@Composable
+fun recurrenceText(rrule: String, locale: Locale): AnnotatedString {
+    val parts = rrule.removePrefix("RRULE:").split(';').mapNotNull { token ->
+        val eq = token.indexOf('=')
+        if (eq <= 0) null else token.substring(0, eq).uppercase() to token.substring(eq + 1)
+    }.toMap()
+
+    val freq = parts["FREQ"]?.uppercase()
+    val interval = parts["INTERVAL"]?.toIntOrNull() ?: 1
+    val base = when (freq) {
+        "DAILY" -> if (interval == 1) stringResource(R.string.recurrence_daily)
+        else stringResource(R.string.recurrence_every_n_days, interval)
+        "WEEKLY" -> if (interval == 1) stringResource(R.string.recurrence_weekly)
+        else stringResource(R.string.recurrence_every_n_weeks, interval)
+        "MONTHLY" -> if (interval == 1) stringResource(R.string.recurrence_monthly)
+        else stringResource(R.string.recurrence_every_n_months, interval)
+        "YEARLY" -> if (interval == 1) stringResource(R.string.recurrence_yearly)
+        else stringResource(R.string.recurrence_every_n_years, interval)
+        else -> return AnnotatedString(stringResource(R.string.event_detail_recurring))
+    }
+
+    // Weekly + BYDAY → "<base> on <days>"; other BYDAY forms keep just the base.
+    // The day names + their joined block are tracked so only the names (not the
+    // commas/conjunction) can be italicised in the final string.
+    val byDay = parts["BYDAY"]
+    var dayNames: List<String>? = null
+    var joinedDays: String? = null
+    val main = if (freq == "WEEKLY" && !byDay.isNullOrBlank()) {
+        val days = byDay.split(',').mapNotNull { rruleDayName(it.trim(), locale) }
+        if (days.isNotEmpty()) {
+            val joined = ListFormatter.getInstance(locale).format(days)
+            dayNames = days
+            joinedDays = joined
+            stringResource(R.string.recurrence_on_days, base, joined)
+        } else {
+            base
+        }
+    } else {
+        base
+    }
+
+    // End bound: UNTIL (a date) takes precedence over COUNT (a number of times).
+    val until = parts["UNTIL"]?.let { parseUntilDate(it, locale) }
+    val count = parts["COUNT"]?.toIntOrNull()
+    val full = when {
+        until != null -> stringResource(R.string.recurrence_with_until, main, until)
+        count != null -> stringResource(R.string.recurrence_with_count, main, count)
+        else -> main
+    }
+
+    return buildAnnotatedString {
+        append(full)
+        val names = dayNames
+        val joined = joinedDays
+        if (names != null && joined != null) {
+            // Italicise each day name within the joined block only — leaving the
+            // separators and conjunction ("und"/"and") in the regular style.
+            val regionStart = full.indexOf(joined)
+            if (regionStart >= 0) {
+                val regionEnd = regionStart + joined.length
+                var cursor = regionStart
+                for (name in names) {
+                    val at = full.indexOf(name, cursor)
+                    if (at in regionStart until regionEnd) {
+                        addStyle(SpanStyle(fontStyle = FontStyle.Italic), at, at + name.length)
+                        cursor = at + name.length
+                    }
+                }
+            }
+        }
+    }
+}
+
+/** Map an RRULE BYDAY token (e.g. "TU" or "2TH") to a localized short weekday name. */
+private fun rruleDayName(token: String, locale: Locale): String? {
+    val dow = when (token.takeLast(2).uppercase()) {
+        "MO" -> DayOfWeek.MONDAY
+        "TU" -> DayOfWeek.TUESDAY
+        "WE" -> DayOfWeek.WEDNESDAY
+        "TH" -> DayOfWeek.THURSDAY
+        "FR" -> DayOfWeek.FRIDAY
+        "SA" -> DayOfWeek.SATURDAY
+        "SU" -> DayOfWeek.SUNDAY
+        else -> return null
+    }
+    return dow.getDisplayName(JavaTextStyle.SHORT, locale)
+}
+
+/** Parse an RRULE UNTIL value ("20261231" or "20261231T235959Z") to a localized date. */
+private fun parseUntilDate(raw: String, locale: Locale): String? {
+    val digits = raw.takeWhile { it.isDigit() }
+    if (digits.length < 8) return null
+    return try {
+        val date = java.time.LocalDate.of(
+            digits.substring(0, 4).toInt(),
+            digits.substring(4, 6).toInt(),
+            digits.substring(6, 8).toInt(),
+        )
+        DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale).format(date)
+    } catch (e: Exception) {
+        null
+    }
+}

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

@@ -6,7 +6,6 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
-import de.jeanlucmakiola.calendula.R
 
 /**
  * Top-bar pill that shows the current view and cycles to the next one on tap
@@ -18,16 +17,11 @@ fun ViewSwitcherPill(
     onCycle: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    val labelRes = when (current) {
-        CalendarView.Month -> R.string.view_month
-        CalendarView.Week -> R.string.view_week
-        CalendarView.Day -> R.string.view_day
-    }
     FilledTonalButton(
         onClick = onCycle,
         shape = MaterialTheme.shapes.large,
         modifier = modifier,
     ) {
-        Text(stringResource(labelRes))
+        Text(stringResource(current.labelRes))
     }
 }

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

@@ -1,14 +1,12 @@
 package de.jeanlucmakiola.calendula.ui.day
 
 import androidx.compose.animation.AnimatedContent
-import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.animateDpAsState
-import androidx.compose.animation.scaleIn
-import androidx.compose.animation.scaleOut
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.gestures.detectHorizontalDragGestures
+import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxWithConstraints
@@ -28,12 +26,10 @@ import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Menu
-import androidx.compose.material.icons.filled.Refresh
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.DrawerValue
 import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.ExtendedFloatingActionButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -72,6 +68,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
+import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
@@ -108,6 +105,7 @@ fun DayScreen(
     onSelectView: (CalendarView) -> Unit,
     onEventClick: (EventInstance) -> Unit,
     onOpenSettings: () -> Unit,
+    onCreateEvent: (LocalDate, Int?) -> Unit,
     modifier: Modifier = Modifier,
     initialDateIso: String? = null,
     viewModel: DayViewModel = hiltViewModel(),
@@ -144,7 +142,15 @@ fun DayScreen(
     var slideDir by remember { mutableIntStateOf(0) }
     val goNext = { slideDir = 1; viewModel.goToNext() }
     val goPrev = { slideDir = -1; viewModel.goToPrev() }
-    val jumpToToday = { slideDir = 0; viewModel.goToToday() }
+    // Slide toward today: viewing the future → today comes in from the left
+    // (back), viewing the past → from the right (forward).
+    val jumpToToday = {
+        slideDir = when (val s = state) {
+            is DayUiState.Success -> if (s.today < s.date) -1 else 1
+            else -> 0
+        }
+        viewModel.goToToday()
+    }
 
     ModalNavigationDrawer(
         drawerState = drawerState,
@@ -152,7 +158,11 @@ fun DayScreen(
         gesturesEnabled = drawerState.isOpen,
         drawerContent = {
             CalendarDrawer(
-                onToday = { jumpToToday(); scope.launch { drawerState.close() } },
+                currentView = selectedView,
+                onSelectView = { view ->
+                    onSelectView(view)
+                    scope.launch { drawerState.close() }
+                },
                 onSettings = {
                     onOpenSettings()
                     scope.launch { drawerState.close() }
@@ -172,17 +182,12 @@ fun DayScreen(
                 )
             },
             floatingActionButton = {
-                AnimatedVisibility(
-                    visible = !isOnToday,
-                    enter = scaleIn(),
-                    exit = scaleOut(),
-                ) {
-                    ExtendedFloatingActionButton(
-                        onClick = jumpToToday,
-                        icon = { Icon(Icons.Default.Refresh, contentDescription = null) },
-                        text = { Text(stringResource(R.string.day_today_action)) },
+                CalendarFabColumn(
+                    todayVisible = !isOnToday,
+                    todayText = stringResource(R.string.day_today_action),
+                    onToday = jumpToToday,
+                    onCreate = { onCreateEvent(date, null) },
                 )
-                }
             },
         ) { innerPadding ->
             DayContent(
@@ -193,6 +198,7 @@ fun DayScreen(
                 onSwipePrev = goPrev,
                 onRetry = jumpToToday,
                 onEventClick = onEventClick,
+                onCreateAt = { d, minutes -> onCreateEvent(d, minutes) },
                 modifier = Modifier
                     .padding(innerPadding)
                     .fillMaxSize(),
@@ -210,6 +216,7 @@ private fun DayContent(
     onSwipePrev: () -> Unit,
     onRetry: () -> Unit,
     onEventClick: (EventInstance) -> Unit,
+    onCreateAt: (LocalDate, Int) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val density = LocalDensity.current
@@ -278,6 +285,7 @@ private fun DayContent(
                 scrollState = scrollState,
                 allDayHeight = allDayHeight,
                 onEventClick = onEventClick,
+                onCreateAt = onCreateAt,
             )
         }
     }
@@ -290,6 +298,7 @@ private fun DaySuccess(
     scrollState: ScrollState,
     allDayHeight: Dp,
     onEventClick: (EventInstance) -> Unit,
+    onCreateAt: (LocalDate, Int) -> Unit,
 ) {
     Column(modifier = Modifier.fillMaxSize()) {
         // All-day strip collapses to nothing when the day has no all-day events,
@@ -305,7 +314,12 @@ private fun DaySuccess(
         // Breathing room between the (colour-shifting) top section and the
         // scrolling timeline below.
         Spacer(Modifier.height(8.dp))
-        Timeline(state = state, scrollState = scrollState, onEventClick = onEventClick)
+        Timeline(
+            state = state,
+            scrollState = scrollState,
+            onEventClick = onEventClick,
+            onCreateAt = onCreateAt,
+        )
     }
 }
 
@@ -423,6 +437,7 @@ private fun Timeline(
     state: DayUiState.Success,
     scrollState: ScrollState,
     onEventClick: (EventInstance) -> Unit,
+    onCreateAt: (LocalDate, Int) -> Unit,
 ) {
     val totalHeight = HOUR_HEIGHT * 24
     val dark = isSystemInDarkTheme()
@@ -470,7 +485,9 @@ private fun Timeline(
                 DayColumnCard(
                     blocks = state.timed,
                     dark = dark,
+                    date = state.date,
                     onEventClick = onEventClick,
+                    onCreateAt = onCreateAt,
                     modifier = Modifier
                         .fillMaxWidth()
                         .height(totalHeight),
@@ -484,9 +501,12 @@ private fun Timeline(
 private fun DayColumnCard(
     blocks: List<TimedBlock>,
     dark: Boolean,
+    date: LocalDate,
     onEventClick: (EventInstance) -> Unit,
+    onCreateAt: (LocalDate, Int) -> Unit,
     modifier: Modifier = Modifier,
 ) {
+    val hourPx = with(LocalDensity.current) { HOUR_HEIGHT.toPx() }
     Card(
         // Plain rectangular column — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -496,7 +516,19 @@ private fun DayColumnCard(
         ),
         modifier = modifier,
     ) {
-        BoxWithConstraints(modifier = Modifier.fillMaxSize()) {
+        BoxWithConstraints(
+            modifier = Modifier
+                .fillMaxSize()
+                // Tap an empty slot to create an event there. Taps on event
+                // blocks are consumed by their own click handler first, so this
+                // 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)
+                    }
+                },
+        ) {
             val colWidth = maxWidth
             blocks.forEach { block ->
                 val laneWidth = colWidth / block.laneCount

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

@@ -1,11 +1,14 @@
 package de.jeanlucmakiola.calendula.ui.detail
 
+import android.Manifest
 import android.content.ActivityNotFoundException
 import android.content.Context
 import android.content.Intent
-import android.icu.text.ListFormatter
+import android.content.pm.PackageManager
 import android.net.Uri
 import androidx.activity.compose.BackHandler
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.isSystemInDarkTheme
@@ -38,24 +41,32 @@ import androidx.compose.material.icons.filled.Place
 import androidx.compose.material.icons.filled.Public
 import androidx.compose.material.icons.filled.Repeat
 import androidx.compose.material.icons.filled.Schedule
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
 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.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
+import androidx.core.content.ContextCompat
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.AnnotatedString
@@ -63,7 +74,6 @@ import androidx.compose.ui.text.LinkAnnotation
 import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.TextLinkStyles
 import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.unit.Dp
@@ -79,12 +89,14 @@ import de.jeanlucmakiola.calendula.domain.AttendeeType
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.EventStatus
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
 import de.jeanlucmakiola.calendula.domain.Reminder
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
+import de.jeanlucmakiola.calendula.ui.common.OptionCard
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.pastelize
+import de.jeanlucmakiola.calendula.ui.common.recurrenceText
 import kotlinx.datetime.TimeZone
-import java.time.DayOfWeek
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
 import java.time.format.FormatStyle
@@ -94,10 +106,12 @@ import kotlin.time.Duration.Companion.seconds
 import kotlin.time.Instant
 
 /**
- * Read-only full-screen event detail (spec S4, realised as a navigation
- * destination rather than a bottom sheet — MD3 list→detail pattern). Back
- * gesture and the top-bar arrow both return to the calendar. The only action is
- * tapping the location to open a maps intent.
+ * Full-screen event detail (spec S4, realised as a navigation destination
+ * rather than a bottom sheet — MD3 list→detail pattern). Back gesture and the
+ * top-bar arrow both return to the calendar. Events in writable calendars can
+ * be deleted (v1.1) and edited (v1.3) from here; [onEdit] opens the shared
+ * event form for this occurrence — for recurring events the form asks how
+ * far the change reaches when saving.
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -106,16 +120,77 @@ fun EventDetailScreen(
     beginMillis: Long,
     endMillis: Long,
     onBack: () -> Unit,
+    onEdit: () -> Unit,
     viewModel: EventDetailViewModel = hiltViewModel(),
 ) {
     LaunchedEffect(eventId, beginMillis, endMillis) {
         viewModel.open(eventId, beginMillis, endMillis)
     }
     val state by viewModel.state.collectAsStateWithLifecycle()
+    val deleteState by viewModel.deleteState.collectAsStateWithLifecycle()
 
     BackHandler(onBack = onBack)
 
+    val context = LocalContext.current
+    val snackbarHostState = remember { SnackbarHostState() }
+    var showDeleteDialog by rememberSaveable { mutableStateOf(false) }
+
+    // v1.0 installs only hold READ_CALENDAR; the first write asks for the
+    // upgrade in place. Granting continues straight into the tapped action.
+    var pendingEdit by remember { mutableStateOf(false) }
+    val writePermissionLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.RequestPermission(),
+    ) { granted ->
+        if (granted) {
+            if (pendingEdit) onEdit() else showDeleteDialog = true
+        }
+        pendingEdit = false
+    }
+    val hasWritePermission = {
+        ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.WRITE_CALENDAR,
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+    val onDeleteClick = {
+        if (hasWritePermission()) {
+            showDeleteDialog = true
+        } else {
+            pendingEdit = false
+            writePermissionLauncher.launch(Manifest.permission.WRITE_CALENDAR)
+        }
+    }
+    val onEditClick = {
+        if (hasWritePermission()) {
+            onEdit()
+        } else {
+            pendingEdit = true
+            writePermissionLauncher.launch(Manifest.permission.WRITE_CALENDAR)
+        }
+    }
+
+    val deleteFailedMessage = stringResource(R.string.event_delete_failed)
+    val writeDeniedMessage = stringResource(R.string.event_delete_write_denied)
+    LaunchedEffect(deleteState) {
+        when (deleteState) {
+            DeleteUiState.Deleted -> {
+                viewModel.consumeDeleteResult()
+                onBack()
+            }
+            DeleteUiState.Failed -> {
+                viewModel.consumeDeleteResult()
+                snackbarHostState.showSnackbar(deleteFailedMessage)
+            }
+            DeleteUiState.NeedsPermission -> {
+                viewModel.consumeDeleteResult()
+                snackbarHostState.showSnackbar(writeDeniedMessage)
+            }
+            DeleteUiState.Idle, DeleteUiState.Deleting -> Unit
+        }
+    }
+
     Scaffold(
+        snackbarHost = { SnackbarHost(snackbarHostState) },
         topBar = {
             TopAppBar(
                 title = {},
@@ -128,18 +203,29 @@ fun EventDetailScreen(
                     }
                 },
                 actions = {
-                    IconButton(onClick = { /* TODO: edit event (V2) */ }) {
+                    // Only writable calendars get actions — WebCal subscriptions,
+                    // birthday calendars etc. are read-only at the provider level.
+                    val s = state
+                    if (s is EventDetailUiState.Success && s.canModify) {
+                        IconButton(
+                            onClick = onEditClick,
+                            enabled = deleteState != DeleteUiState.Deleting,
+                        ) {
                             Icon(
                                 imageVector = Icons.Default.Edit,
                                 contentDescription = stringResource(R.string.event_detail_edit),
                             )
                         }
-                    IconButton(onClick = { /* TODO: delete event (V2) */ }) {
+                        IconButton(
+                            onClick = onDeleteClick,
+                            enabled = deleteState != DeleteUiState.Deleting,
+                        ) {
                             Icon(
                                 imageVector = Icons.Default.Delete,
                                 contentDescription = stringResource(R.string.event_detail_delete),
                             )
                         }
+                    }
                 },
                 colors = TopAppBarDefaults.topAppBarColors(
                     containerColor = MaterialTheme.colorScheme.surface,
@@ -159,8 +245,84 @@ fun EventDetailScreen(
             is EventDetailUiState.Success -> EventDetailContent(s, contentModifier)
         }
     }
+
+    val loaded = state
+    if (showDeleteDialog && loaded is EventDetailUiState.Success) {
+        DeleteEventDialog(
+            isRecurring = !loaded.detail.rrule.isNullOrBlank(),
+            onConfirm = { scope ->
+                showDeleteDialog = false
+                viewModel.delete(scope)
+            },
+            onDismiss = { showDeleteDialog = false },
+        )
+    }
 }
 
+/**
+ * Delete confirmation. Recurring events choose between cancelling just the
+ * tapped occurrence (default), truncating the series from it onwards, and
+ * removing the whole series.
+ */
+@Composable
+private fun DeleteEventDialog(
+    isRecurring: Boolean,
+    onConfirm: (RecurringWriteScope) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    var scope by rememberSaveable { mutableStateOf(RecurringWriteScope.ThisEvent) }
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = {
+            Text(
+                stringResource(
+                    if (isRecurring) R.string.event_delete_recurring_title
+                    else R.string.event_delete_title,
+                ),
+            )
+        },
+        text = {
+            if (isRecurring) {
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_occurrence),
+                        onClick = { scope = RecurringWriteScope.ThisEvent },
+                        selected = scope == RecurringWriteScope.ThisEvent,
+                    )
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_following),
+                        onClick = { scope = RecurringWriteScope.ThisAndFollowing },
+                        selected = scope == RecurringWriteScope.ThisAndFollowing,
+                    )
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_series),
+                        onClick = { scope = RecurringWriteScope.AllEvents },
+                        selected = scope == RecurringWriteScope.AllEvents,
+                    )
+                }
+            } else {
+                Text(stringResource(R.string.event_delete_body))
+            }
+        },
+        confirmButton = {
+            TextButton(
+                onClick = { onConfirm(if (isRecurring) scope else RecurringWriteScope.AllEvents) },
+            ) {
+                Text(
+                    text = stringResource(R.string.event_detail_delete),
+                    color = MaterialTheme.colorScheme.error,
+                )
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text(stringResource(R.string.dialog_cancel))
+            }
+        },
+    )
+}
+
+
 @Composable
 private fun EventDetailContent(state: EventDetailUiState.Success, modifier: Modifier = Modifier) {
     val detail = state.detail
@@ -580,116 +742,6 @@ private fun linkifyUrls(text: String, linkColor: Color): AnnotatedString = remem
     }
 }
 
-/**
- * Humanise an RFC 5545 RRULE into a localized phrase, e.g.
- * "Every week on Tue and Thu until 31 Dec 2026" or "Every day, 10 times".
- * Falls back to a generic label for rules we don't render in full (ordinal
- * monthly/yearly BYDAY, etc.).
- */
-@Composable
-private fun recurrenceText(rrule: String, locale: Locale): AnnotatedString {
-    val parts = rrule.removePrefix("RRULE:").split(';').mapNotNull { token ->
-        val eq = token.indexOf('=')
-        if (eq <= 0) null else token.substring(0, eq).uppercase() to token.substring(eq + 1)
-    }.toMap()
-
-    val freq = parts["FREQ"]?.uppercase()
-    val interval = parts["INTERVAL"]?.toIntOrNull() ?: 1
-    val base = when (freq) {
-        "DAILY" -> if (interval == 1) stringResource(R.string.recurrence_daily)
-        else stringResource(R.string.recurrence_every_n_days, interval)
-        "WEEKLY" -> if (interval == 1) stringResource(R.string.recurrence_weekly)
-        else stringResource(R.string.recurrence_every_n_weeks, interval)
-        "MONTHLY" -> if (interval == 1) stringResource(R.string.recurrence_monthly)
-        else stringResource(R.string.recurrence_every_n_months, interval)
-        "YEARLY" -> if (interval == 1) stringResource(R.string.recurrence_yearly)
-        else stringResource(R.string.recurrence_every_n_years, interval)
-        else -> return AnnotatedString(stringResource(R.string.event_detail_recurring))
-    }
-
-    // Weekly + BYDAY → "<base> on <days>"; other BYDAY forms keep just the base.
-    // The day names + their joined block are tracked so only the names (not the
-    // commas/conjunction) can be italicised in the final string.
-    val byDay = parts["BYDAY"]
-    var dayNames: List<String>? = null
-    var joinedDays: String? = null
-    val main = if (freq == "WEEKLY" && !byDay.isNullOrBlank()) {
-        val days = byDay.split(',').mapNotNull { rruleDayName(it.trim(), locale) }
-        if (days.isNotEmpty()) {
-            val joined = ListFormatter.getInstance(locale).format(days)
-            dayNames = days
-            joinedDays = joined
-            stringResource(R.string.recurrence_on_days, base, joined)
-        } else {
-            base
-        }
-    } else {
-        base
-    }
-
-    // End bound: UNTIL (a date) takes precedence over COUNT (a number of times).
-    val until = parts["UNTIL"]?.let { parseUntilDate(it, locale) }
-    val count = parts["COUNT"]?.toIntOrNull()
-    val full = when {
-        until != null -> stringResource(R.string.recurrence_with_until, main, until)
-        count != null -> stringResource(R.string.recurrence_with_count, main, count)
-        else -> main
-    }
-
-    return buildAnnotatedString {
-        append(full)
-        val names = dayNames
-        val joined = joinedDays
-        if (names != null && joined != null) {
-            // Italicise each day name within the joined block only — leaving the
-            // separators and conjunction ("und"/"and") in the regular style.
-            val regionStart = full.indexOf(joined)
-            if (regionStart >= 0) {
-                val regionEnd = regionStart + joined.length
-                var cursor = regionStart
-                for (name in names) {
-                    val at = full.indexOf(name, cursor)
-                    if (at in regionStart until regionEnd) {
-                        addStyle(SpanStyle(fontStyle = FontStyle.Italic), at, at + name.length)
-                        cursor = at + name.length
-                    }
-                }
-            }
-        }
-    }
-}
-
-/** Map an RRULE BYDAY token (e.g. "TU" or "2TH") to a localized short weekday name. */
-private fun rruleDayName(token: String, locale: Locale): String? {
-    val dow = when (token.takeLast(2).uppercase()) {
-        "MO" -> DayOfWeek.MONDAY
-        "TU" -> DayOfWeek.TUESDAY
-        "WE" -> DayOfWeek.WEDNESDAY
-        "TH" -> DayOfWeek.THURSDAY
-        "FR" -> DayOfWeek.FRIDAY
-        "SA" -> DayOfWeek.SATURDAY
-        "SU" -> DayOfWeek.SUNDAY
-        else -> return null
-    }
-    return dow.getDisplayName(JavaTextStyle.SHORT, locale)
-}
-
-/** Parse an RRULE UNTIL value ("20261231" or "20261231T235959Z") to a localized date. */
-private fun parseUntilDate(raw: String, locale: Locale): String? {
-    val digits = raw.takeWhile { it.isDigit() }
-    if (digits.length < 8) return null
-    return try {
-        val date = java.time.LocalDate.of(
-            digits.substring(0, 4).toInt(),
-            digits.substring(4, 6).toInt(),
-            digits.substring(6, 8).toInt(),
-        )
-        DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale).format(date)
-    } catch (e: Exception) {
-        null
-    }
-}
-
 /**
  * Format an event's time into a primary line (date, or "All day") and an
  * optional secondary line (time range). Multi-day timed events collapse into a

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

@@ -4,7 +4,7 @@ import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.FailureReason
 
 /**
- * UI state for the event-detail bottom sheet (spec S4). Read-only in V1.
+ * UI state for the event-detail screen (spec S4).
  */
 sealed interface EventDetailUiState {
     data object Loading : EventDetailUiState
@@ -13,5 +13,20 @@ sealed interface EventDetailUiState {
         val detail: EventDetail,
         /** Display name of the owning calendar, null if it can't be resolved. */
         val calendarName: String?,
+        /** Whether the owning calendar allows modifying events (shows edit/delete). */
+        val canModify: Boolean = false,
     ) : EventDetailUiState
 }
+
+/**
+ * One-shot state of a delete request, separate from the screen state so a
+ * failed delete leaves the loaded detail visible.
+ */
+sealed interface DeleteUiState {
+    data object Idle : DeleteUiState
+    data object Deleting : DeleteUiState
+    data object Deleted : DeleteUiState
+    /** WRITE_CALENDAR was revoked between the tap and the provider call. */
+    data object NeedsPermission : DeleteUiState
+    data object Failed : DeleteUiState
+}

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

@@ -7,11 +7,13 @@ 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.FailureReason
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
@@ -19,6 +21,7 @@ import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
 import kotlin.coroutines.cancellation.CancellationException
 import kotlin.time.Instant
 import javax.inject.Inject
@@ -38,6 +41,9 @@ class EventDetailViewModel @Inject constructor(
     // Bumped by retry() to re-run the load for the same target.
     private val _reload = MutableStateFlow(0)
 
+    private val _deleteState = MutableStateFlow<DeleteUiState>(DeleteUiState.Idle)
+    val deleteState: StateFlow<DeleteUiState> = _deleteState.asStateFlow()
+
     val state: StateFlow<EventDetailUiState> =
         combine(_target, _reload) { target, _ -> target }
             .flatMapLatest { target ->
@@ -72,6 +78,41 @@ class EventDetailViewModel @Inject constructor(
         _reload.value += 1
     }
 
+    /**
+     * Delete the open event. [scope] is meaningful only for recurring events
+     * (one-off events always pass [RecurringWriteScope.AllEvents]). Result
+     * lands in [deleteState]; the screen consumes it via [consumeDeleteResult].
+     */
+    fun delete(scope: RecurringWriteScope) {
+        val target = _target.value ?: return
+        if (_deleteState.value == DeleteUiState.Deleting) return
+        viewModelScope.launch {
+            _deleteState.value = DeleteUiState.Deleting
+            _deleteState.value = try {
+                when (scope) {
+                    RecurringWriteScope.AllEvents ->
+                        repository.deleteEvent(target.eventId)
+                    RecurringWriteScope.ThisEvent ->
+                        repository.deleteOccurrence(target.eventId, target.beginMillis)
+                    RecurringWriteScope.ThisAndFollowing ->
+                        repository.deleteEventFromOccurrence(target.eventId, target.beginMillis)
+                }
+                DeleteUiState.Deleted
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: SecurityException) {
+                DeleteUiState.NeedsPermission
+            } catch (e: Exception) {
+                DeleteUiState.Failed
+            }
+        }
+    }
+
+    /** Reset [deleteState] after the screen handled a terminal result. */
+    fun consumeDeleteResult() {
+        _deleteState.value = DeleteUiState.Idle
+    }
+
     private suspend fun loadDetail(target: Target): EventDetailUiState = try {
         val detail = repository.eventDetail(target.eventId)
         // The Events row holds the series start; replace it with this
@@ -82,10 +123,13 @@ class EventDetailViewModel @Inject constructor(
                 end = Instant.fromEpochMilliseconds(target.endMillis),
             ),
         )
-        val calendarName = repository.calendars().first()
+        val calendar = repository.calendars().first()
             .firstOrNull { it.id == corrected.instance.calendarId }
-            ?.displayName
-        EventDetailUiState.Success(corrected, calendarName)
+        EventDetailUiState.Success(
+            detail = corrected,
+            calendarName = calendar?.displayName,
+            canModify = calendar?.canModifyContents == true,
+        )
     } catch (e: CancellationException) {
         throw e
     } catch (e: NoSuchEventException) {

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

@@ -0,0 +1,69 @@
+package de.jeanlucmakiola.calendula.ui.edit
+
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventColorOption
+import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.EventFormField
+import de.jeanlucmakiola.calendula.domain.EventFormProblem
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+
+/**
+ * UI state for the event form (v1.2: create; v1.3 reuses it for edit). Null
+ * form means the screen hasn't been opened yet.
+ */
+data class EventEditUiState(
+    /** The form with its calendar id resolved (picked > last used > first writable). */
+    val form: EventForm,
+    /** Calendars that accept writes — the only valid targets. */
+    val calendars: List<CalendarSource>,
+    /** Validation problems; empty until a save was attempted. */
+    val problems: Set<EventFormProblem>,
+    val saveState: SaveUiState,
+    /** Optional sections currently rendered (settings defaults ∪ revealed). */
+    val visibleFields: Set<EventFormField> = emptySet(),
+    /**
+     * Optional sections behind "more fields". Sections the current mode can't
+     * offer at all (recurrence while editing a single occurrence) appear in
+     * neither list.
+     */
+    val hiddenFields: List<EventFormField> = emptyList(),
+    /** True while editing an existing event (the calendar is then fixed). */
+    val isEditing: Boolean = false,
+    /**
+     * True while an edit changed the recurrence rule — the save-scope dialog
+     * then drops "only this event" (an exception row can't carry a rule).
+     */
+    val recurrenceChanged: Boolean = false,
+    /**
+     * The event-colour palette the resolved target calendar publishes; empty
+     * when it exposes none. Non-empty → the colour picker offers these swatches
+     * (written as a key, sync-safe); empty → see [colorMode].
+     */
+    val colorPalette: List<EventColorOption> = emptyList(),
+    /**
+     * Whether the user has opted into custom colours on calendars that publish
+     * no palette (a synced one may then drop the colour on sync). Mirrors the
+     * settings flag; ignored for local and palette-backed calendars.
+     */
+    val allowColorOnUnsupportedCalendars: Boolean = false,
+)
+
+/** One-shot state of a save request, mirroring DeleteUiState on the detail screen. */
+sealed interface SaveUiState {
+    data object Idle : SaveUiState
+    /** A dirty recurring event waits for the user to pick the write scope. */
+    data object AwaitingScope : SaveUiState
+    /**
+     * The event changed externally (sync) while the form was open; the save
+     * is parked with its chosen [scope] until the user picks overwrite,
+     * discard, or cancel.
+     */
+    data class AwaitingConflict(val scope: RecurringWriteScope) : SaveUiState
+    /** The event was deleted externally while the form was open. */
+    data object Gone : SaveUiState
+    data object Saving : SaveUiState
+    data object Saved : SaveUiState
+    /** WRITE_CALENDAR was revoked between the tap and the provider call. */
+    data object NeedsPermission : SaveUiState
+    data object Failed : SaveUiState
+}

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

@@ -0,0 +1,396 @@
+package de.jeanlucmakiola.calendula.ui.edit
+
+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.data.prefs.CalendarPrefs
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.domain.AccessLevel
+import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EditSnapshot
+import de.jeanlucmakiola.calendula.domain.EventColorOption
+import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.EventFormField
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.populatedFields
+import de.jeanlucmakiola.calendula.domain.problems
+import de.jeanlucmakiola.calendula.domain.toEditSnapshot
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.coroutines.cancellation.CancellationException
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Instant
+import javax.inject.Inject
+
+/**
+ * Holds the event form being composed. The form's calendar id resolves to
+ * (user pick > last used > first writable); the resolved value is what the UI
+ * shows and what gets saved.
+ */
+@HiltViewModel
+class EventEditViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    private val prefs: CalendarPrefs,
+    private val settingsPrefs: SettingsPrefs,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    private val _form = MutableStateFlow<EventForm?>(null)
+    private val _saveState = MutableStateFlow<SaveUiState>(SaveUiState.Idle)
+    // Problems stay hidden until the first save attempt, so a half-filled
+    // form isn't already shouting errors.
+    private val _showProblems = MutableStateFlow(false)
+    // Fields added through the "more fields" picker; folds back on reset().
+    // openForEdit seeds it with the sections that already hold values.
+    private val _revealed = MutableStateFlow<Set<EventFormField>>(emptySet())
+    // Set while the form edits an existing event instead of composing a new one.
+    private val _editTarget = MutableStateFlow<EditTarget?>(null)
+    private val _loadFailed = MutableStateFlow(false)
+
+    /** True when the event to edit couldn't be loaded; the screen closes itself. */
+    val loadFailed: StateFlow<Boolean> = _loadFailed.asStateFlow()
+
+    /**
+     * The event being edited plus everything the form saw at load time.
+     * For recurring events the write scope is chosen at save time; the
+     * tapped occurrence's [beginMillis]/[endMillis] anchor occurrence-level
+     * writes and the conflict re-read. [zone] is pinned at load so a device
+     * timezone change mid-edit can't fake a conflict.
+     */
+    private data class EditTarget(
+        val eventId: Long,
+        val snapshot: EditSnapshot,
+        val beginMillis: Long,
+        val endMillis: Long,
+        val zone: TimeZone,
+    ) {
+        val original: EventForm get() = snapshot.form
+    }
+
+    private data class LocalInputs(
+        val form: EventForm?,
+        val saveState: SaveUiState,
+        val showProblems: Boolean,
+        val revealed: Set<EventFormField>,
+        val editTarget: EditTarget?,
+    )
+
+    private data class ExternalInputs(
+        val writable: List<CalendarSource>,
+        val lastUsed: Long?,
+        val defaultFields: Set<EventFormField>,
+        val allowColorOnUnsupported: Boolean,
+    )
+
+    /** Writable calendars — the only valid event targets. */
+    private val writableCalendars: Flow<List<CalendarSource>> = repository.calendars()
+        .map { calendars -> calendars.filter { it.canModifyContents } }
+        .catch { emit(emptyList()) }
+
+    /** The target calendar id, resolved exactly as the form shows it. */
+    private val resolvedCalendarId: Flow<Long?> = combine(
+        _form.map { it?.calendarId },
+        writableCalendars,
+        prefs.lastUsedCalendarId,
+    ) { picked, writable, lastUsed ->
+        picked
+            ?: lastUsed?.takeIf { id -> writable.any { it.id == id } }
+            ?: writable.firstOrNull()?.id
+    }.distinctUntilChanged()
+
+    /** The resolved calendar's published event palette, refetched when it changes. */
+    @OptIn(ExperimentalCoroutinesApi::class)
+    private val colorPalette: Flow<List<EventColorOption>> = resolvedCalendarId
+        .flatMapLatest { id ->
+            flow { emit(id?.let { repository.eventColorPalette(it) }.orEmpty()) }
+        }
+        .flowOn(io)
+
+    val state: StateFlow<EventEditUiState?> = combine(
+        combine(_form, _saveState, _showProblems, _revealed, _editTarget, ::LocalInputs),
+        combine(
+            writableCalendars,
+            prefs.lastUsedCalendarId,
+            settingsPrefs.defaultFormFields,
+            settingsPrefs.allowColorOnUnsupportedCalendars,
+            ::ExternalInputs,
+        ).flowOn(io),
+        colorPalette,
+    ) { local, external, palette ->
+        val form = local.form ?: return@combine null
+        val resolvedId = form.calendarId
+            ?: external.lastUsed?.takeIf { id -> external.writable.any { it.id == id } }
+            ?: external.writable.firstOrNull()?.id
+        val resolved = form.copy(calendarId = resolvedId)
+        val visibleFields = external.defaultFields + local.revealed
+        EventEditUiState(
+            form = resolved,
+            calendars = external.writable,
+            problems = if (local.showProblems) resolved.problems() else emptySet(),
+            saveState = local.saveState,
+            visibleFields = visibleFields,
+            hiddenFields = (EventFormField.entries.toSet() - visibleFields).sorted(),
+            isEditing = local.editTarget != null,
+            // A modified-occurrence exception can't carry its own rule, so
+            // the scope dialog drops "only this event" after a rule change.
+            recurrenceChanged = local.editTarget != null &&
+                resolved.rrule != local.editTarget.original.rrule,
+            colorPalette = palette,
+            allowColorOnUnsupportedCalendars = external.allowColorOnUnsupported,
+        )
+    }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = null,
+        )
+
+    /**
+     * Initialise a fresh form for a new event on [date]. [startMinutes] (minutes
+     * from midnight) anchors the start when the form is opened by tapping a slot
+     * in the day/week grid; without it the default is the next full hour (today)
+     * or 09:00 (any other day). No-op when a form is already open, so user input
+     * survives configuration changes; [reset] clears it when the screen closes.
+     */
+    fun openNew(date: LocalDate, startMinutes: Int? = null) {
+        if (_form.value != null) return
+        val zone = TimeZone.currentSystemDefault()
+        val now = Clock.System.now()
+        val start = when {
+            startMinutes != null ->
+                LocalDateTime(date, LocalTime(startMinutes / 60, startMinutes % 60))
+            date == now.toLocalDateTime(zone).date -> {
+                // Today: the next full hour (may roll into tomorrow before midnight).
+                val hourMillis = 3_600_000L
+                val rounded = (now.toEpochMilliseconds() / hourMillis + 1) * hourMillis
+                Instant.fromEpochMilliseconds(rounded).toLocalDateTime(zone)
+            }
+            else -> LocalDateTime(date, LocalTime(9, 0))
+        }
+        val end = (start.toInstant(zone) + 1.hours).toLocalDateTime(zone)
+        _form.value = EventForm(calendarId = null, start = start, end = end)
+    }
+
+    /**
+     * Load an existing event into the form. [beginMillis]/[endMillis] are the
+     * tapped occurrence's own times, like on the detail screen. No-op while a
+     * form is open, so user edits survive configuration changes.
+     */
+    fun openForEdit(eventId: Long, beginMillis: Long, endMillis: Long) {
+        if (_form.value != null || _editTarget.value != null) return
+        viewModelScope.launch {
+            val detail = try {
+                repository.eventDetail(eventId)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                _loadFailed.value = true
+                return@launch
+            }
+            val zone = TimeZone.currentSystemDefault()
+            val snapshot = detail.toEditSnapshot(beginMillis, endMillis, zone)
+            _editTarget.value = EditTarget(eventId, snapshot, beginMillis, endMillis, zone)
+            // Sections holding data must show even when not in the defaults.
+            _revealed.value = snapshot.form.populatedFields()
+            _form.value = snapshot.form
+        }
+    }
+
+    /** Forget the open form; the next [openNew]/[openForEdit] starts clean. */
+    fun reset() {
+        _form.value = null
+        _saveState.value = SaveUiState.Idle
+        _showProblems.value = false
+        _revealed.value = emptySet()
+        _editTarget.value = null
+        _loadFailed.value = false
+    }
+
+    /** Unfold one optional field, picked in the "more fields" dialog. */
+    fun revealField(field: EventFormField) {
+        _revealed.value = _revealed.value + field
+    }
+
+    fun setTitle(value: String) = update { it.copy(title = value) }
+    fun setLocation(value: String) = update { it.copy(location = value) }
+    fun setDescription(value: String) = update { it.copy(description = value) }
+    fun setAllDay(value: Boolean) = update { it.copy(isAllDay = value) }
+
+    /**
+     * Switching calendars drops any chosen colour: a palette key is
+     * account-scoped, and a raw colour may be invalid on the new calendar.
+     * The event falls back to the new calendar's colour until re-picked.
+     */
+    fun setCalendar(id: Long) = update { it.copy(calendarId = id, colorKey = null, color = null) }
+    fun setAvailability(value: Availability) = update { it.copy(availability = value) }
+    fun setAccessLevel(value: AccessLevel) = update { it.copy(accessLevel = value) }
+
+    /** Pick a palette colour (round-trips via its key); [argb] is its swatch. */
+    fun setColorKey(key: String, argb: Int) = update { it.copy(colorKey = key, color = argb) }
+
+    /** Pick a raw colour (local / opted-in calendars), clearing any palette key. */
+    fun setColorRaw(argb: Int) = update { it.copy(colorKey = null, color = argb) }
+
+    /** Clear the colour so the event inherits its calendar's. */
+    fun clearColor() = update { it.copy(colorKey = null, color = null) }
+
+    /** Bare RRULE value from the recurrence picker; null = does not repeat. */
+    fun setRecurrence(rrule: String?) = update { it.copy(rrule = rrule) }
+
+    fun addReminder(minutes: Int) = update {
+        it.copy(reminders = (it.reminders + minutes).distinct().sorted())
+    }
+
+    fun removeReminder(minutes: Int) = update {
+        it.copy(reminders = it.reminders - minutes)
+    }
+
+    /** Moving the start drags the end along, preserving the duration. */
+    fun setStartDate(date: LocalDate) = moveStart { LocalDateTime(date, it.time) }
+    fun setStartTime(time: LocalTime) = moveStart { LocalDateTime(it.date, time) }
+    fun setEndDate(date: LocalDate) = update { it.copy(end = LocalDateTime(date, it.end.time)) }
+    fun setEndTime(time: LocalTime) = update { it.copy(end = LocalDateTime(it.end.date, time)) }
+
+    /**
+     * Validate and write. Saving a dirty recurring event pauses in
+     * [SaveUiState.AwaitingScope] until the screen answers via
+     * [saveWithScope]; everything else writes directly. Terminal results
+     * land in [saveState].
+     */
+    fun save() {
+        val current = state.value ?: return
+        if (current.saveState == SaveUiState.Saving) return
+        val form = current.form
+        if (form.problems().isNotEmpty()) {
+            _showProblems.value = true
+            return
+        }
+        val target = _editTarget.value
+        if (target != null && form == target.original) {
+            // A pristine form saves as a no-op instead of a write.
+            _saveState.value = SaveUiState.Saved
+            return
+        }
+        if (target != null && target.original.rrule != null) {
+            _saveState.value = SaveUiState.AwaitingScope
+            return
+        }
+        performSave(form, RecurringWriteScope.AllEvents)
+    }
+
+    /** Finish a save parked in [SaveUiState.AwaitingScope]. */
+    fun saveWithScope(scope: RecurringWriteScope) {
+        val current = state.value ?: return
+        if (current.saveState != SaveUiState.AwaitingScope) return
+        performSave(current.form, scope)
+    }
+
+    /** Finish a save parked in [SaveUiState.AwaitingConflict], overwriting. */
+    fun saveOverwriting() {
+        val current = state.value ?: return
+        val parked = current.saveState as? SaveUiState.AwaitingConflict ?: return
+        performSave(current.form, parked.scope, ignoreConflict = true)
+    }
+
+    private fun performSave(
+        form: EventForm,
+        scope: RecurringWriteScope,
+        ignoreConflict: Boolean = false,
+    ) {
+        val target = _editTarget.value
+        viewModelScope.launch {
+            _saveState.value = SaveUiState.Saving
+            // No locking (plan 03, decision 5): right before writing, re-read
+            // the event and compare against what the form loaded. An external
+            // change parks the save in a conflict dialog instead of silently
+            // clobbering the edited fields.
+            if (target != null && !ignoreConflict) {
+                val fresh = try {
+                    repository.eventDetail(target.eventId)
+                        .toEditSnapshot(target.beginMillis, target.endMillis, target.zone)
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: NoSuchEventException) {
+                    _saveState.value = SaveUiState.Gone
+                    return@launch
+                } catch (e: Exception) {
+                    // Can't verify — proceed; a real problem fails the write itself.
+                    null
+                }
+                if (fresh != null && fresh != target.snapshot) {
+                    _saveState.value = SaveUiState.AwaitingConflict(scope)
+                    return@launch
+                }
+            }
+            _saveState.value = try {
+                if (target == null) {
+                    repository.createEvent(form)
+                    prefs.setLastUsedCalendarId(requireNotNull(form.calendarId))
+                } else {
+                    when (scope) {
+                        RecurringWriteScope.ThisEvent ->
+                            repository.updateOccurrence(target.eventId, target.beginMillis, form)
+                        RecurringWriteScope.ThisAndFollowing ->
+                            repository.updateEventFromOccurrence(
+                                eventId = target.eventId,
+                                beginMillis = target.beginMillis,
+                                original = target.original,
+                                updated = form,
+                            )
+                        RecurringWriteScope.AllEvents ->
+                            repository.updateEvent(target.eventId, target.original, form)
+                    }
+                }
+                SaveUiState.Saved
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: SecurityException) {
+                SaveUiState.NeedsPermission
+            } catch (e: Exception) {
+                SaveUiState.Failed
+            }
+        }
+    }
+
+    /** Reset [saveState] after the screen handled a terminal result. */
+    fun consumeSaveResult() {
+        _saveState.value = SaveUiState.Idle
+    }
+
+    private fun moveStart(transform: (LocalDateTime) -> LocalDateTime) = update { form ->
+        val zone = TimeZone.currentSystemDefault()
+        val newStart = transform(form.start)
+        val duration = form.end.toInstant(zone) - form.start.toInstant(zone)
+        val newEnd = (newStart.toInstant(zone) + duration).toLocalDateTime(zone)
+        form.copy(start = newStart, end = newEnd)
+    }
+
+    private inline fun update(block: (EventForm) -> EventForm) {
+        _form.value = _form.value?.let(block)
+    }
+}

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

@@ -1,25 +1,17 @@
 package de.jeanlucmakiola.calendula.ui.filter
 
 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.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material3.Checkbox
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
@@ -28,7 +20,9 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.ui.common.pastelize
+import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
+import de.jeanlucmakiola.calendula.ui.common.GroupedRow
+import de.jeanlucmakiola.calendula.ui.common.positionOf
 
 /**
  * Calendar-visibility filter (M3), rendered inline in the navigation drawer.
@@ -53,67 +47,44 @@ fun CalendarFilterList(
     }
 }
 
+/**
+ * Renders as a plain (non-scrolling) [Column] so it flows inside the drawer's
+ * single scroll container — the whole sidebar scrolls as one. Calendar counts
+ * are small, so a lazy list isn't needed.
+ */
 @Composable
 private fun FilterList(
     groups: List<AccountGroup>,
     onSetVisible: (Long, Boolean) -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    val dark = isSystemInDarkTheme()
-    LazyColumn(
-        modifier = modifier.fillMaxWidth(),
-        contentPadding = PaddingValues(vertical = 4.dp),
-    ) {
+    Column(modifier = modifier.fillMaxWidth()) {
         groups.forEach { group ->
-            item(key = "header-${group.account}") {
             Text(
                 text = group.account,
                 style = MaterialTheme.typography.labelMedium,
                 color = MaterialTheme.colorScheme.onSurfaceVariant,
                 modifier = Modifier.padding(start = 28.dp, end = 28.dp, top = 12.dp, bottom = 4.dp),
             )
-            }
-            items(group.calendars, key = { it.id }) { cal ->
-                CalendarToggleRow(
-                    row = cal,
-                    dark = dark,
+            group.calendars.forEachIndexed { index, cal ->
+                GroupedRow(
+                    title = cal.displayName,
+                    position = positionOf(index, group.calendars.size),
+                    minHeight = 56.dp,
+                    leading = { CalendarColorChip(cal.color) },
+                    trailing = {
+                        Checkbox(
+                            checked = cal.visible,
                             onCheckedChange = { onSetVisible(cal.id, it) },
                         )
+                    },
+                    onClick = { onSetVisible(cal.id, !cal.visible) },
+                )
             }
         }
     }
 }
 
-@Composable
-private fun CalendarToggleRow(
-    row: CalendarRow,
-    dark: Boolean,
-    onCheckedChange: (Boolean) -> Unit,
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 28.dp, vertical = 6.dp),
-        verticalAlignment = Alignment.CenterVertically,
-        horizontalArrangement = Arrangement.spacedBy(16.dp),
-    ) {
-        Box(
-            modifier = Modifier
-                .size(14.dp)
-                .background(pastelize(row.color, dark), CircleShape),
-        )
-        Text(
-            text = row.displayName,
-            style = MaterialTheme.typography.bodyMedium,
-            modifier = Modifier.weight(1f),
-        )
-        Checkbox(
-            checked = row.visible,
-            onCheckedChange = onCheckedChange,
-        )
-    }
-}
-
 @Composable
 private fun FilterLoading(modifier: Modifier = Modifier) {
     Column(

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

@@ -1,35 +1,30 @@
 package de.jeanlucmakiola.calendula.ui.month
 
 import androidx.compose.animation.AnimatedContent
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.animation.scaleIn
-import androidx.compose.animation.scaleOut
 import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.gestures.detectHorizontalDragGestures
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.interaction.collectIsPressedAsState
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxSize
 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.size
+import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Menu
-import androidx.compose.material.icons.filled.Refresh
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.DrawerValue
 import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
-import androidx.compose.material3.ExtendedFloatingActionButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -48,7 +43,9 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalDensity
@@ -57,11 +54,13 @@ import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
+import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
@@ -71,11 +70,12 @@ import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import kotlinx.coroutines.launch
-import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
 import kotlinx.datetime.YearMonth
-import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
 import java.time.format.TextStyle as JavaTextStyle
 import java.util.Locale
 
@@ -86,6 +86,7 @@ fun MonthScreen(
     onSelectView: (CalendarView) -> Unit,
     onOpenDay: (LocalDate) -> Unit,
     onOpenSettings: () -> Unit,
+    onCreateEvent: (LocalDate, Int?) -> Unit,
     modifier: Modifier = Modifier,
     viewModel: MonthViewModel = hiltViewModel(),
 ) {
@@ -113,8 +114,14 @@ fun MonthScreen(
         slideDir = -1
         viewModel.goToPrev()
     }
+    // Slide toward today: viewing the future → today comes in from the left
+    // (back), viewing the past → from the right (forward).
     val jumpToToday = {
-        slideDir = 0
+        slideDir = when (val s = state) {
+            is MonthUiState.Success ->
+                if (YearMonth(s.today.year, s.today.month) < s.month) -1 else 1
+            else -> 0
+        }
         viewModel.goToToday()
     }
 
@@ -124,8 +131,9 @@ fun MonthScreen(
         gesturesEnabled = drawerState.isOpen,
         drawerContent = {
             CalendarDrawer(
-                onToday = {
-                    jumpToToday()
+                currentView = selectedView,
+                onSelectView = { view ->
+                    onSelectView(view)
                     scope.launch { drawerState.close() }
                 },
                 onSettings = {
@@ -147,17 +155,21 @@ fun MonthScreen(
                 )
             },
             floatingActionButton = {
-                AnimatedVisibility(
-                    visible = !isOnCurrentMonth,
-                    enter = scaleIn(),
-                    exit = scaleOut(),
-                ) {
-                    ExtendedFloatingActionButton(
-                        onClick = jumpToToday,
-                        icon = { Icon(Icons.Default.Refresh, contentDescription = null) },
-                        text = { Text(stringResource(R.string.month_today_action)) },
+                CalendarFabColumn(
+                    todayVisible = !isOnCurrentMonth,
+                    todayText = stringResource(R.string.month_today_action),
+                    onToday = jumpToToday,
+                    onCreate = {
+                        // Anchor on today when its month is shown, else the 1st.
+                        val today = Clock.System.now()
+                            .toLocalDateTime(TimeZone.currentSystemDefault()).date
+                        onCreateEvent(
+                            if (isOnCurrentMonth) today
+                            else LocalDate(month.year, month.month, 1),
+                            null,
+                        )
+                    },
                 )
-                }
             },
         ) { innerPadding ->
             Column(
@@ -168,7 +180,6 @@ fun MonthScreen(
                 WeekdayHeader(weekStart = weekStart)
                 MonthContent(
                     state = state,
-                    weekStart = weekStart,
                     slideDir = slideDir,
                     onSwipeNext = goNext,
                     onSwipePrev = goPrev,
@@ -183,7 +194,6 @@ fun MonthScreen(
 @Composable
 private fun MonthContent(
     state: MonthUiState,
-    weekStart: DayOfWeek,
     slideDir: Int,
     onSwipeNext: () -> Unit,
     onSwipePrev: () -> Unit,
@@ -228,7 +238,6 @@ private fun MonthContent(
             is MonthUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onRetry)
             is MonthUiState.Success -> MonthGrid(
                 state = s,
-                weekStart = weekStart,
                 onOpenDay = onOpenDay,
             )
         }
@@ -298,140 +307,279 @@ private fun WeekdayHeader(weekStart: DayOfWeek) {
     }
 }
 
+private val EVENT_ROW_HEIGHT = 20.dp
+private val DAY_NUMBER_HEIGHT = 22.dp
+private val DAY_NUMBER_GAP = 4.dp
+private val CELL_TOP_PADDING = 6.dp
+private val CELL_GAP = 2.dp
+private val CELL_SHAPE = RoundedCornerShape(12.dp)
+private const val MAX_EVENT_ROWS = 3
+
 @Composable
 private fun MonthGrid(
     state: MonthUiState.Success,
-    weekStart: DayOfWeek,
     onOpenDay: (LocalDate) -> Unit,
 ) {
-    val firstOfMonth = LocalDate(state.month.year, state.month.month, 1)
-    val gridStart = firstOfMonth.startOfGridWeek(weekStart)
-
-    // Show only the weeks the current month actually touches; leading/trailing
-    // days of neighbouring months are left blank rather than rendered.
-    val leadOffset = ((firstOfMonth.dayOfWeek.ordinal - weekStart.ordinal) + 7) % 7
-    val daysInMonth =
-        java.time.YearMonth.of(state.month.year, state.month.month.ordinal + 1).lengthOfMonth()
-    val weeks = (leadOffset + daysInMonth + 6) / 7
-
     Column(
         modifier = Modifier
             .fillMaxSize()
-            .padding(horizontal = 8.dp, vertical = 4.dp),
-        verticalArrangement = Arrangement.spacedBy(8.dp),
+            .padding(horizontal = 4.dp, vertical = 4.dp),
+        verticalArrangement = Arrangement.spacedBy(2.dp),
     ) {
-        repeat(weeks) { row ->
-            Row(
+        state.weeks.forEach { week ->
+            MonthWeekRow(
+                week = week,
+                today = state.today,
+                month = state.month,
+                onOpenDay = onOpenDay,
                 modifier = Modifier
                     .fillMaxWidth()
                     .weight(1f),
-                horizontalArrangement = Arrangement.spacedBy(4.dp),
-            ) {
-                repeat(7) { col ->
-                    val date = gridStart.plus(row * 7 + col, DateTimeUnit.DAY)
-                    val inMonth =
-                        date.month == state.month.month && date.year == state.month.year
-                    if (inMonth) {
-                        DayCard(
-                            date = date,
-                            isToday = date == state.today,
-                            data = state.cells[date],
-                            onClick = { onOpenDay(date) },
+            )
+        }
+    }
+}
+
+/**
+ * One week of the grid. Bars (all-day / multi-day) are positioned absolutely so
+ * a multi-day event is one connected bar across the columns; single-day timed
+ * events sit beneath them as filled pills in their own cell. The cap is
+ * [MAX_EVENT_ROWS] rows of bars+pills, then a "+N" dot indicator per day.
+ * A transparent per-day layer on top turns a tap into "open that day".
+ */
+@Composable
+private fun MonthWeekRow(
+    week: MonthWeek,
+    today: LocalDate,
+    month: YearMonth,
+    onOpenDay: (LocalDate) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val dark = isSystemInDarkTheme()
+    val laneCount = (week.spans.maxOfOrNull { it.lane } ?: -1) + 1
+    val shownLanes = laneCount.coerceAtMost(MAX_EVENT_ROWS)
+
+    BoxWithConstraints(modifier) {
+        val colW = maxWidth / 7
+
+        // Per-day background pills — same surfaceContainer rounded surface the
+        // week/day views use, so the three views share one visual language.
+        // Spanning bars draw on top of these, bridging cells, so they still read
+        // as one continuous event.
+        Row(Modifier.matchParentSize()) {
+            week.days.forEach { d ->
+                val inMonth = d.month == month.month && d.year == month.year
+                Box(
+                    Modifier
+                        .weight(1f)
+                        .fillMaxHeight()
+                        .padding(horizontal = CELL_GAP, vertical = 1.dp)
+                        .background(
+                            color = if (inMonth) MaterialTheme.colorScheme.surfaceContainer
+                            else MaterialTheme.colorScheme.surfaceContainerLow,
+                            shape = CELL_SHAPE,
+                        ),
+                )
+            }
+        }
+
+        Column(Modifier.fillMaxSize().padding(top = CELL_TOP_PADDING)) {
+            Row(Modifier.fillMaxWidth()) {
+                week.days.forEach { d ->
+                    DayNumberCell(
+                        date = d,
+                        isToday = d == today,
+                        inMonth = d.month == month.month && d.year == month.year,
                         modifier = Modifier.weight(1f),
                     )
-                    } else {
-                        Spacer(Modifier.weight(1f))
                 }
             }
+            // Breathing room between the day number (and today's circle) and the
+            // first event row.
+            Spacer(Modifier.height(DAY_NUMBER_GAP))
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .weight(1f)
+                    .clipToBounds(),
+            ) {
+                // Spanning bars on their shared lanes.
+                week.spans.filter { it.lane < shownLanes }.forEach { span ->
+                    val cols = span.endCol - span.startCol + 1
+                    MonthBar(
+                        event = span.event,
+                        dark = dark,
+                        continuesLeft = span.continuesLeft,
+                        continuesRight = span.continuesRight,
+                        modifier = Modifier
+                            .offset(
+                                x = colW * span.startCol,
+                                y = EVENT_ROW_HEIGHT * span.lane,
+                            )
+                            .width(colW * cols)
+                            .height(EVENT_ROW_HEIGHT)
+                            .padding(horizontal = CELL_GAP + 1.dp, vertical = 1.dp),
+                    )
+                }
+                // Single-day timed pills + overflow, per column. Pills fill the
+                // lane slots no bar occupies on THIS day (top-most first), so a
+                // bar-free day isn't pushed down by a multi-day event that only
+                // sits on other days of the week.
+                week.days.forEachIndexed { col, d ->
+                    val timed = week.timedByDay[d].orEmpty()
+                    val occupied = week.spans
+                        .filter { it.lane < shownLanes && col in it.startCol..it.endCol }
+                        .map { it.lane }
+                        .toSet()
+                    val freeSlots = (0 until MAX_EVENT_ROWS).filter { it !in occupied }
+                    val pillsShown = timed.take(freeSlots.size)
+                    pillsShown.forEachIndexed { i, ev ->
+                        MonthBar(
+                            event = ev,
+                            dark = dark,
+                            continuesLeft = false,
+                            continuesRight = false,
+                            modifier = Modifier
+                                .offset(
+                                    x = colW * col,
+                                    y = EVENT_ROW_HEIGHT * freeSlots[i],
+                                )
+                                .width(colW)
+                                .height(EVENT_ROW_HEIGHT)
+                                .padding(horizontal = CELL_GAP + 1.dp, vertical = 1.dp),
+                        )
+                    }
+                    val hidden = (week.countByDay[d] ?: 0) - occupied.size - pillsShown.size
+                    if (hidden > 0) {
+                        val hiddenColors = buildList {
+                            week.spans
+                                .filter { it.lane >= shownLanes && col in it.startCol..it.endCol }
+                                .forEach { add(it.event.color) }
+                            timed.drop(pillsShown.size).forEach { add(it.color) }
+                        }.distinct().take(3)
+                        OverflowDots(
+                            colors = hiddenColors,
+                            extra = hidden - hiddenColors.size,
+                            dark = dark,
+                            modifier = Modifier
+                                .offset(x = colW * col, y = EVENT_ROW_HEIGHT * MAX_EVENT_ROWS)
+                                .width(colW)
+                                .padding(horizontal = 3.dp),
+                        )
+                    }
+                }
+            }
+        }
+
+        // Tap layer: in month view a tap on any day opens that day. Padded and
+        // clipped to the background pill so the ripple matches it.
+        Row(Modifier.matchParentSize()) {
+            week.days.forEach { d ->
+                Box(
+                    Modifier
+                        .weight(1f)
+                        .fillMaxHeight()
+                        .padding(horizontal = CELL_GAP, vertical = 1.dp)
+                        .clip(CELL_SHAPE)
+                        .clickable { onOpenDay(d) },
+                )
             }
         }
     }
 }
 
-@OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-private fun DayCard(
+private fun DayNumberCell(
     date: LocalDate,
     isToday: Boolean,
-    data: DayCellData?,
-    onClick: () -> Unit,
+    inMonth: Boolean,
     modifier: Modifier = Modifier,
 ) {
-    val todayPrefix = stringResource(R.string.month_a11y_today_prefix)
-    val cellLabel = buildString {
-        if (isToday) append(todayPrefix).append(", ")
-        append(date.year).append('-')
-        append((date.month.ordinal + 1).toString().padStart(2, '0')).append('-')
-        append(date.day.toString().padStart(2, '0'))
-        data?.let { append(", ").append(it.count).append(" Events") }
-    }
-
-    // M3 Expressive press feedback: a spatial spring from the active motion
-    // scheme drives a subtle scale, instead of a fixed easing curve.
-    val interactionSource = remember { MutableInteractionSource() }
-    val pressed by interactionSource.collectIsPressedAsState()
-    val scale by animateFloatAsState(
-        targetValue = if (pressed) 0.94f else 1f,
-        animationSpec = MaterialTheme.motionScheme.fastSpatialSpec(),
-        label = "day-card-press",
-    )
-
-    Card(
-        onClick = onClick,
-        interactionSource = interactionSource,
-        shape = MaterialTheme.shapes.medium,
-        colors = CardDefaults.cardColors(
-            containerColor = if (isToday) MaterialTheme.colorScheme.primaryContainer
-            else MaterialTheme.colorScheme.surfaceContainerHigh,
-            contentColor = if (isToday) MaterialTheme.colorScheme.onPrimaryContainer
-            else MaterialTheme.colorScheme.onSurface,
-        ),
-        modifier = modifier
-            .fillMaxSize()
-            .graphicsLayer {
-                scaleX = scale
-                scaleY = scale
-            }
-            .semantics { contentDescription = cellLabel },
+    Box(
+        modifier = modifier.height(DAY_NUMBER_HEIGHT),
+        contentAlignment = Alignment.Center,
     ) {
-        Column(
+        if (isToday) {
+            Box(
                 modifier = Modifier
-                .fillMaxSize()
-                .padding(top = 4.dp, bottom = 2.dp),
-            horizontalAlignment = Alignment.CenterHorizontally,
+                    .size(DAY_NUMBER_HEIGHT)
+                    .background(MaterialTheme.colorScheme.primary, CircleShape),
+                contentAlignment = Alignment.Center,
             ) {
                 Text(
                     text = date.day.toString(),
-                style = MaterialTheme.typography.labelLarge,
-                fontWeight = if (isToday) FontWeight.Bold else FontWeight.Normal,
+                    style = MaterialTheme.typography.labelMedium,
+                    fontWeight = FontWeight.Bold,
+                    color = MaterialTheme.colorScheme.onPrimary,
+                )
+            }
+        } else {
+            Text(
+                text = date.day.toString(),
+                style = MaterialTheme.typography.labelMedium,
+                color = if (inMonth) MaterialTheme.colorScheme.onSurface
+                else MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.4f),
             )
-            Spacer(Modifier.height(2.dp))
-            EventDotRow(data)
         }
     }
 }
 
+/** A filled event pill/bar — pastelized fill, title clipped to one line. */
 @Composable
-private fun EventDotRow(data: DayCellData?) {
-    if (data == null || data.swatches.isEmpty()) {
-        Spacer(Modifier.height(6.dp))
-        return
+private fun MonthBar(
+    event: de.jeanlucmakiola.calendula.domain.EventInstance,
+    dark: Boolean,
+    continuesLeft: Boolean,
+    continuesRight: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
+    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,
+    )
+    Box(
+        modifier = modifier
+            .background(pastelize(event.color, dark), shape)
+            .padding(horizontal = 4.dp)
+            .semantics { contentDescription = title },
+        contentAlignment = Alignment.CenterStart,
+    ) {
+        Text(
+            text = title,
+            style = MaterialTheme.typography.labelSmall,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+            color = Color.Black.copy(alpha = 0.8f),
+        )
     }
-    val dark = isSystemInDarkTheme()
+}
+
+/** Overflow row: a dot per hidden event (up to three) plus "+N" for the rest. */
+@Composable
+private fun OverflowDots(
+    colors: List<Int>,
+    extra: Int,
+    dark: Boolean,
+    modifier: Modifier = Modifier,
+) {
     Row(
+        modifier = modifier.height(EVENT_ROW_HEIGHT),
         horizontalArrangement = Arrangement.spacedBy(2.dp),
         verticalAlignment = Alignment.CenterVertically,
     ) {
-        data.swatches.forEach { argb ->
+        colors.forEach { argb ->
             Box(
                 modifier = Modifier
                     .size(6.dp)
                     .background(pastelize(argb, dark), CircleShape),
             )
         }
-        if (data.count > data.swatches.size) {
+        if (extra > 0) {
             Text(
-                text = "+${data.count - data.swatches.size}",
+                text = "+$extra",
                 style = MaterialTheme.typography.labelSmall,
                 color = MaterialTheme.colorScheme.onSurfaceVariant,
             )

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

@@ -1,20 +1,40 @@
 package de.jeanlucmakiola.calendula.ui.month
 
+import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.YearMonth
 
 /**
- * Per-day aggregation surfaced to the month grid. We only need
- *   - the total event count (drives the optional "+N" indicator), and
- *   - up to three calendar colors for the dot row.
- *
- * The day cell never holds full event objects — the detail sheet pulls those
- * lazily.
+ * An all-day or multi-day event laid out as one connected horizontal bar across
+ * a week row, [startCol]..[endCol], stacked on [lane] so overlapping spans don't
+ * collide. Mirrors the week view's [de.jeanlucmakiola.calendula.ui.week.AllDaySpan]
+ * but adds clip flags so a bar that started in an earlier week (or runs into a
+ * later one) drops its rounded cap on that side.
  */
-data class DayCellData(
-    val count: Int,
-    val swatches: List<Int>,
+data class MonthSpan(
+    val event: EventInstance,
+    val startCol: Int,
+    val endCol: Int,
+    val lane: Int,
+    val continuesLeft: Boolean,
+    val continuesRight: Boolean,
+)
+
+/**
+ * One week row of the grid with its events resolved for rendering.
+ *
+ *  - [spans] are the all-day/multi-day bars, lanes already assigned for the row.
+ *  - [timedByDay] holds the single-day timed events per date, sorted by start;
+ *    these render as filled pills beneath the bar lanes in their own cell.
+ *  - [countByDay] is the total number of events touching each date (bars + pills),
+ *    so the cell can compute the "+N" overflow once the visible-row cap is known.
+ */
+data class MonthWeek(
+    val days: List<LocalDate>,
+    val spans: List<MonthSpan>,
+    val timedByDay: Map<LocalDate, List<EventInstance>>,
+    val countByDay: Map<LocalDate, Int>,
 )
 
 sealed interface MonthUiState {
@@ -23,6 +43,6 @@ sealed interface MonthUiState {
     data class Success(
         val month: YearMonth,
         val today: LocalDate,
-        val cells: Map<LocalDate, DayCellData>,
+        val weeks: List<MonthWeek>,
     ) : MonthUiState
 }

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

@@ -10,6 +10,8 @@ import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 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 kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -71,7 +73,7 @@ class MonthViewModel @Inject constructor(
                     repository.calendars(),
                     repository.instances(range),
                 ) { calendars, instances ->
-                    buildState(ym, calendars, instances)
+                    buildState(ym, ws, calendars, instances)
                 }
             }
             .catch { emit(MonthUiState.Failure(FailureReason.ProviderUnavailable)) }
@@ -96,25 +98,64 @@ class MonthViewModel @Inject constructor(
 
     private fun buildState(
         ym: YearMonth,
+        weekStart: DayOfWeek,
         calendars: List<CalendarSource>,
         instances: List<EventInstance>,
     ): MonthUiState {
         if (calendars.isEmpty()) {
             return MonthUiState.Failure(FailureReason.NoCalendarsConfigured)
         }
-        val byDay = instances.groupBy { it.start.toLocalDateTime(zone).date }
-            .mapValues { (_, evs) ->
-                DayCellData(
-                    count = evs.size,
-                    swatches = evs.map { it.color }.distinct().take(3),
-                )
-            }
         return MonthUiState.Success(
             month = ym,
             today = todayDate,
-            cells = byDay,
+            weeks = layoutMonth(ym, weekStart, instances),
         )
     }
+
+    /**
+     * Split the grid into week rows and resolve each row's events. An event is a
+     * spanning bar when it's all-day or touches more than one of the row's days;
+     * everything else is a single-day timed pill. Bars get lanes from the shared
+     * [layoutAllDay] so a multi-day event stays on one row across the week.
+     */
+    private fun layoutMonth(
+        ym: YearMonth,
+        weekStart: DayOfWeek,
+        instances: List<EventInstance>,
+    ): List<MonthWeek> {
+        val firstOfMonth = LocalDate(ym.year, ym.month, 1)
+        val gridStart = firstOfMonth.startOfGridWeek(weekStart)
+        val leadOffset = ((firstOfMonth.dayOfWeek.ordinal - weekStart.ordinal) + 7) % 7
+        val daysInMonth =
+            java.time.YearMonth.of(ym.year, ym.month.ordinal + 1).lengthOfMonth()
+        val weekCount = (leadOffset + daysInMonth + 6) / 7
+
+        return (0 until weekCount).map { row ->
+            val days = (0 until 7).map { gridStart.plus(row * 7 + it, DateTimeUnit.DAY) }
+            val weekEvents = instances.filter { ev -> days.any { ev.coversDay(it, zone) } }
+            val (bars, singles) = weekEvents.partition { ev ->
+                ev.isAllDay || days.count { ev.coversDay(it, zone) } > 1
+            }
+            val spans = layoutAllDay(bars, days, zone).map { s ->
+                MonthSpan(
+                    event = s.event,
+                    startCol = s.startCol,
+                    endCol = s.endCol,
+                    lane = s.lane,
+                    continuesLeft = s.event.coversDay(days.first().minus(1, DateTimeUnit.DAY), zone),
+                    continuesRight = s.event.coversDay(days.last().plus(1, DateTimeUnit.DAY), zone),
+                )
+            }
+            MonthWeek(
+                days = days,
+                spans = spans,
+                timedByDay = days.associateWith { d ->
+                    singles.filter { it.coversDay(d, zone) }.sortedBy { it.start }
+                },
+                countByDay = days.associateWith { d -> weekEvents.count { it.coversDay(d, zone) } },
+            )
+        }
+    }
 }
 
 /**

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

@@ -0,0 +1,163 @@
+package de.jeanlucmakiola.calendula.ui.permission
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+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.navigationBarsPadding
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Lock
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.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
+
+/** MD3 8dp spacing scale shared by the onboarding screens. */
+internal object OnboardingSpace {
+    val xs = 8.dp
+    val sm = 16.dp
+    val md = 24.dp
+    val lg = 32.dp
+    val xl = 48.dp
+}
+
+/**
+ * Shared onboarding shell (calendar grant, reminder step): a scrollable,
+ * centred hero + body with the call(s) to action pinned to the bottom (clear
+ * of the navigation bar). The content slot is centred horizontally; benefit
+ * rows fill the width so their own content left-aligns.
+ */
+@Composable
+internal fun OnboardingScaffold(
+    hero: @Composable () -> Unit,
+    actions: @Composable ColumnScope.() -> Unit,
+    modifier: Modifier = Modifier,
+    body: @Composable ColumnScope.() -> Unit,
+) {
+    Scaffold(
+        modifier = modifier,
+        containerColor = MaterialTheme.colorScheme.surface,
+        bottomBar = {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .navigationBarsPadding()
+                    .padding(horizontal = OnboardingSpace.md, vertical = OnboardingSpace.sm),
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.spacedBy(4.dp),
+                content = actions,
+            )
+        },
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(innerPadding)
+                .verticalScroll(rememberScrollState())
+                .padding(horizontal = OnboardingSpace.md),
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Spacer(Modifier.height(OnboardingSpace.xl))
+            hero()
+            Spacer(Modifier.height(OnboardingSpace.lg))
+            body()
+            Spacer(Modifier.height(OnboardingSpace.md))
+        }
+    }
+}
+
+/** The app's adaptive launcher mark, reconstructed as a large branded squircle. */
+@Composable
+internal fun BrandHero(denied: Boolean) {
+    Box(contentAlignment = Alignment.Center) {
+        Box(
+            modifier = Modifier
+                .size(128.dp)
+                .clip(RoundedCornerShape(34.dp))
+                .background(colorResource(R.color.ic_launcher_background)),
+        ) {
+            Image(
+                painter = painterResource(R.drawable.ic_launcher_foreground),
+                contentDescription = stringResource(R.string.app_name),
+                modifier = Modifier.fillMaxSize(),
+            )
+        }
+        if (denied) {
+            // A small lock badge sits over the corner to signal "blocked".
+            Box(
+                modifier = Modifier
+                    .align(Alignment.BottomEnd)
+                    .offset(x = 10.dp, y = 10.dp)
+                    .size(44.dp)
+                    .clip(CircleShape)
+                    .background(MaterialTheme.colorScheme.errorContainer),
+                contentAlignment = Alignment.Center,
+            ) {
+                Icon(
+                    imageVector = Icons.Filled.Lock,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.onErrorContainer,
+                    modifier = Modifier.size(24.dp),
+                )
+            }
+        }
+    }
+}
+
+/** One trust point: a tonal icon chip on the left, title + supporting text right. */
+@Composable
+internal fun BenefitRow(icon: ImageVector, title: String, body: String) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Box(
+            modifier = Modifier
+                .size(44.dp)
+                .clip(CircleShape)
+                .background(MaterialTheme.colorScheme.secondaryContainer),
+            contentAlignment = Alignment.Center,
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.onSecondaryContainer,
+                modifier = Modifier.size(22.dp),
+            )
+        }
+        Spacer(Modifier.width(OnboardingSpace.sm))
+        Column(modifier = Modifier.weight(1f)) {
+            Text(text = title, style = MaterialTheme.typography.titleMedium)
+            Text(
+                text = body,
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+    }
+}

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

@@ -6,25 +6,14 @@ import android.net.Uri
 import android.provider.Settings
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ColumnScope
 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.navigationBarsPadding
-import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowForward
 import androidx.compose.material.icons.filled.CalendarMonth
@@ -34,7 +23,6 @@ import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
@@ -42,28 +30,19 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 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.platform.LocalContext
-import androidx.compose.ui.res.colorResource
-import androidx.compose.ui.res.painterResource
 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 androidx.compose.foundation.Image
 import de.jeanlucmakiola.calendula.R
 
-// MD3 8dp spacing scale, scoped to this screen.
-private object Space {
-    val xs = 8.dp
-    val sm = 16.dp
-    val md = 24.dp
-    val lg = 32.dp
-    val xl = 48.dp
-}
+private val CALENDAR_PERMISSIONS = arrayOf(
+    Manifest.permission.READ_CALENDAR,
+    Manifest.permission.WRITE_CALENDAR,
+)
 
 @Composable
 fun PermissionScreen(
@@ -73,10 +52,17 @@ fun PermissionScreen(
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
 
+    // READ and WRITE are requested together (one system dialog — same
+    // permission group), but only READ gates the app: declining write keeps
+    // Calendula usable read-only.
     val launcher = rememberLauncherForActivityResult(
-        contract = ActivityResultContracts.RequestPermission(),
-    ) { granted ->
-        if (granted) viewModel.onGranted() else viewModel.onDenied()
+        contract = ActivityResultContracts.RequestMultiplePermissions(),
+    ) { results ->
+        if (results[Manifest.permission.READ_CALENDAR] == true) {
+            viewModel.onGranted()
+        } else {
+            viewModel.onDenied()
+        }
     }
 
     LaunchedEffect(state) {
@@ -85,13 +71,13 @@ fun PermissionScreen(
 
     when (state) {
         is PermissionUiState.Rationale -> RationaleContent(
-            onRequest = { launcher.launch(Manifest.permission.READ_CALENDAR) },
+            onRequest = { launcher.launch(CALENDAR_PERMISSIONS) },
             modifier = modifier,
         )
         is PermissionUiState.Denied -> DeniedContent(
             onRetry = {
                 viewModel.onRetry()
-                launcher.launch(Manifest.permission.READ_CALENDAR)
+                launcher.launch(CALENDAR_PERMISSIONS)
             },
             modifier = modifier,
         )
@@ -106,7 +92,7 @@ private fun RationaleContent(
     onRequest: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    PermissionScaffold(
+    OnboardingScaffold(
         modifier = modifier,
         hero = { BrandHero(denied = false) },
         actions = {
@@ -119,7 +105,7 @@ private fun RationaleContent(
                     text = stringResource(R.string.permission_request_button),
                     style = MaterialTheme.typography.titleMedium,
                 )
-                Spacer(Modifier.width(Space.xs))
+                Spacer(Modifier.width(OnboardingSpace.xs))
                 Icon(
                     imageVector = Icons.AutoMirrored.Filled.ArrowForward,
                     contentDescription = null,
@@ -135,7 +121,7 @@ private fun RationaleContent(
             color = MaterialTheme.colorScheme.primary,
             letterSpacing = 2.sp,
         )
-        Spacer(Modifier.height(Space.xs))
+        Spacer(Modifier.height(OnboardingSpace.xs))
         Text(
             text = stringResource(R.string.permission_rationale_title),
             style = MaterialTheme.typography.headlineMedium,
@@ -149,20 +135,20 @@ private fun RationaleContent(
             textAlign = TextAlign.Center,
         )
 
-        Spacer(Modifier.height(Space.xl))
+        Spacer(Modifier.height(OnboardingSpace.xl))
 
         BenefitRow(
             icon = Icons.Filled.Lock,
             title = stringResource(R.string.permission_benefit_private_title),
             body = stringResource(R.string.permission_benefit_private_body),
         )
-        Spacer(Modifier.height(Space.sm))
+        Spacer(Modifier.height(OnboardingSpace.sm))
         BenefitRow(
             icon = Icons.Filled.CalendarMonth,
             title = stringResource(R.string.permission_benefit_sync_title),
             body = stringResource(R.string.permission_benefit_sync_body),
         )
-        Spacer(Modifier.height(Space.sm))
+        Spacer(Modifier.height(OnboardingSpace.sm))
         BenefitRow(
             icon = Icons.Filled.VisibilityOff,
             title = stringResource(R.string.permission_benefit_privacy_title),
@@ -177,7 +163,7 @@ private fun DeniedContent(
     modifier: Modifier = Modifier,
 ) {
     val context = LocalContext.current
-    PermissionScaffold(
+    OnboardingScaffold(
         modifier = modifier,
         hero = { BrandHero(denied = true) },
         actions = {
@@ -219,122 +205,6 @@ private fun DeniedContent(
     }
 }
 
-/**
- * Shared onboarding shell: a scrollable, centred hero + body with the call(s) to
- * action pinned to the bottom (clear of the navigation bar). The content slot is
- * centred horizontally; benefit rows fill the width so their own content
- * left-aligns.
- */
-@Composable
-private fun PermissionScaffold(
-    hero: @Composable () -> Unit,
-    actions: @Composable ColumnScope.() -> Unit,
-    modifier: Modifier = Modifier,
-    body: @Composable ColumnScope.() -> Unit,
-) {
-    Scaffold(
-        modifier = modifier,
-        containerColor = MaterialTheme.colorScheme.surface,
-        bottomBar = {
-            Column(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .navigationBarsPadding()
-                    .padding(horizontal = Space.md, vertical = Space.sm),
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.spacedBy(4.dp),
-                content = actions,
-            )
-        },
-    ) { innerPadding ->
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(innerPadding)
-                .verticalScroll(rememberScrollState())
-                .padding(horizontal = Space.md),
-            horizontalAlignment = Alignment.CenterHorizontally,
-        ) {
-            Spacer(Modifier.height(Space.xl))
-            hero()
-            Spacer(Modifier.height(Space.lg))
-            body()
-            Spacer(Modifier.height(Space.md))
-        }
-    }
-}
-
-/** The app's adaptive launcher mark, reconstructed as a large branded squircle. */
-@Composable
-private fun BrandHero(denied: Boolean) {
-    Box(contentAlignment = Alignment.Center) {
-        Box(
-            modifier = Modifier
-                .size(128.dp)
-                .clip(RoundedCornerShape(34.dp))
-                .background(colorResource(R.color.ic_launcher_background)),
-        ) {
-            Image(
-                painter = painterResource(R.drawable.ic_launcher_foreground),
-                contentDescription = stringResource(R.string.app_name),
-                modifier = Modifier.fillMaxSize(),
-            )
-        }
-        if (denied) {
-            // A small lock badge sits over the corner to signal "blocked".
-            Box(
-                modifier = Modifier
-                    .align(Alignment.BottomEnd)
-                    .offset(x = 10.dp, y = 10.dp)
-                    .size(44.dp)
-                    .clip(CircleShape)
-                    .background(MaterialTheme.colorScheme.errorContainer),
-                contentAlignment = Alignment.Center,
-            ) {
-                Icon(
-                    imageVector = Icons.Filled.Lock,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.onErrorContainer,
-                    modifier = Modifier.size(24.dp),
-                )
-            }
-        }
-    }
-}
-
-/** One trust point: a tonal icon chip on the left, title + supporting text right. */
-@Composable
-private fun BenefitRow(icon: ImageVector, title: String, body: String) {
-    Row(
-        modifier = Modifier.fillMaxWidth(),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Box(
-            modifier = Modifier
-                .size(44.dp)
-                .clip(CircleShape)
-                .background(MaterialTheme.colorScheme.secondaryContainer),
-            contentAlignment = Alignment.Center,
-        ) {
-            Icon(
-                imageVector = icon,
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.onSecondaryContainer,
-                modifier = Modifier.size(22.dp),
-            )
-        }
-        Spacer(Modifier.width(Space.sm))
-        Column(modifier = Modifier.weight(1f)) {
-            Text(text = title, style = MaterialTheme.typography.titleMedium)
-            Text(
-                text = body,
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
-        }
-    }
-}
-
 @Composable
 private fun PrivacyFootnote() {
     Row(

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

@@ -0,0 +1,138 @@
+package de.jeanlucmakiola.calendula.ui.permission
+
+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
+ * 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).
+ *
+ * Reminders default ON: [onFinished] gets true from the primary action even
+ * if the system dialog is declined — the OS permission is the real gate, and
+ * the Settings toggle re-requests it. "Not now" turns the in-app toggle off.
+ */
+@Composable
+fun ReminderOnboardingScreen(
+    onFinished: (remindersEnabled: Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val launcher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.RequestPermission(),
+    ) { onFinished(true) }
+
+    OnboardingScaffold(
+        modifier = modifier,
+        hero = { BellHero() },
+        actions = {
+            Button(
+                onClick = {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                        launcher.launch(Manifest.permission.POST_NOTIFICATIONS)
+                    } else {
+                        onFinished(true)
+                    }
+                },
+                modifier = Modifier.fillMaxWidth().height(56.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.reminder_onboarding_enable_button),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+            }
+            TextButton(
+                onClick = { onFinished(false) },
+                modifier = Modifier.fillMaxWidth(),
+            ) {
+                Text(stringResource(R.string.reminder_onboarding_skip_button))
+            }
+        },
+    ) {
+        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,
+            textAlign = TextAlign.Center,
+        )
+        Spacer(Modifier.height(12.dp))
+        Text(
+            text = stringResource(R.string.reminder_onboarding_body),
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+        )
+
+        Spacer(Modifier.height(OnboardingSpace.xl))
+
+        BenefitRow(
+            icon = Icons.Filled.NotificationsActive,
+            title = stringResource(R.string.reminder_benefit_delivery_title),
+            body = stringResource(R.string.reminder_benefit_delivery_body),
+        )
+        Spacer(Modifier.height(OnboardingSpace.sm))
+        BenefitRow(
+            icon = Icons.Filled.ContentCopy,
+            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/permission/ReminderOnboardingViewModel.kt

@@ -0,0 +1,39 @@
+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 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,
+) : 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()
+        }
+    }
+}

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

@@ -1,301 +1,582 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
+import android.Manifest
+import android.content.Context
 import android.content.Intent
-import androidx.activity.compose.BackHandler
-import androidx.core.net.toUri
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
 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.padding
+import androidx.compose.foundation.layout.requiredSize
+import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
+import androidx.compose.foundation.shape.CircleShape
+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.ArrowDropDown
-import androidx.compose.material3.DropdownMenu
-import androidx.compose.material3.DropdownMenuItem
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material.icons.filled.CalendarMonth
+import androidx.compose.material.icons.filled.Gavel
+import androidx.compose.material.icons.filled.Language
+import androidx.compose.material.icons.filled.Notifications
+import androidx.compose.material.icons.filled.Palette
+import androidx.compose.material.icons.filled.Tune
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
-import androidx.compose.material3.TopAppBar
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.colorResource
+import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
+import androidx.core.net.toUri
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
+import de.jeanlucmakiola.calendula.domain.EventFormField
+import de.jeanlucmakiola.calendula.ui.common.CollapsingScaffold
+import de.jeanlucmakiola.calendula.ui.common.GroupedRow
+import de.jeanlucmakiola.calendula.ui.common.OptionCard
+import de.jeanlucmakiola.calendula.ui.common.Position
+import de.jeanlucmakiola.calendula.ui.common.positionOf
+import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
+
+/** The settings sub-screens reached from the hub's category rows. */
+private enum class SettingsSection { Appearance, EventForm, Notifications }
 
 /**
- * Settings (M4) — appearance (theme, dynamic colour, week start), language,
- * and an about section. A full-screen destination; [onBack] pops it.
+ * Token-based accent for a leading icon chip (container / on-container pair).
+ * Neutral chips stay grey; accents are drawn from the M3 scheme so they adapt
+ * to theme, dark mode and dynamic colour.
+ */
+private enum class ChipAccent { Neutral, Primary, Tertiary }
+
+/**
+ * Settings (M4), restructured in v2.3 into a category hub with sub-screens.
+ * Both the hub and the sub-screens use a collapsing [LargeTopAppBar] and the
+ * grouped-row card system. Calendars opens the separate manager hoisted in
+ * [CalendarHost]; Language opens an inline OptionCard dialog; About is a card
+ * at the top. A full-screen destination; [onBack] pops it.
  */
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun SettingsScreen(
     onBack: () -> Unit,
+    onManageCalendars: () -> Unit,
     modifier: Modifier = Modifier,
     viewModel: SettingsViewModel = hiltViewModel(),
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
+    var section by rememberSaveable { mutableStateOf<SettingsSection?>(null) }
+    val slideSpec = rememberCalendarSlideSpec()
 
-    // Intercept the system back button/gesture — without this it falls through
-    // to the activity and closes the app instead of returning to the calendar.
-    BackHandler { onBack() }
-
-    Scaffold(
+    Box(
         modifier = modifier
             .fillMaxSize()
             .background(MaterialTheme.colorScheme.surface),
-        topBar = {
-            TopAppBar(
-                title = { Text(stringResource(R.string.settings_title)) },
-                navigationIcon = {
-                    IconButton(onClick = onBack) {
-                        Icon(
-                            Icons.AutoMirrored.Filled.ArrowBack,
-                            contentDescription = stringResource(R.string.settings_back),
-                        )
-                    }
-                },
-            )
-        },
-    ) { innerPadding ->
-        Column(
-            modifier = Modifier
-                .padding(innerPadding)
-                .fillMaxSize()
-                .verticalScroll(rememberScrollState()),
     ) {
-            SectionHeader(stringResource(R.string.settings_section_appearance))
-
-            SettingDropdownRow(
-                title = stringResource(R.string.settings_theme),
-                selected = state.themeMode,
-                options = ThemeMode.entries,
-                optionLabel = { themeLabel(it) },
-                onSelect = viewModel::setThemeMode,
-            )
-            DynamicColorRow(
-                checked = state.dynamicColor,
-                enabled = state.dynamicColorAvailable,
-                onCheckedChange = viewModel::setDynamicColor,
-            )
-            SettingDropdownRow(
-                title = stringResource(R.string.settings_week_start),
-                selected = state.weekStart,
-                options = WeekStartPref.entries,
-                optionLabel = { weekStartLabel(it) },
-                onSelect = viewModel::setWeekStart,
+        SettingsHub(
+            onBack = onBack,
+            onOpenSection = { section = it },
+            onManageCalendars = onManageCalendars,
         )
 
-            HorizontalDivider(Modifier.padding(vertical = 8.dp))
-            SectionHeader(stringResource(R.string.settings_section_language))
-            LanguageRow()
-
-            HorizontalDivider(Modifier.padding(vertical = 8.dp))
-            SectionHeader(stringResource(R.string.settings_section_about))
-            AboutSection()
-            Spacer(Modifier.height(24.dp))
+        AnimatedVisibility(
+            visible = section == SettingsSection.Appearance,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
+        ) {
+            AppearanceScreen(state = state, viewModel = viewModel, onBack = { section = null })
+        }
+        AnimatedVisibility(
+            visible = section == SettingsSection.EventForm,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
+        ) {
+            EventFormScreen(state = state, viewModel = viewModel, onBack = { section = null })
+        }
+        AnimatedVisibility(
+            visible = section == SettingsSection.Notifications,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
+        ) {
+            NotificationsScreen(state = state, viewModel = viewModel, onBack = { section = null })
         }
     }
 }
 
+// ---------------------------------------------------------------------------
+// Hub
+// ---------------------------------------------------------------------------
+
 @Composable
-private fun LanguageRow() {
+private fun SettingsHub(
+    onBack: () -> Unit,
+    onOpenSection: (SettingsSection) -> Unit,
+    onManageCalendars: () -> Unit,
+) {
+    CollapsingScaffold(title = stringResource(R.string.settings_title), onBack = onBack) {
+        Box(Modifier.padding(horizontal = 16.dp)) { AboutCard() }
+        Spacer(Modifier.height(16.dp))
+
+        GroupedRow(
+            title = stringResource(R.string.settings_section_appearance),
+            summary = stringResource(R.string.settings_appearance_subtitle),
+            position = Position.Top,
+            leading = { CategoryIcon(Icons.Default.Palette, ChipAccent.Neutral) },
+            onClick = { onOpenSection(SettingsSection.Appearance) },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_section_event_form),
+            summary = stringResource(R.string.settings_event_form_subtitle),
+            position = Position.Middle,
+            leading = { CategoryIcon(Icons.Default.Tune, ChipAccent.Neutral) },
+            onClick = { onOpenSection(SettingsSection.EventForm) },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_section_notifications),
+            summary = stringResource(R.string.settings_notifications_subtitle),
+            position = Position.Middle,
+            leading = { CategoryIcon(Icons.Default.Notifications, ChipAccent.Primary) },
+            onClick = { onOpenSection(SettingsSection.Notifications) },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_section_calendars),
+            summary = stringResource(R.string.settings_manage_calendars_hint),
+            position = Position.Middle,
+            leading = { CategoryIcon(Icons.Default.CalendarMonth, ChipAccent.Tertiary) },
+            onClick = onManageCalendars,
+        )
+        LanguageRow(position = Position.Bottom)
+
+        AppVersionText()
+    }
+}
+
+@Composable
+private fun LanguageRow(position: Position) {
     // Setting a locale recreates the activity; mirror the choice locally so the
-    // dropdown updates instantly even before the recreation lands.
+    // row updates instantly even before the recreation lands.
     var current by remember { mutableStateOf(AppLanguage.current()) }
-    SettingDropdownRow(
+    var showDialog by remember { mutableStateOf(false) }
+
+    GroupedRow(
+        title = stringResource(R.string.settings_language),
+        summary = languageLabel(current),
+        position = position,
+        leading = { CategoryIcon(Icons.Default.Language, ChipAccent.Neutral) },
+        onClick = { showDialog = true },
+    )
+
+    if (showDialog) {
+        OptionPickerDialog(
             title = stringResource(R.string.settings_language),
-        selected = current,
             options = LanguagePref.entries,
-        optionLabel = { languageLabel(it) },
+            selected = current,
+            label = { languageLabel(it) },
             onSelect = {
                 current = it
                 AppLanguage.apply(it)
             },
+            onDismiss = { showDialog = false },
         )
+    }
 }
 
 @Composable
-private fun SectionHeader(text: String) {
-    Text(
-        text = text,
-        style = MaterialTheme.typography.labelLarge,
-        color = MaterialTheme.colorScheme.primary,
-        modifier = Modifier.padding(start = 24.dp, end = 24.dp, top = 16.dp, bottom = 4.dp),
-    )
-}
+private fun AboutCard() {
+    val context = LocalContext.current
+    val sourceUrl = stringResource(R.string.about_source_url)
+    val licenseUrl = stringResource(R.string.about_license_url)
 
-@Composable
-private fun <T> SettingDropdownRow(
-    title: String,
-    selected: T,
-    options: List<T>,
-    optionLabel: @Composable (T) -> String,
-    onSelect: (T) -> Unit,
-) {
-    var expanded by remember { mutableStateOf(false) }
-    Box {
-        Row(
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        shape = RoundedCornerShape(24.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Column(
             modifier = Modifier
                 .fillMaxWidth()
-                .clickable { expanded = true }
-                .padding(horizontal = 24.dp, vertical = 16.dp),
-            verticalAlignment = Alignment.CenterVertically,
+                .padding(16.dp),
         ) {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                AppLogo()
+                Spacer(Modifier.width(16.dp))
+                Column(Modifier.weight(1f)) {
                     Text(
-                text = title,
-                style = MaterialTheme.typography.bodyLarge,
-                modifier = Modifier.weight(1f),
+                        text = stringResource(R.string.app_name),
+                        style = MaterialTheme.typography.titleLarge,
                     )
                     Text(
-                text = optionLabel(selected),
+                        text = stringResource(R.string.settings_about_author),
                         style = MaterialTheme.typography.bodyMedium,
                         color = MaterialTheme.colorScheme.onSurfaceVariant,
                     )
-            Icon(
-                Icons.Default.ArrowDropDown,
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
-        }
-        DropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) {
-            options.forEach { option ->
-                DropdownMenuItem(
-                    text = { Text(optionLabel(option)) },
-                    onClick = {
-                        expanded = false
-                        onSelect(option)
-                    },
-                )
                 }
             }
-    }
-}
-
-@Composable
-private fun DynamicColorRow(
-    checked: Boolean,
-    enabled: Boolean,
-    onCheckedChange: (Boolean) -> Unit,
-) {
+            Spacer(Modifier.height(12.dp))
             Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 24.dp, vertical = 12.dp),
-        verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
             ) {
-        Column(Modifier.weight(1f)) {
-            Text(
-                text = stringResource(R.string.settings_dynamic_color),
-                style = MaterialTheme.typography.bodyLarge,
-                color = if (enabled) MaterialTheme.colorScheme.onSurface
-                else MaterialTheme.colorScheme.onSurfaceVariant,
+                OutlinedButton(
+                    onClick = { openUrl(context, sourceUrl) },
+                    contentPadding = PaddingValues(horizontal = 12.dp),
+                    modifier = Modifier.weight(1f),
+                ) {
+                    Icon(
+                        painter = painterResource(R.drawable.ic_gitea),
+                        contentDescription = null,
+                        modifier = Modifier.size(18.dp),
                     )
-            if (!enabled) {
-                Text(
-                    text = stringResource(R.string.settings_dynamic_color_unavailable),
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    Spacer(Modifier.width(8.dp))
+                    Text(stringResource(R.string.settings_about_source))
+                }
+                OutlinedButton(
+                    onClick = { openUrl(context, licenseUrl) },
+                    contentPadding = PaddingValues(horizontal = 12.dp),
+                    modifier = Modifier.weight(1f),
+                ) {
+                    Icon(
+                        Icons.Default.Gavel,
+                        contentDescription = null,
+                        modifier = Modifier.size(18.dp),
                     )
+                    Spacer(Modifier.width(8.dp))
+                    Text(stringResource(R.string.settings_license))
+                }
             }
         }
-        Switch(
-            checked = checked,
-            onCheckedChange = onCheckedChange,
-            enabled = enabled,
-        )
     }
 }
 
+/** Plain centred version mark at the foot of the settings list (no card). */
 @Composable
-private fun AboutSection() {
+private fun AppVersionText() {
     val context = LocalContext.current
     val versionName = remember {
         runCatching {
             context.packageManager.getPackageInfo(context.packageName, 0).versionName
         }.getOrNull() ?: "—"
     }
-    val sourceUrl = stringResource(R.string.about_source_url)
-
-    AboutRow(
-        title = stringResource(R.string.settings_version),
-        value = versionName,
-    )
-    AboutRow(
-        title = stringResource(R.string.settings_license),
-        value = stringResource(R.string.settings_license_value),
-    )
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 16.dp, vertical = 4.dp),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Column(Modifier.weight(1f).padding(start = 8.dp)) {
     Text(
-                text = stringResource(R.string.settings_source),
-                style = MaterialTheme.typography.bodyLarge,
-            )
-            Text(
-                text = sourceUrl.removePrefix("https://"),
+        text = stringResource(R.string.settings_about_version, versionName),
         style = MaterialTheme.typography.bodySmall,
         color = MaterialTheme.colorScheme.onSurfaceVariant,
+        textAlign = TextAlign.Center,
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 16.dp),
+    )
+}
+
+/**
+ * The app icon as a rounded chip: the off-white launcher mark over its slate
+ * background colour, rendered oversized and clipped to fill the chip the way a
+ * launcher mask would.
+ */
+@Composable
+private fun AppLogo() {
+    Box(
+        modifier = Modifier
+            .size(72.dp)
+            .clip(RoundedCornerShape(20.dp))
+            .background(colorResource(R.color.ic_launcher_background)),
+        contentAlignment = Alignment.Center,
+    ) {
+        Image(
+            painter = painterResource(R.drawable.ic_launcher_foreground),
+            contentDescription = stringResource(R.string.settings_about_logo_desc),
+            modifier = Modifier.requiredSize(108.dp),
         )
     }
-        TextButton(onClick = {
-            val intent = Intent(Intent.ACTION_VIEW, sourceUrl.toUri())
-            runCatching { context.startActivity(intent) }
-        }) {
-            Text(stringResource(R.string.settings_source_open))
+}
+
+// ---------------------------------------------------------------------------
+// Sub-screens
+// ---------------------------------------------------------------------------
+
+@Composable
+private fun AppearanceScreen(
+    state: SettingsUiState,
+    viewModel: SettingsViewModel,
+    onBack: () -> Unit,
+) {
+    var showTheme by remember { mutableStateOf(false) }
+    var showWeekStart by remember { mutableStateOf(false) }
+
+    CollapsingScaffold(
+        title = stringResource(R.string.settings_section_appearance),
+        onBack = onBack,
+    ) {
+        GroupedRow(
+            title = stringResource(R.string.settings_theme),
+            summary = themeLabel(state.themeMode),
+            position = Position.Top,
+            onClick = { showTheme = true },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_dynamic_color),
+            summary = if (state.dynamicColorAvailable) {
+                null
+            } else {
+                stringResource(R.string.settings_dynamic_color_unavailable)
+            },
+            position = Position.Middle,
+            trailing = {
+                Switch(
+                    checked = state.dynamicColor,
+                    onCheckedChange = viewModel::setDynamicColor,
+                    enabled = state.dynamicColorAvailable,
+                )
+            },
+            onClick = if (state.dynamicColorAvailable) {
+                { viewModel.setDynamicColor(!state.dynamicColor) }
+            } else {
+                null
+            },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_week_start),
+            summary = weekStartLabel(state.weekStart),
+            position = Position.Bottom,
+            onClick = { showWeekStart = true },
+        )
     }
+
+    if (showTheme) {
+        OptionPickerDialog(
+            title = stringResource(R.string.settings_theme),
+            options = ThemeMode.entries,
+            selected = state.themeMode,
+            label = { themeLabel(it) },
+            onSelect = viewModel::setThemeMode,
+            onDismiss = { showTheme = false },
+        )
+    }
+    if (showWeekStart) {
+        OptionPickerDialog(
+            title = stringResource(R.string.settings_week_start),
+            options = WeekStartPref.entries,
+            selected = state.weekStart,
+            label = { weekStartLabel(it) },
+            onSelect = viewModel::setWeekStart,
+            onDismiss = { showWeekStart = false },
+        )
     }
 }
 
 @Composable
-private fun AboutRow(title: String, value: String) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 24.dp, vertical = 12.dp),
-        verticalAlignment = Alignment.CenterVertically,
+private fun EventFormScreen(
+    state: SettingsUiState,
+    viewModel: SettingsViewModel,
+    onBack: () -> Unit,
+) {
+    CollapsingScaffold(
+        title = stringResource(R.string.settings_section_event_form),
+        onBack = onBack,
     ) {
         Text(
-            text = title,
-            style = MaterialTheme.typography.bodyLarge,
-            modifier = Modifier.weight(1f),
-        )
-        Text(
-            text = value,
+            text = stringResource(R.string.settings_form_fields_hint),
             style = MaterialTheme.typography.bodyMedium,
             color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp),
+        )
+        Spacer(Modifier.height(8.dp))
+        val fields = EventFormField.entries
+        fields.forEachIndexed { index, field ->
+            val checked = field in state.defaultFormFields
+            GroupedRow(
+                title = stringResource(formFieldLabel(field)),
+                position = positionOf(index, fields.size),
+                trailing = {
+                    Switch(
+                        checked = checked,
+                        onCheckedChange = { viewModel.setFormFieldDefault(field, it) },
+                    )
+                },
+                onClick = { viewModel.setFormFieldDefault(field, !checked) },
             )
-        Spacer(Modifier.width(8.dp))
         }
+
+        // Per-event colour on calendars that publish no colour set (some
+        // CalDAV) — off by default, with the honest caveat that the colour may
+        // not survive their next sync. Local and palette calendars ignore it.
+        Spacer(Modifier.height(24.dp))
+        GroupedRow(
+            title = stringResource(R.string.settings_color_unsupported),
+            summary = stringResource(R.string.settings_color_unsupported_hint),
+            position = Position.Alone,
+            trailing = {
+                Switch(
+                    checked = state.allowColorOnUnsupportedCalendars,
+                    onCheckedChange = { viewModel.setAllowColorOnUnsupportedCalendars(it) },
+                )
+            },
+            onClick = {
+                viewModel.setAllowColorOnUnsupportedCalendars(
+                    !state.allowColorOnUnsupportedCalendars,
+                )
+            },
+        )
+    }
+}
+
+/**
+ * Reminder-notifications toggle (v1.4), mirroring the onboarding step.
+ * Turning it on re-requests `POST_NOTIFICATIONS` when missing (API 33+) —
+ * the pref is set either way; the OS permission is the real gate.
+ */
+@Composable
+private fun NotificationsScreen(
+    state: SettingsUiState,
+    viewModel: SettingsViewModel,
+    onBack: () -> Unit,
+) {
+    val context = LocalContext.current
+    val launcher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.RequestPermission(),
+    ) { /* The pref is already on; a denial just leaves the OS gate shut. */ }
+    val toggleReminders: (Boolean) -> Unit = { enabled ->
+        viewModel.setRemindersEnabled(enabled)
+        val needsPermission = enabled &&
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
+            ContextCompat.checkSelfPermission(
+                context, Manifest.permission.POST_NOTIFICATIONS,
+            ) != PackageManager.PERMISSION_GRANTED
+        if (needsPermission) {
+            launcher.launch(Manifest.permission.POST_NOTIFICATIONS)
+        }
+    }
+
+    CollapsingScaffold(
+        title = stringResource(R.string.settings_section_notifications),
+        onBack = onBack,
+    ) {
+        GroupedRow(
+            title = stringResource(R.string.settings_reminders),
+            summary = stringResource(R.string.settings_reminders_hint),
+            position = Position.Alone,
+            trailing = {
+                Switch(checked = state.remindersEnabled, onCheckedChange = toggleReminders)
+            },
+            onClick = { toggleReminders(!state.remindersEnabled) },
+        )
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Shared building blocks
+// ---------------------------------------------------------------------------
+
+/**
+ * Leading circular icon chip. Colours come from the M3 scheme via a container /
+ * on-container token pair, so each accent stays correctly paired across theme,
+ * dark mode and dynamic colour.
+ */
+@Composable
+private fun CategoryIcon(icon: ImageVector, accent: ChipAccent) {
+    val scheme = MaterialTheme.colorScheme
+    val (background, iconColor) = when (accent) {
+        ChipAccent.Neutral -> scheme.surfaceContainerHighest to scheme.onSurfaceVariant
+        ChipAccent.Primary -> scheme.primaryContainer to scheme.onPrimaryContainer
+        ChipAccent.Tertiary -> scheme.tertiaryContainer to scheme.onTertiaryContainer
+    }
+    Box(
+        modifier = Modifier
+            .size(40.dp)
+            .clip(CircleShape)
+            .background(background),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = null,
+            tint = iconColor,
+            modifier = Modifier.size(22.dp),
+        )
+    }
+}
+
+/** OptionCard selection dialog — the app's only sanctioned picker style. */
+@Composable
+private fun <T> OptionPickerDialog(
+    title: String,
+    options: List<T>,
+    selected: T,
+    label: @Composable (T) -> String,
+    onSelect: (T) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(title) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                options.forEach { option ->
+                    OptionCard(
+                        label = label(option),
+                        onClick = {
+                            onSelect(option)
+                            onDismiss()
+                        },
+                        selected = option == selected,
+                    )
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
+        },
+    )
+}
+
+private fun openUrl(context: Context, url: String) {
+    val intent = Intent(Intent.ACTION_VIEW, url.toUri())
+    runCatching { context.startActivity(intent) }
+}
+
+private fun formFieldLabel(field: EventFormField): Int = when (field) {
+    EventFormField.Location -> R.string.event_detail_location
+    EventFormField.Description -> R.string.event_detail_description
+    EventFormField.Reminders -> R.string.event_detail_reminders
+    EventFormField.Recurrence -> R.string.event_detail_recurrence
+    EventFormField.Availability -> R.string.event_edit_availability
+    EventFormField.Visibility -> R.string.event_edit_visibility
+    EventFormField.Color -> R.string.event_edit_color
 }
 
 @Composable

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

@@ -1,7 +1,9 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
+import de.jeanlucmakiola.calendula.domain.EventFormField
 
 /**
  * Settings screen state (M4). Persisted preferences are instant to read, so
@@ -14,4 +16,13 @@ data class SettingsUiState(
     val dynamicColor: Boolean = true,
     val dynamicColorAvailable: Boolean = true,
     val weekStart: WeekStartPref = WeekStartPref.AUTO,
+    /** Optional event-form fields shown by default (rest behind "more fields"). */
+    val defaultFormFields: Set<EventFormField> = SettingsPrefs.DEFAULT_FORM_FIELDS,
+    /** Whether Calendula posts reminder notifications (v1.4). */
+    val remindersEnabled: Boolean = true,
+    /**
+     * Whether the event-colour picker is offered on calendars that publish no
+     * colour palette (the colour may then not survive their next sync).
+     */
+    val allowColorOnUnsupportedCalendars: Boolean = false,
 )

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

@@ -7,6 +7,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
+import de.jeanlucmakiola.calendula.domain.EventFormField
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.combine
@@ -22,17 +23,28 @@ class SettingsViewModel @Inject constructor(
     private val dynamicColorAvailable = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
 
     val state: StateFlow<SettingsUiState> =
+        combine(
+            // combine() only types up to five flows, so the sixth pref folds
+            // into the assembled state in an outer combine.
             combine(
                 prefs.themeMode,
                 prefs.dynamicColor,
                 prefs.weekStart,
-        ) { theme, dynamic, weekStart ->
+                prefs.defaultFormFields,
+                prefs.remindersEnabled,
+            ) { theme, dynamic, weekStart, formFields, reminders ->
                 SettingsUiState(
                     themeMode = theme,
                     dynamicColor = dynamic && dynamicColorAvailable,
                     dynamicColorAvailable = dynamicColorAvailable,
                     weekStart = weekStart,
+                    defaultFormFields = formFields,
+                    remindersEnabled = reminders,
                 )
+            },
+            prefs.allowColorOnUnsupportedCalendars,
+        ) { base, allowColor ->
+            base.copy(allowColorOnUnsupportedCalendars = allowColor)
         }.stateIn(
             scope = viewModelScope,
             started = SharingStarted.WhileSubscribed(5_000L),
@@ -50,4 +62,16 @@ class SettingsViewModel @Inject constructor(
     fun setWeekStart(pref: WeekStartPref) {
         viewModelScope.launch { prefs.setWeekStart(pref) }
     }
+
+    fun setFormFieldDefault(field: EventFormField, enabled: Boolean) {
+        viewModelScope.launch { prefs.setFormFieldDefault(field, enabled) }
+    }
+
+    fun setRemindersEnabled(enabled: Boolean) {
+        viewModelScope.launch { prefs.setRemindersEnabled(enabled) }
+    }
+
+    fun setAllowColorOnUnsupportedCalendars(enabled: Boolean) {
+        viewModelScope.launch { prefs.setAllowColorOnUnsupportedCalendars(enabled) }
+    }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/theme/Theme.kt

@@ -2,7 +2,9 @@ package de.jeanlucmakiola.calendula.ui.theme
 
 import android.os.Build
 import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.MaterialExpressiveTheme
+import androidx.compose.material3.MotionScheme
 import androidx.compose.material3.dynamicDarkColorScheme
 import androidx.compose.material3.dynamicLightColorScheme
 import androidx.compose.runtime.Composable
@@ -17,6 +19,7 @@ import androidx.compose.ui.platform.LocalContext
  * The Settings screen (later) can override useDynamicColor and themePreference,
  * but the V1 foundation just follows the system.
  */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun CalendulaTheme(
     darkTheme: Boolean = isSystemInDarkTheme(),
@@ -32,9 +35,15 @@ fun CalendulaTheme(
         else -> CalendulaLightFallback
     }
 
-    MaterialTheme(
+    // MaterialExpressiveTheme routes all component + custom motion through
+    // MaterialTheme.motionScheme (switches, chips, pickers, calendar slide,
+    // FAB, field reveal). The STANDARD scheme is a deliberate choice over
+    // expressive(): same spring choreography, but without the overshoot —
+    // the bouncy variant felt overdone in review (2026-06-11).
+    MaterialExpressiveTheme(
         colorScheme = colorScheme,
         typography = CalendulaTypography,
+        motionScheme = MotionScheme.standard(),
         content = content,
     )
 }

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

@@ -1,14 +1,12 @@
 package de.jeanlucmakiola.calendula.ui.week
 
 import androidx.compose.animation.AnimatedContent
-import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.animateDpAsState
-import androidx.compose.animation.scaleIn
-import androidx.compose.animation.scaleOut
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.gestures.detectHorizontalDragGestures
+import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -31,12 +29,10 @@ import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Menu
-import androidx.compose.material.icons.filled.Refresh
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.DrawerValue
 import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.ExtendedFloatingActionButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -77,6 +73,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
+import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
@@ -88,7 +85,10 @@ import de.jeanlucmakiola.calendula.ui.common.pastelize
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
 import kotlinx.datetime.plus
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
 import java.time.format.TextStyle as JavaTextStyle
 import java.util.Locale
 import kotlin.math.roundToInt
@@ -113,6 +113,7 @@ fun WeekScreen(
     onSelectView: (CalendarView) -> Unit,
     onEventClick: (EventInstance) -> Unit,
     onOpenSettings: () -> Unit,
+    onCreateEvent: (LocalDate, Int?) -> Unit,
     modifier: Modifier = Modifier,
     viewModel: WeekViewModel = hiltViewModel(),
 ) {
@@ -146,7 +147,15 @@ fun WeekScreen(
     var slideDir by remember { mutableIntStateOf(0) }
     val goNext = { slideDir = 1; viewModel.goToNext() }
     val goPrev = { slideDir = -1; viewModel.goToPrev() }
-    val jumpToToday = { slideDir = 0; viewModel.goToToday() }
+    // Slide toward today: viewing the future → today comes in from the left
+    // (back), viewing the past → from the right (forward).
+    val jumpToToday = {
+        slideDir = when (val s = state) {
+            is WeekUiState.Success -> if (s.today < s.weekStart) -1 else 1
+            else -> 0
+        }
+        viewModel.goToToday()
+    }
 
     ModalNavigationDrawer(
         drawerState = drawerState,
@@ -154,7 +163,11 @@ fun WeekScreen(
         gesturesEnabled = drawerState.isOpen,
         drawerContent = {
             CalendarDrawer(
-                onToday = { jumpToToday(); scope.launch { drawerState.close() } },
+                currentView = selectedView,
+                onSelectView = { view ->
+                    onSelectView(view)
+                    scope.launch { drawerState.close() }
+                },
                 onSettings = {
                     onOpenSettings()
                     scope.launch { drawerState.close() }
@@ -174,17 +187,17 @@ fun WeekScreen(
                 )
             },
             floatingActionButton = {
-                AnimatedVisibility(
-                    visible = !isOnCurrentWeek,
-                    enter = scaleIn(),
-                    exit = scaleOut(),
-                ) {
-                    ExtendedFloatingActionButton(
-                        onClick = jumpToToday,
-                        icon = { Icon(Icons.Default.Refresh, contentDescription = null) },
-                        text = { Text(stringResource(R.string.week_today_action)) },
+                CalendarFabColumn(
+                    todayVisible = !isOnCurrentWeek,
+                    todayText = stringResource(R.string.week_today_action),
+                    onToday = jumpToToday,
+                    onCreate = {
+                        // Anchor on today when it's in view, else the week's first day.
+                        val today = Clock.System.now()
+                            .toLocalDateTime(TimeZone.currentSystemDefault()).date
+                        onCreateEvent(if (isOnCurrentWeek) today else weekStart, null)
+                    },
                 )
-                }
             },
         ) { innerPadding ->
             WeekContent(
@@ -195,6 +208,7 @@ fun WeekScreen(
                 onSwipePrev = goPrev,
                 onRetry = jumpToToday,
                 onEventClick = onEventClick,
+                onCreateAt = { d, minutes -> onCreateEvent(d, minutes) },
                 modifier = Modifier
                     .padding(innerPadding)
                     .fillMaxSize(),
@@ -212,6 +226,7 @@ private fun WeekContent(
     onSwipePrev: () -> Unit,
     onRetry: () -> Unit,
     onEventClick: (EventInstance) -> Unit,
+    onCreateAt: (LocalDate, Int) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val density = LocalDensity.current
@@ -283,6 +298,7 @@ private fun WeekContent(
                 scrollState = scrollState,
                 allDayHeight = allDayHeight,
                 onEventClick = onEventClick,
+                onCreateAt = onCreateAt,
             )
         }
     }
@@ -295,6 +311,7 @@ private fun WeekSuccess(
     scrollState: ScrollState,
     allDayHeight: Dp,
     onEventClick: (EventInstance) -> Unit,
+    onCreateAt: (LocalDate, Int) -> Unit,
 ) {
     Column(modifier = Modifier.fillMaxSize()) {
         Column(
@@ -308,7 +325,12 @@ private fun WeekSuccess(
         // Breathing room between the (colour-shifting) top section and the
         // scrolling timeline below.
         Spacer(Modifier.height(8.dp))
-        Timeline(state = state, scrollState = scrollState, onEventClick = onEventClick)
+        Timeline(
+            state = state,
+            scrollState = scrollState,
+            onEventClick = onEventClick,
+            onCreateAt = onCreateAt,
+        )
     }
 }
 
@@ -521,6 +543,7 @@ private fun Timeline(
     state: WeekUiState.Success,
     scrollState: ScrollState,
     onEventClick: (EventInstance) -> Unit,
+    onCreateAt: (LocalDate, Int) -> Unit,
 ) {
     val totalHeight = HOUR_HEIGHT * 24
     val dark = isSystemInDarkTheme()
@@ -576,7 +599,9 @@ private fun Timeline(
                         DayColumnCard(
                             blocks = state.timedByDay[day].orEmpty(),
                             dark = dark,
+                            date = day,
                             onEventClick = onEventClick,
+                            onCreateAt = onCreateAt,
                             modifier = Modifier
                                 .weight(1f)
                                 .fillMaxHeight(),
@@ -592,9 +617,12 @@ private fun Timeline(
 private fun DayColumnCard(
     blocks: List<TimedBlock>,
     dark: Boolean,
+    date: LocalDate,
     onEventClick: (EventInstance) -> Unit,
+    onCreateAt: (LocalDate, Int) -> Unit,
     modifier: Modifier = Modifier,
 ) {
+    val hourPx = with(LocalDensity.current) { HOUR_HEIGHT.toPx() }
     Card(
         // Plain rectangular columns — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -604,7 +632,18 @@ private fun DayColumnCard(
         ),
         modifier = modifier,
     ) {
-        BoxWithConstraints(modifier = Modifier.fillMaxSize()) {
+        BoxWithConstraints(
+            modifier = Modifier
+                .fillMaxSize()
+                // Tap an empty slot to create an event there; taps on event
+                // 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)
+                    }
+                },
+        ) {
             val colWidth = maxWidth
             blocks.forEach { block ->
                 val laneWidth = colWidth / block.laneCount

app/src/main/res/drawable/ic_gitea.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Gitea brand mark, used on the "Source" button in Settings → About.
+    Single-path logo from Simple Icons (https://simpleicons.org, CC0),
+    pathData kept verbatim so Android's PathParser reads the arc flags.
+    fillColor is a placeholder; the Compose Icon recolours it via tint.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M4.209 4.603c-.247 0-.525.02-.84.088-.333.07-1.28.283-2.054 1.027C-.403 7.25.035 9.685.089 10.052c.065.446.263 1.687 1.21 2.768 1.749 2.141 5.513 2.092 5.513 2.092s.462 1.103 1.168 2.119c.955 1.263 1.936 2.248 2.89 2.367 2.406 0 7.212-.004 7.212-.004s.458.004 1.08-.394c.535-.324 1.013-.893 1.013-.893s.492-.527 1.18-1.73c.21-.37.385-.729.538-1.068 0 0 2.107-4.471 2.107-8.823-.042-1.318-.367-1.55-.443-1.627-.156-.156-.366-.153-.366-.153s-4.475.252-6.792.306c-.508.011-1.012.023-1.512.027v4.474l-.634-.301c0-1.39-.004-4.17-.004-4.17-1.107.016-3.405-.084-3.405-.084s-5.399-.27-5.987-.324c-.187-.011-.401-.032-.648-.032zm.354 1.832h.111s.271 2.269.6 3.597C5.549 11.147 6.22 13 6.22 13s-.996-.119-1.641-.348c-.99-.324-1.409-.714-1.409-.714s-.73-.511-1.096-1.52C1.444 8.73 2.021 7.7 2.021 7.7s.32-.859 1.47-1.145c.395-.106.863-.12 1.072-.12zm8.33 2.554c.26.003.509.127.509.127l.868.422-.529 1.075a.686.686 0 0 0-.614.359.685.685 0 0 0 .072.756l-.939 1.924a.69.69 0 0 0-.66.527.687.687 0 0 0 .347.763.686.686 0 0 0 .867-.206.688.688 0 0 0-.069-.882l.916-1.874a.667.667 0 0 0 .237-.02.657.657 0 0 0 .271-.137 8.826 8.826 0 0 1 1.016.512.761.761 0 0 1 .286.282c.073.21-.073.569-.073.569-.087.29-.702 1.55-.702 1.55a.692.692 0 0 0-.676.477.681.681 0 1 0 1.157-.252c.073-.141.141-.282.214-.431.19-.397.515-1.16.515-1.16.035-.066.218-.394.103-.814-.095-.435-.48-.638-.48-.638-.467-.301-1.116-.58-1.116-.58s0-.156-.042-.27a.688.688 0 0 0-.148-.241l.516-1.062 2.89 1.401s.48.218.583.619c.073.282-.019.534-.069.657-.24.587-2.1 4.317-2.1 4.317s-.232.554-.748.588a1.065 1.065 0 0 1-.393-.045l-.202-.08-4.31-2.1s-.417-.218-.49-.596c-.083-.31.104-.691.104-.691l2.073-4.272s.183-.37.466-.497a.855.855 0 0 1 .35-.077z" />
+</vector>

app/src/main/res/drawable/ic_notification.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Monochrome status-bar mark: Material "event" calendar glyph. -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24"
+    android:tint="?attr/colorControlNormal">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M19,3h-1V1h-2v2H8V1H6v2H5C3.89,3 3.01,3.9 3.01,5L3,19c0,1.1 0.89,2 2,2h14c1.1,0 2,-0.9 2,-2V5C21,3.9 20.1,3 19,3zM19,19H5V8h14V19zM7,10h5v5H7V10z" />
+</vector>

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

@@ -13,7 +13,7 @@
 
     <!-- Permission-Flow (F1) -->
     <string name="permission_rationale_title">Alle Termine, schön im Blick</string>
-    <string name="permission_rationale_body">Calendula braucht Lesezugriff auf deinen Kalender, um deine Termine zu zeigen. Mehr verlangt die App nie.</string>
+    <string name="permission_rationale_body">Calendula braucht Zugriff auf deinen Kalender, um deine Termine zu zeigen und zu verwalten. Mehr verlangt die App nie.</string>
     <string name="permission_request_button">Kalender-Zugriff erlauben</string>
     <string name="permission_denied_title">Kalender-Zugriff abgelehnt</string>
     <string name="permission_denied_body">Ohne Kalender-Zugriff kann Calendula keine Termine anzeigen. Du kannst den Zugriff in den System-Einstellungen wieder erlauben.</string>
@@ -25,7 +25,7 @@
     <string name="permission_benefit_sync_body">Google, CalDAV, lokal — alles, was synchronisiert ist, erscheint automatisch.</string>
     <string name="permission_benefit_privacy_title">Kein Tracking, niemals</string>
     <string name="permission_benefit_privacy_body">Keine Telemetrie, keine Analyse, keine Werbung.</string>
-    <string name="permission_privacy_footnote">Nur Lesezugriff · keine Internet-Berechtigung</string>
+    <string name="permission_privacy_footnote">Bleibt auf deinem Gerät · keine Internet-Berechtigung</string>
 
     <!-- Monatsansicht (S1) -->
     <string name="month_prev">Vorheriger Monat</string>
@@ -47,6 +47,77 @@
     <string name="event_detail_back">Zurück</string>
     <string name="event_detail_edit">Bearbeiten</string>
     <string name="event_detail_delete">Löschen</string>
+    <string name="event_delete_title">Termin löschen?</string>
+    <string name="event_delete_body">Der Termin wird aus deinem Kalender und von allen synchronisierten Geräten entfernt.</string>
+    <string name="event_delete_recurring_title">Wiederkehrenden Termin löschen</string>
+    <string name="event_delete_option_occurrence">Nur dieser Termin</string>
+    <string name="event_delete_option_following">Dieser und alle folgenden Termine</string>
+    <string name="event_delete_option_series">Alle Termine der Serie</string>
+    <string name="event_edit_recurring_title">Wiederkehrenden Termin bearbeiten</string>
+    <string name="event_delete_failed">Termin konnte nicht gelöscht werden</string>
+    <string name="event_delete_write_denied">Calendula braucht Schreibzugriff, um Termine zu löschen</string>
+    <string name="dialog_cancel">Abbrechen</string>
+    <string name="dialog_ok">OK</string>
+
+    <!-- Termin-Formular (v1.2 Erstellen) -->
+    <string name="event_edit_new_title">Neuer Termin</string>
+    <string name="event_edit_close">Schließen</string>
+    <string name="event_edit_save">Speichern</string>
+    <string name="event_edit_title_hint">Titel hinzufügen</string>
+    <string name="event_edit_starts">Beginn</string>
+    <string name="event_edit_ends">Ende</string>
+    <string name="event_edit_error_end_before_start">Endet vor dem Beginn</string>
+    <string name="event_edit_error_no_calendar">Kein beschreibbarer Kalender verfügbar</string>
+    <string name="event_edit_save_failed">Termin konnte nicht gespeichert werden</string>
+    <string name="event_edit_write_denied">Calendula braucht Schreibzugriff, um Termine zu erstellen</string>
+    <string name="event_edit_more_fields">Weitere Felder</string>
+    <string name="event_edit_add">Hinzufügen</string>
+    <string name="event_edit_add_reminder">Erinnerung hinzufügen</string>
+    <string name="event_edit_remove_reminder">Erinnerung entfernen</string>
+    <string name="event_edit_reminder_custom">Benutzerdefiniert</string>
+    <string name="reminder_unit_minutes">Minuten</string>
+    <string name="reminder_unit_hours">Stunden</string>
+    <string name="reminder_unit_days">Tage</string>
+    <string name="reminder_unit_weeks">Wochen</string>
+    <string name="event_edit_availability">Verfügbarkeit</string>
+    <string name="event_edit_visibility">Sichtbarkeit</string>
+
+    <!-- Termin-Formular — eigene Terminfarbe -->
+    <string name="event_edit_color">Farbe</string>
+    <string name="event_edit_color_default">Kalenderfarbe</string>
+    <string name="event_edit_color_custom">Eigene Farbe</string>
+    <string name="event_edit_color_reset">Zurücksetzen</string>
+    <string name="event_edit_color_unsupported">Für diesen Kalender nicht verfügbar</string>
+    <string name="event_edit_color_unsupported_hint">Dieser Kalender stellt keine Farbpalette bereit. Du kannst eigene Farben für solche Kalender in den Einstellungen aktivieren.</string>
+    <string name="event_edit_color_sync_warning">Dieser Kalender verwirft oder überschreibt die Farbe unter Umständen bei der nächsten Synchronisierung.</string>
+
+    <!-- Termin-Formular — Speicher-Konflikt (v2.0) -->
+    <string name="event_edit_conflict_title">Termin wurde extern geändert</string>
+    <string name="event_edit_conflict_body">Während du bearbeitet hast, wurde dieser Termin anderswo geändert — durch Synchronisierung oder eine andere App. Was soll mit deinen Änderungen passieren?</string>
+    <string name="event_edit_conflict_overwrite">Meine Änderungen speichern</string>
+    <string name="event_edit_conflict_overwrite_hint">Nur von dir bearbeitete Felder überschreiben die externe Änderung</string>
+    <string name="event_edit_conflict_discard">Meine Änderungen verwerfen</string>
+    <string name="event_edit_conflict_discard_hint">Der Termin bleibt, wie er jetzt ist</string>
+    <string name="event_edit_gone_title">Termin wurde gelöscht</string>
+    <string name="event_edit_gone_body">Dieser Termin wurde zwischenzeitlich gelöscht, etwa auf einem anderen Gerät. Deine Änderungen können nicht mehr gespeichert werden.</string>
+
+    <!-- Termin-Formular — Wiederholungs-Picker (v1.3) -->
+    <string name="event_edit_recurrence_none">Wiederholt sich nicht</string>
+    <string name="event_edit_recurrence_custom">Benutzerdefiniert</string>
+    <string name="event_edit_recurrence_every">Alle</string>
+    <string name="recurrence_unit_days">Tage</string>
+    <string name="recurrence_unit_weeks">Wochen</string>
+    <string name="recurrence_unit_months">Monate</string>
+    <string name="recurrence_unit_years">Jahre</string>
+    <string name="event_edit_recurrence_ends">Endet</string>
+    <string name="event_edit_recurrence_end_never">Nie</string>
+    <string name="event_edit_recurrence_end_until">An einem Datum</string>
+    <string name="event_edit_recurrence_end_count">Nach einer Anzahl</string>
+    <string name="event_edit_recurrence_times">Mal</string>
+    <string name="event_edit_error_recurrence_ends_before_start">Wiederholung endet vor dem Beginn</string>
+    <string name="event_availability_busy">Beschäftigt</string>
+    <string name="event_access_default">Standard</string>
+    <string name="event_access_public">Öffentlich</string>
     <string name="event_detail_all_day">Ganztägig</string>
     <string name="event_detail_calendar">Kalender</string>
     <string name="event_detail_calendar_unknown">Unbekannter Kalender</string>
@@ -107,10 +178,25 @@
     <!-- Geteilte Event-Strings -->
     <string name="event_untitled">(Ohne Titel)</string>
 
+    <!-- Erinnerungs-Benachrichtigungen (v1.4) -->
+    <string name="reminder_channel_name">Termin-Erinnerungen</string>
+    <string name="reminder_channel_description">Benachrichtigungen zu den Erinnerungszeiten deiner Termine</string>
+    <string name="reminder_onboarding_title">Keinen Termin mehr verpassen</string>
+    <string name="reminder_onboarding_body">Android zeigt Termin-Erinnerungen nicht von selbst — das muss eine Kalender-App tun. Überlass Calendula den Job.</string>
+    <string name="reminder_benefit_delivery_title">Erinnerungen, zugestellt</string>
+    <string name="reminder_benefit_delivery_body">Jede Erinnerung an deinen Terminen kommt pünktlich als Benachrichtigung an.</string>
+    <string name="reminder_benefit_duplicates_title">Noch eine zweite Kalender-App?</string>
+    <string name="reminder_benefit_duplicates_body">Wenn eine andere App ebenfalls Erinnerungen zeigt, siehst du sie doppelt — schalte sie dort oder hier ab.</string>
+    <string name="reminder_benefit_reversible_title">Jederzeit änderbar</string>
+    <string name="reminder_benefit_reversible_body">Der Schalter liegt in den Einstellungen unter Benachrichtigungen.</string>
+    <string name="reminder_onboarding_enable_button">Erinnerungen einschalten</string>
+    <string name="reminder_onboarding_skip_button">Später</string>
+
     <!-- View-Switcher (M1) -->
     <string name="view_month">Monat</string>
     <string name="view_week">Woche</string>
     <string name="view_day">Tag</string>
+    <string name="view_section">Ansicht</string>
 
     <!-- Kalender-Filter (M3) -->
     <string name="filter_title">Kalender</string>
@@ -129,15 +215,48 @@
     <string name="settings_week_start_auto">Automatisch</string>
     <string name="settings_week_start_monday">Montag</string>
     <string name="settings_week_start_sunday">Sonntag</string>
+    <string name="settings_section_event_form">Termin-Formular</string>
+    <string name="settings_form_fields_hint">Standardmäßig angezeigte Felder — alles Weitere liegt hinter \"Weitere Felder\"</string>
+    <string name="settings_color_unsupported">Farben auf nicht unterstützten Kalendern erlauben</string>
+    <string name="settings_color_unsupported_hint">Manche Kalender (z. B. bestimmte CalDAV) stellen keine Farbpalette bereit; eine eigene Terminfarbe wird dort bei der nächsten Synchronisierung unter Umständen verworfen oder überschrieben. Das ist eine Einschränkung dieser Kalender und kann von Calendula nicht behoben werden.</string>
+    <string name="settings_section_notifications">Benachrichtigungen</string>
+    <string name="settings_reminders">Termin-Erinnerungen</string>
+    <string name="settings_reminders_hint">Erinnerungen doppelt? Eine andere Kalender-App zeigt sie ebenfalls — schalte sie in einer der beiden ab.</string>
+    <string name="settings_section_calendars">Kalender</string>
+    <string name="settings_manage_calendars">Kalender verwalten</string>
+    <string name="settings_manage_calendars_hint">Lokale Kalender anlegen, synchronisierte verwalten</string>
     <string name="settings_section_language">Sprache</string>
     <string name="settings_language">App-Sprache</string>
     <string name="settings_language_auto">Systemstandard</string>
     <string name="settings_language_german">Deutsch</string>
     <string name="settings_language_english">English</string>
+    <!-- Hub category subtitles -->
+    <string name="settings_appearance_subtitle">Design, dynamische Farben, Wochenstart</string>
+    <string name="settings_event_form_subtitle">Standardfelder für neue Termine</string>
+    <string name="settings_notifications_subtitle">Termin-Erinnerungen</string>
     <string name="settings_section_about">Über</string>
-    <string name="settings_version">Version</string>
     <string name="settings_license">Lizenz</string>
     <string name="settings_license_value">MIT</string>
-    <string name="settings_source">Quellcode</string>
-    <string name="settings_source_open">Öffnen</string>
+    <string name="settings_about_author">von Jean-Luc Makiola</string>
+    <string name="settings_about_source">Quellcode</string>
+    <string name="settings_about_version">Version %1$s</string>
+    <string name="settings_about_logo_desc">Calendula-App-Symbol</string>
+
+    <!-- Calendar manager -->
+    <string name="calendars_title">Kalender</string>
+    <string name="calendars_local_header">Deine Kalender</string>
+    <string name="calendars_local_empty">Noch keine lokalen Kalender. Lege einen an, um Termine nur auf diesem Gerät zu speichern.</string>
+    <string name="calendars_add">Kalender hinzufügen</string>
+    <string name="calendars_synced_header">Synchronisierte Kalender</string>
+    <string name="calendars_synced_hint">Diese stammen von Konten auf deinem Gerät. Erstelle und bearbeite sie in der jeweiligen App.</string>
+    <string name="calendars_manage_in_app">Verwalten</string>
+    <string name="calendars_add_account">Konto hinzufügen</string>
+    <string name="calendars_new_title">Neuer Kalender</string>
+    <string name="calendars_edit_title">Kalender bearbeiten</string>
+    <string name="calendars_name_label">Name</string>
+    <string name="calendars_color_label">Farbe</string>
+    <string name="calendars_description_hint">Beschreibung hinzufügen</string>
+    <string name="calendars_delete_confirm_title">Kalender löschen?</string>
+    <string name="calendars_delete_confirm_message">\"%1$s\" und alle zugehörigen Termine werden dauerhaft von diesem Gerät entfernt.</string>
+    <string name="calendars_write_error">Änderung konnte nicht gespeichert werden.</string>
 </resources>

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

@@ -14,7 +14,7 @@
 
     <!-- Permission flow (F1) -->
     <string name="permission_rationale_title">See all your events, beautifully</string>
-    <string name="permission_rationale_body">Calendula needs to read your calendar to show your events. That\'s the only thing it ever asks for.</string>
+    <string name="permission_rationale_body">Calendula needs access to your calendar to show and manage your events. That\'s the only thing it ever asks for.</string>
     <string name="permission_request_button">Grant calendar access</string>
     <string name="permission_denied_title">Calendar access denied</string>
     <string name="permission_denied_body">Calendula cannot show events without calendar access. You can grant it again in the system settings.</string>
@@ -26,7 +26,7 @@
     <string name="permission_benefit_sync_body">Google, CalDAV, local — anything synced to the device just appears.</string>
     <string name="permission_benefit_privacy_title">No tracking, ever</string>
     <string name="permission_benefit_privacy_body">Zero telemetry, zero analytics, no ads.</string>
-    <string name="permission_privacy_footnote">Read-only · no internet permission</string>
+    <string name="permission_privacy_footnote">Stays on your device · no internet permission</string>
 
     <!-- Month view (S1) -->
     <string name="month_prev">Previous month</string>
@@ -48,6 +48,77 @@
     <string name="event_detail_back">Back</string>
     <string name="event_detail_edit">Edit</string>
     <string name="event_detail_delete">Delete</string>
+    <string name="event_delete_title">Delete event?</string>
+    <string name="event_delete_body">The event is removed from your calendar and from every device it syncs to.</string>
+    <string name="event_delete_recurring_title">Delete recurring event</string>
+    <string name="event_delete_option_occurrence">Only this event</string>
+    <string name="event_delete_option_following">This and all following events</string>
+    <string name="event_delete_option_series">All events in the series</string>
+    <string name="event_edit_recurring_title">Edit recurring event</string>
+    <string name="event_delete_failed">Couldn\'t delete the event</string>
+    <string name="event_delete_write_denied">Calendula needs write access to delete events</string>
+    <string name="dialog_cancel">Cancel</string>
+    <string name="dialog_ok">OK</string>
+
+    <!-- Event form (v1.2 create) -->
+    <string name="event_edit_new_title">New event</string>
+    <string name="event_edit_close">Close</string>
+    <string name="event_edit_save">Save</string>
+    <string name="event_edit_title_hint">Add title</string>
+    <string name="event_edit_starts">Starts</string>
+    <string name="event_edit_ends">Ends</string>
+    <string name="event_edit_error_end_before_start">Ends before it starts</string>
+    <string name="event_edit_error_no_calendar">No writable calendar available</string>
+    <string name="event_edit_save_failed">Couldn\'t save the event</string>
+    <string name="event_edit_write_denied">Calendula needs write access to create events</string>
+    <string name="event_edit_more_fields">More fields</string>
+    <string name="event_edit_add">Add</string>
+    <string name="event_edit_add_reminder">Add reminder</string>
+    <string name="event_edit_remove_reminder">Remove reminder</string>
+    <string name="event_edit_reminder_custom">Custom</string>
+    <string name="reminder_unit_minutes">minutes</string>
+    <string name="reminder_unit_hours">hours</string>
+    <string name="reminder_unit_days">days</string>
+    <string name="reminder_unit_weeks">weeks</string>
+    <string name="event_edit_availability">Availability</string>
+    <string name="event_edit_visibility">Visibility</string>
+
+    <!-- Event form — per-event color -->
+    <string name="event_edit_color">Color</string>
+    <string name="event_edit_color_default">Calendar color</string>
+    <string name="event_edit_color_custom">Custom color</string>
+    <string name="event_edit_color_reset">Reset</string>
+    <string name="event_edit_color_unsupported">Not available for this calendar</string>
+    <string name="event_edit_color_unsupported_hint">This calendar publishes no color set. You can allow custom colors for such calendars in Settings.</string>
+    <string name="event_edit_color_sync_warning">This calendar may drop or overwrite the color on its next sync.</string>
+
+    <!-- Event form — save conflict (v2.0) -->
+    <string name="event_edit_conflict_title">Event changed elsewhere</string>
+    <string name="event_edit_conflict_body">While you were editing, this event was changed — by sync or another app. What should happen to your changes?</string>
+    <string name="event_edit_conflict_overwrite">Save my changes</string>
+    <string name="event_edit_conflict_overwrite_hint">Only fields you edited overwrite the outside change</string>
+    <string name="event_edit_conflict_discard">Discard my changes</string>
+    <string name="event_edit_conflict_discard_hint">The event stays as it is now</string>
+    <string name="event_edit_gone_title">Event deleted</string>
+    <string name="event_edit_gone_body">This event was deleted in the meantime, for example on another device. Your changes can no longer be saved.</string>
+
+    <!-- Event form — recurrence picker (v1.3) -->
+    <string name="event_edit_recurrence_none">Does not repeat</string>
+    <string name="event_edit_recurrence_custom">Custom</string>
+    <string name="event_edit_recurrence_every">Every</string>
+    <string name="recurrence_unit_days">days</string>
+    <string name="recurrence_unit_weeks">weeks</string>
+    <string name="recurrence_unit_months">months</string>
+    <string name="recurrence_unit_years">years</string>
+    <string name="event_edit_recurrence_ends">Ends</string>
+    <string name="event_edit_recurrence_end_never">Never</string>
+    <string name="event_edit_recurrence_end_until">On a date</string>
+    <string name="event_edit_recurrence_end_count">After a number of times</string>
+    <string name="event_edit_recurrence_times">times</string>
+    <string name="event_edit_error_recurrence_ends_before_start">Repeats end before the event starts</string>
+    <string name="event_availability_busy">Busy</string>
+    <string name="event_access_default">Default</string>
+    <string name="event_access_public">Public</string>
     <string name="event_detail_all_day">All day</string>
     <string name="event_detail_calendar">Calendar</string>
     <string name="event_detail_calendar_unknown">Unknown calendar</string>
@@ -108,10 +179,25 @@
     <!-- Shared event strings -->
     <string name="event_untitled">(No title)</string>
 
+    <!-- Reminder notifications (v1.4) -->
+    <string name="reminder_channel_name">Event reminders</string>
+    <string name="reminder_channel_description">Notifications at the reminder times of your events</string>
+    <string name="reminder_onboarding_title">Never miss an event</string>
+    <string name="reminder_onboarding_body">Android doesn\'t show event reminders by itself — a calendar app has to. Let Calendula take that job.</string>
+    <string name="reminder_benefit_delivery_title">Reminders, delivered</string>
+    <string name="reminder_benefit_delivery_body">Every reminder on your events arrives as a notification, right on time.</string>
+    <string name="reminder_benefit_duplicates_title">Using a second calendar app?</string>
+    <string name="reminder_benefit_duplicates_body">If another app also posts reminders, you\'ll see them twice — turn them off there or here.</string>
+    <string name="reminder_benefit_reversible_title">Change it anytime</string>
+    <string name="reminder_benefit_reversible_body">The switch lives in Settings, under Notifications.</string>
+    <string name="reminder_onboarding_enable_button">Turn on reminders</string>
+    <string name="reminder_onboarding_skip_button">Not now</string>
+
     <!-- View switcher (M1) -->
     <string name="view_month">Month</string>
     <string name="view_week">Week</string>
     <string name="view_day">Day</string>
+    <string name="view_section">View</string>
 
     <!-- Calendar filter (M3) -->
     <string name="filter_title">Calendars</string>
@@ -130,16 +216,50 @@
     <string name="settings_week_start_auto">Automatic</string>
     <string name="settings_week_start_monday">Monday</string>
     <string name="settings_week_start_sunday">Sunday</string>
+    <string name="settings_section_event_form">New event form</string>
+    <string name="settings_form_fields_hint">Fields shown by default — everything else sits behind \"More fields\"</string>
+    <string name="settings_color_unsupported">Allow colors on unsupported calendars</string>
+    <string name="settings_color_unsupported_hint">Some calendars (e.g. certain CalDAV) publish no color set; a custom event color may be dropped or overwritten on their next sync. That\'s a limitation of those calendars, not something Calendula can fix.</string>
+    <string name="settings_section_notifications">Notifications</string>
+    <string name="settings_reminders">Event reminders</string>
+    <string name="settings_reminders_hint">Seeing reminders twice? Another calendar app is posting them too — turn them off in one of the two.</string>
+    <string name="settings_section_calendars">Calendars</string>
+    <string name="settings_manage_calendars">Manage calendars</string>
+    <string name="settings_manage_calendars_hint">Create local calendars; manage synced ones</string>
     <string name="settings_section_language">Language</string>
     <string name="settings_language">App language</string>
     <string name="settings_language_auto">System default</string>
     <string name="settings_language_german">Deutsch</string>
     <string name="settings_language_english">English</string>
+    <!-- Hub category subtitles -->
+    <string name="settings_appearance_subtitle">Theme, dynamic colour, week start</string>
+    <string name="settings_event_form_subtitle">Default fields for new events</string>
+    <string name="settings_notifications_subtitle">Event reminders</string>
     <string name="settings_section_about">About</string>
-    <string name="settings_version">Version</string>
     <string name="settings_license">License</string>
     <string name="settings_license_value">MIT</string>
-    <string name="settings_source">Source code</string>
-    <string name="settings_source_open">Open</string>
+    <string name="settings_about_author">by Jean-Luc Makiola</string>
+    <string name="settings_about_source">Source</string>
+    <string name="settings_about_version">Version %1$s</string>
+    <string name="settings_about_logo_desc">Calendula app icon</string>
+
+    <!-- Calendar manager -->
+    <string name="calendars_title">Calendars</string>
+    <string name="calendars_local_header">Your calendars</string>
+    <string name="calendars_local_empty">No local calendars yet. Create one to keep events on this device only.</string>
+    <string name="calendars_add">Add calendar</string>
+    <string name="calendars_synced_header">Synced calendars</string>
+    <string name="calendars_synced_hint">These come from accounts on your device. Create and edit them in their own app.</string>
+    <string name="calendars_manage_in_app">Manage</string>
+    <string name="calendars_add_account">Add account</string>
+    <string name="calendars_new_title">New calendar</string>
+    <string name="calendars_edit_title">Edit calendar</string>
+    <string name="calendars_name_label">Name</string>
+    <string name="calendars_color_label">Color</string>
+    <string name="calendars_description_hint">Add a description</string>
+    <string name="calendars_delete_confirm_title">Delete calendar?</string>
+    <string name="calendars_delete_confirm_message">\"%1$s\" and all of its events will be permanently removed from this device.</string>
+    <string name="calendars_write_error">Couldn\'t save the change.</string>
     <string name="about_source_url" translatable="false">https://gitea.jeanlucmakiola.de/makiolaj/calendula</string>
+    <string name="about_license_url" translatable="false">https://gitea.jeanlucmakiola.de/makiolaj/calendula/src/branch/main/LICENSE</string>
 </resources>

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
+import android.provider.CalendarContract
 import com.google.common.truth.Truth.assertThat
 import org.junit.jupiter.api.Test
 
@@ -12,6 +13,8 @@ class CalendarMapperTest {
         accountType: String? = "LOCAL",
         color: Int = 0,
         visible: Int = 1,
+        accessLevel: Int = CalendarContract.Calendars.CAL_ACCESS_OWNER,
+        description: String? = null,
     ): MapColumnReader = MapColumnReader(
         CalendarProjection.IDX_ID to id,
         CalendarProjection.IDX_DISPLAY_NAME to displayName,
@@ -19,6 +22,8 @@ class CalendarMapperTest {
         CalendarProjection.IDX_ACCOUNT_TYPE to accountType,
         CalendarProjection.IDX_COLOR to color,
         CalendarProjection.IDX_VISIBLE to visible,
+        CalendarProjection.IDX_ACCESS_LEVEL to accessLevel,
+        CalendarProjection.IDX_DESCRIPTION to description,
     )
 
     @Test
@@ -39,6 +44,7 @@ class CalendarMapperTest {
                 accountType = "com.google",
                 color = 0xFF112233.toInt(),
                 isVisibleInSystem = true,
+                canModifyContents = true,
             )
         )
     }
@@ -65,4 +71,56 @@ class CalendarMapperTest {
         assertThat(src.accountName).isEqualTo("")
         assertThat(src.accountType).isEqualTo("")
     }
+
+    @Test
+    fun `contributor access and above can modify contents`() {
+        val contributor = reader(accessLevel = CalendarContract.Calendars.CAL_ACCESS_CONTRIBUTOR)
+        val owner = reader(accessLevel = CalendarContract.Calendars.CAL_ACCESS_OWNER)
+        assertThat(contributor.toCalendarSource().canModifyContents).isTrue()
+        assertThat(owner.toCalendarSource().canModifyContents).isTrue()
+    }
+
+    @Test
+    fun `read access cannot modify contents`() {
+        val src = reader(accessLevel = CalendarContract.Calendars.CAL_ACCESS_READ)
+        assertThat(src.toCalendarSource().canModifyContents).isFalse()
+    }
+
+    @Test
+    fun `missing access level defaults to read-only`() {
+        // WebCal subscriptions on some providers report level 0 (CAL_ACCESS_NONE).
+        val src = reader(accessLevel = CalendarContract.Calendars.CAL_ACCESS_NONE)
+        assertThat(src.toCalendarSource().canModifyContents).isFalse()
+    }
+
+    @Test
+    fun `local account type marks the calendar as app-owned`() {
+        val src = reader(accountType = CalendarContract.ACCOUNT_TYPE_LOCAL).toCalendarSource()
+        assertThat(src.isLocal).isTrue()
+    }
+
+    @Test
+    fun `synced account type is not local`() {
+        val src = reader(accountType = "com.google").toCalendarSource()
+        assertThat(src.isLocal).isFalse()
+    }
+
+    @Test
+    fun `local calendar exposes its CAL_SYNC1 description`() {
+        val src = reader(
+            accountType = CalendarContract.ACCOUNT_TYPE_LOCAL,
+            description = "House stuff",
+        ).toCalendarSource()
+        assertThat(src.description).isEqualTo("House stuff")
+    }
+
+    @Test
+    fun `synced calendar never exposes CAL_SYNC1 as a description`() {
+        // CAL_SYNC1 holds the sync token for synced rows — it must not leak as a note.
+        val src = reader(
+            accountType = "com.google",
+            description = """{"type":"SYNC_TOKEN","value":"…"}""",
+        ).toCalendarSource()
+        assertThat(src.description).isNull()
+    }
 }

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

@@ -7,8 +7,13 @@ import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventColorOption
+import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import kotlinx.coroutines.Dispatchers
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.UnconfinedTestDispatcher
 import kotlinx.coroutines.test.runTest
@@ -157,6 +162,231 @@ class CalendarRepositoryImplTest {
         }
     }
 
+    @Test
+    fun `createEvent delegates and returns the new id`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply { nextInsertId = 77L }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val form = EventForm(
+            calendarId = 1L,
+            title = "Stand-up",
+            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15)),
+        )
+
+        val id = repo.createEvent(form)
+
+        assertThat(id).isEqualTo(77L)
+        assertThat(fake.insertedForms).containsExactly(form)
+    }
+
+    @Test
+    fun `createEvent propagates write failures`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply {
+            writeError = WriteFailedException("insert event")
+        }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val form = EventForm(
+            calendarId = 1L,
+            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
+        )
+
+        try {
+            repo.createEvent(form)
+            error("Expected WriteFailedException")
+        } catch (expected: WriteFailedException) {
+            assertThat(expected.message).contains("insert")
+        }
+    }
+
+    @Test
+    fun `updateEvent forwards id and both forms`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource()
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val original = EventForm(
+            calendarId = 1L,
+            title = "Stand-up",
+            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15)),
+        )
+        val updated = original.copy(title = "Daily")
+
+        repo.updateEvent(eventId = 42L, original = original, updated = updated)
+
+        assertThat(fake.updatedEvents).containsExactly(Triple(42L, original, updated))
+    }
+
+    @Test
+    fun `updateEvent propagates write failures`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply {
+            writeError = WriteFailedException("update event id=42")
+        }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val form = EventForm(
+            calendarId = 1L,
+            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
+        )
+
+        try {
+            repo.updateEvent(eventId = 42L, original = form, updated = form.copy(title = "X"))
+            error("Expected WriteFailedException")
+        } catch (expected: WriteFailedException) {
+            assertThat(expected.message).contains("42")
+        }
+    }
+
+    @Test
+    fun `deleteEvent delegates to the data source`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource()
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+
+        repo.deleteEvent(eventId = 42L)
+
+        assertThat(fake.deletedEventIds).containsExactly(42L)
+        assertThat(fake.deletedOccurrences).isEmpty()
+    }
+
+    @Test
+    fun `deleteOccurrence forwards event id and begin time`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource()
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+
+        repo.deleteOccurrence(eventId = 42L, beginMillis = 1_000L)
+
+        assertThat(fake.deletedOccurrences).containsExactly(42L to 1_000L)
+        assertThat(fake.deletedEventIds).isEmpty()
+    }
+
+    @Test
+    fun `deleteEventFromOccurrence forwards event id and begin time`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource()
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+
+        repo.deleteEventFromOccurrence(eventId = 42L, beginMillis = 1_000L)
+
+        assertThat(fake.deletedFromOccurrences).containsExactly(42L to 1_000L)
+        assertThat(fake.deletedEventIds).isEmpty()
+        assertThat(fake.deletedOccurrences).isEmpty()
+    }
+
+    @Test
+    fun `updateOccurrence forwards target and form, returns the exception id`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply { nextInsertId = 88L }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val form = EventForm(
+            calendarId = 1L,
+            title = "Moved",
+            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
+        )
+
+        val id = repo.updateOccurrence(eventId = 42L, beginMillis = 1_000L, form = form)
+
+        assertThat(id).isEqualTo(88L)
+        assertThat(fake.updatedOccurrences).containsExactly(Triple(42L, 1_000L, form))
+        assertThat(fake.updatedEvents).isEmpty()
+    }
+
+    @Test
+    fun `updateEventFromOccurrence forwards target and forms, returns the new id`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply { nextInsertId = 99L }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val original = EventForm(
+            calendarId = 1L,
+            title = "Weekly",
+            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
+            rrule = "FREQ=WEEKLY",
+        )
+        val updated = original.copy(title = "Weekly, renamed")
+
+        val id = repo.updateEventFromOccurrence(
+            eventId = 42L,
+            beginMillis = 1_000L,
+            original = original,
+            updated = updated,
+        )
+
+        assertThat(id).isEqualTo(99L)
+        assertThat(fake.updatedFromOccurrences).containsExactly(Triple(42L, 1_000L, updated))
+        assertThat(fake.updatedEvents).isEmpty()
+    }
+
+    @Test
+    fun `deleteEvent propagates write failures`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply {
+            writeError = WriteFailedException("delete event id=42")
+        }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+
+        try {
+            repo.deleteEvent(eventId = 42L)
+            error("Expected WriteFailedException")
+        } catch (expected: WriteFailedException) {
+            assertThat(expected.message).contains("42")
+        }
+    }
+
+    @Test
+    fun `createLocalCalendar delegates and returns the new id`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply { nextCalendarId = 501L }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+
+        val id = repo.createLocalCalendar(
+            displayName = "Home",
+            color = 0xFF33B679.toInt(),
+            description = "House stuff",
+        )
+
+        assertThat(id).isEqualTo(501L)
+        assertThat(fake.createdCalendars).containsExactly(
+            FakeCalendarDataSource.CreatedCalendar("Home", 0xFF33B679.toInt(), "House stuff"),
+        )
+    }
+
+    @Test
+    fun `updateCalendar forwards id, name, color and description`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource()
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+
+        repo.updateCalendar(
+            id = 5L,
+            displayName = "Renamed",
+            color = 0xFF039BE5.toInt(),
+            description = null,
+        )
+
+        assertThat(fake.updatedCalendars).containsExactly(
+            FakeCalendarDataSource.UpdatedCalendar(5L, "Renamed", 0xFF039BE5.toInt(), null),
+        )
+    }
+
+    @Test
+    fun `deleteCalendar delegates to the data source`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource()
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+
+        repo.deleteCalendar(id = 7L)
+
+        assertThat(fake.deletedCalendarIds).containsExactly(7L)
+    }
+
+    @Test
+    fun `createLocalCalendar propagates write failures`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply {
+            writeError = WriteFailedException("create local calendar 'Home'")
+        }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+
+        try {
+            repo.createLocalCalendar(displayName = "Home", color = 0, description = null)
+            error("Expected WriteFailedException")
+        } catch (expected: WriteFailedException) {
+            assertThat(expected.message).contains("Home")
+        }
+    }
+
     @Test
     fun `eventDetail throws NoSuchEventException when data source returns null`(@TempDir tempDir: Path) = runTest {
         val fake = FakeCalendarDataSource().apply {
@@ -171,4 +401,20 @@ class CalendarRepositoryImplTest {
             assertThat(expected.message).contains("999")
         }
     }
+
+    @Test
+    fun `eventColorPalette delegates to the data source for the given calendar`(
+        @TempDir tempDir: Path,
+    ) = runTest {
+        val fake = FakeCalendarDataSource().apply {
+            eventColorPaletteResult = { id ->
+                if (id == 7L) listOf(EventColorOption("5", 0xFF33B679.toInt())) else emptyList()
+            }
+        }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+
+        assertThat(repo.eventColorPalette(7L))
+            .containsExactly(EventColorOption("5", 0xFF33B679.toInt()))
+        assertThat(repo.eventColorPalette(8L)).isEmpty()
+    }
 }

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

@@ -20,6 +20,7 @@ class EventDetailMapperTest {
         organizer: String? = "x@y",
         rrule: String? = null,
         eventColor: Any? = null,
+        eventColorKey: String? = null,
         calendarColor: Int = 0xFFAABBCC.toInt(),
         dtstart: Long = 1_000_000_000L,
         dtend: Long = 1_000_003_600L,
@@ -49,6 +50,7 @@ class EventDetailMapperTest {
         EventDetailProjection.IDX_ACCESS_LEVEL to accessLevel,
         EventDetailProjection.IDX_EVENT_TIMEZONE to timezone,
         EventDetailProjection.IDX_SELF_ATTENDEE_STATUS to selfStatus,
+        EventDetailProjection.IDX_EVENT_COLOR_KEY to eventColorKey,
     )
 
     private fun attendeeReader(
@@ -88,11 +90,33 @@ class EventDetailMapperTest {
         assertThat(detail.attendees).isEmpty()
     }
 
+    @Test
+    fun `missing title stays raw so the edit form does not inherit a placeholder`() {
+        assertThat(detailReader(title = null).toDetail()!!.instance.title).isEmpty()
+        assertThat(detailReader(title = "").toDetail()!!.instance.title).isEmpty()
+    }
+
     @Test
     fun `event color falls back to calendar color when null`() {
         val detail = detailReader(eventColor = null, calendarColor = 0xFF112233.toInt())
             .toDetail()
         assertThat(detail!!.instance.color).isEqualTo(0xFF112233.toInt())
+        // No own colour: the edit form must see this as "inherits".
+        assertThat(detail.eventColor).isNull()
+        assertThat(detail.eventColorKey).isNull()
+    }
+
+    @Test
+    fun `own event color and key are surfaced apart from the resolved color`() {
+        val detail = detailReader(
+            eventColor = 0xFF33B679.toInt(),
+            eventColorKey = "5",
+            calendarColor = 0xFF112233.toInt(),
+        ).toDetail()
+        // Resolved display colour is the event's own, not the calendar fallback.
+        assertThat(detail!!.instance.color).isEqualTo(0xFF33B679.toInt())
+        assertThat(detail.eventColor).isEqualTo(0xFF33B679.toInt())
+        assertThat(detail.eventColorKey).isEqualTo("5")
     }
 
     @Test

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

@@ -0,0 +1,300 @@
+package de.jeanlucmakiola.calendula.data.calendar
+
+import android.provider.CalendarContract
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.AccessLevel
+import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.EventForm
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import org.junit.jupiter.api.Test
+import java.time.ZoneId
+
+class EventWriteMapperTest {
+
+    private val berlin: ZoneId = ZoneId.of("Europe/Berlin")
+
+    private fun form(
+        isAllDay: Boolean = false,
+        start: LocalDateTime = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)),
+        end: LocalDateTime = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 30)),
+    ): EventForm = EventForm(calendarId = 1L, isAllDay = isAllDay, start = start, end = end)
+
+    @Test
+    fun `timed event resolves wall clock in the given zone`() {
+        val times = form().toWriteTimes(berlin)
+        // 2026-06-11 is CEST (UTC+2): 10:00 local == 08:00Z.
+        assertThat(times.dtStartMillis).isEqualTo(1_781_164_800_000L)
+        assertThat(times.dtEndMillis - times.dtStartMillis).isEqualTo(90L * 60L * 1000L)
+        assertThat(times.timezone).isEqualTo("Europe/Berlin")
+    }
+
+    @Test
+    fun `all-day event lives at UTC midnights with exclusive end`() {
+        val times = form(isAllDay = true).toWriteTimes(berlin)
+        assertThat(times.timezone).isEqualTo("UTC")
+        assertThat(times.dtStartMillis % 86_400_000L).isEqualTo(0L)
+        // Single-day all-day event: DTEND is the NEXT UTC midnight.
+        assertThat(times.dtEndMillis - times.dtStartMillis).isEqualTo(86_400_000L)
+    }
+
+    @Test
+    fun `availability maps to the provider constants`() {
+        assertThat(Availability.Busy.toProviderValue())
+            .isEqualTo(CalendarContract.Events.AVAILABILITY_BUSY)
+        assertThat(Availability.Free.toProviderValue())
+            .isEqualTo(CalendarContract.Events.AVAILABILITY_FREE)
+        assertThat(Availability.Tentative.toProviderValue())
+            .isEqualTo(CalendarContract.Events.AVAILABILITY_TENTATIVE)
+    }
+
+    @Test
+    fun `access level maps to the provider constants`() {
+        assertThat(AccessLevel.Default.toProviderValue())
+            .isEqualTo(CalendarContract.Events.ACCESS_DEFAULT)
+        assertThat(AccessLevel.Private.toProviderValue())
+            .isEqualTo(CalendarContract.Events.ACCESS_PRIVATE)
+        assertThat(AccessLevel.Confidential.toProviderValue())
+            .isEqualTo(CalendarContract.Events.ACCESS_CONFIDENTIAL)
+        assertThat(AccessLevel.Public.toProviderValue())
+            .isEqualTo(CalendarContract.Events.ACCESS_PUBLIC)
+    }
+
+    @Test
+    fun `multi-day all-day event spans every covered day`() {
+        val times = form(
+            isAllDay = true,
+            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 13), LocalTime(0, 0)),
+        ).toWriteTimes(berlin)
+        // 11th, 12th, 13th inclusive = 3 days.
+        assertThat(times.dtEndMillis - times.dtStartMillis).isEqualTo(3L * 86_400_000L)
+    }
+
+    @Test
+    fun `truncation cutoff is the end of the previous local day`() {
+        // June 9 2026 15:30Z == 17:30 in Berlin. The cutoff must be
+        // June 8 23:59:59 Berlin == June 8 21:59:59Z.
+        assertThat(previousLocalDayEndUtcMillis(1_781_019_000_000L, berlin))
+            .isEqualTo(1_780_955_999_000L)
+        // All-day series live in UTC: the cutoff for a June 9 UTC-midnight
+        // occurrence is June 8 23:59:59Z.
+        assertThat(previousLocalDayEndUtcMillis(1_780_963_200_000L, ZoneId.of("UTC")))
+            .isEqualTo(1_780_963_199_000L)
+    }
+
+    @Test
+    fun `duration renders seconds for timed and days for all-day events`() {
+        assertThat(form().toWriteTimes(berlin).toRfc2445Duration(isAllDay = false))
+            .isEqualTo("P5400S")
+        assertThat(form(isAllDay = true).toWriteTimes(berlin).toRfc2445Duration(isAllDay = true))
+            .isEqualTo("P1D")
+    }
+
+    // --- buildEventUpdateValues (dirty-checked partial update) ---
+
+    private val seriesStart = 1_700_000_000_000L
+
+    private fun update(original: EventForm, updated: EventForm): Map<String, Any?> =
+        buildEventUpdateValues(original, updated, seriesStart, berlin)
+
+    @Test
+    fun `pristine form produces no values`() {
+        val original = form()
+        assertThat(update(original, original.copy())).isEmpty()
+    }
+
+    @Test
+    fun `text-only edit writes just the changed columns`() {
+        val original = form()
+        val values = update(original, original.copy(title = "New", description = "Body"))
+        assertThat(values).containsExactly(
+            CalendarContract.Events.TITLE, "New",
+            CalendarContract.Events.DESCRIPTION, "Body",
+        )
+    }
+
+    @Test
+    fun `clearing location writes an explicit null`() {
+        val original = form().copy(location = "Berlin")
+        val values = update(original, original.copy(location = " "))
+        assertThat(values).containsExactly(CalendarContract.Events.EVENT_LOCATION, null)
+    }
+
+    @Test
+    fun `time edit on a one-off event writes absolute times and clears recurrence columns`() {
+        val original = form()
+        val updated = original.copy(
+            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 0)),
+        )
+        val values = update(original, updated)
+        // 2026-06-11 11:00 CEST == 09:00Z.
+        assertThat(values[CalendarContract.Events.DTSTART])
+            .isEqualTo(1_781_164_800_000L + 3_600_000L)
+        assertThat(values[CalendarContract.Events.DTEND])
+            .isEqualTo(1_781_164_800_000L + 2L * 3_600_000L)
+        assertThat(values).containsEntry(CalendarContract.Events.RRULE, null)
+        assertThat(values).containsEntry(CalendarContract.Events.DURATION, null)
+        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("Europe/Berlin")
+        assertThat(values[CalendarContract.Events.ALL_DAY]).isEqualTo(0)
+    }
+
+    @Test
+    fun `time edit on a recurring event moves the series start by the same delta`() {
+        val original = form().copy(rrule = "FREQ=WEEKLY")
+        val updated = original.copy(
+            // Pushed one hour later than the displayed occurrence.
+            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 30)),
+        )
+        val values = update(original, updated)
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(seriesStart + 3_600_000L)
+        assertThat(values).containsEntry(CalendarContract.Events.DTEND, null)
+        assertThat(values[CalendarContract.Events.RRULE]).isEqualTo("FREQ=WEEKLY")
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P5400S")
+    }
+
+    @Test
+    fun `adding a recurrence keeps the times and writes rule plus duration`() {
+        val original = form()
+        val values = update(original, original.copy(rrule = "FREQ=DAILY;COUNT=5"))
+        // The event was one-off, so the row's DTSTART is the occurrence start
+        // and a zero delta keeps it in place.
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(seriesStart)
+        assertThat(values[CalendarContract.Events.RRULE]).isEqualTo("FREQ=DAILY;COUNT=5")
+        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P5400S")
+        assertThat(values).containsEntry(CalendarContract.Events.DTEND, null)
+    }
+
+    @Test
+    fun `removing the recurrence writes absolute occurrence times and clears the rule`() {
+        val original = form().copy(rrule = "FREQ=WEEKLY")
+        val values = update(original, original.copy(rrule = null))
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_164_800_000L)
+        assertThat(values[CalendarContract.Events.DTEND])
+            .isEqualTo(1_781_164_800_000L + 5_400_000L)
+        assertThat(values).containsEntry(CalendarContract.Events.RRULE, null)
+        assertThat(values).containsEntry(CalendarContract.Events.DURATION, null)
+    }
+
+    @Test
+    fun `reminder-only changes touch no event columns`() {
+        val original = form()
+        assertThat(update(original, original.copy(reminders = listOf(10)))).isEmpty()
+    }
+
+    // --- buildOccurrenceExceptionValues ("edit only this event") ---
+
+    @Test
+    fun `occurrence exception carries absolute times and the original instance`() {
+        val values = buildOccurrenceExceptionValues(
+            form = form().copy(title = "Moved", location = "Berlin"),
+            originalInstanceMillis = 1_700_000_000_000L,
+            zone = berlin,
+        )
+        assertThat(values[CalendarContract.Events.ORIGINAL_INSTANCE_TIME])
+            .isEqualTo(1_700_000_000_000L)
+        assertThat(values[CalendarContract.Events.TITLE]).isEqualTo("Moved")
+        assertThat(values[CalendarContract.Events.EVENT_LOCATION]).isEqualTo("Berlin")
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_164_800_000L)
+        assertThat(values[CalendarContract.Events.DTEND])
+            .isEqualTo(1_781_164_800_000L + 5_400_000L)
+        // A single occurrence never carries its own rule.
+        assertThat(values).doesNotContainKey(CalendarContract.Events.RRULE)
+        assertThat(values).doesNotContainKey(CalendarContract.Events.DURATION)
+    }
+
+    @Test
+    fun `occurrence exception clears empty optionals explicitly`() {
+        // The provider clones the parent row, so a blank field must be an
+        // explicit NULL or the parent's value would survive.
+        val values = buildOccurrenceExceptionValues(
+            form = form(),
+            originalInstanceMillis = 0L,
+            zone = berlin,
+        )
+        assertThat(values).containsEntry(CalendarContract.Events.EVENT_LOCATION, null)
+        assertThat(values).containsEntry(CalendarContract.Events.DESCRIPTION, null)
+    }
+
+    // --- per-event colour ---
+
+    @Test
+    fun `palette colour writes only the key, never a raw colour`() {
+        assertThat(eventColorColumns(colorKey = "5", color = 0xFF33B679.toInt()))
+            .containsExactly(CalendarContract.Events.EVENT_COLOR_KEY, "5")
+    }
+
+    @Test
+    fun `raw colour writes the colour and clears any key`() {
+        assertThat(eventColorColumns(colorKey = null, color = 0xFF8E24AA.toInt()))
+            .containsExactly(
+                CalendarContract.Events.EVENT_COLOR_KEY, null,
+                CalendarContract.Events.EVENT_COLOR, 0xFF8E24AA.toInt(),
+            )
+    }
+
+    @Test
+    fun `no colour clears both columns so the event inherits its calendar`() {
+        assertThat(eventColorColumns(colorKey = null, color = null))
+            .containsExactly(
+                CalendarContract.Events.EVENT_COLOR_KEY, null,
+                CalendarContract.Events.EVENT_COLOR, null,
+            )
+    }
+
+    @Test
+    fun `setting a palette colour on update writes just the key`() {
+        val original = form()
+        val values = update(original, original.copy(colorKey = "3", color = 0xFFF6BF26.toInt()))
+        assertThat(values).containsExactly(CalendarContract.Events.EVENT_COLOR_KEY, "3")
+    }
+
+    @Test
+    fun `setting a raw colour on update writes the colour and a null key`() {
+        val original = form()
+        val values = update(original, original.copy(color = 0xFF039BE5.toInt()))
+        assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR, 0xFF039BE5.toInt())
+        assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR_KEY, null)
+    }
+
+    @Test
+    fun `clearing a colour on update writes explicit nulls`() {
+        val original = form().copy(color = 0xFFD50000.toInt())
+        val values = update(original, original.copy(color = null))
+        assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR, null)
+        assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR_KEY, null)
+    }
+
+    @Test
+    fun `unchanged colour writes no colour columns`() {
+        val original = form().copy(colorKey = "7", color = 0xFF3F51B5.toInt())
+        val values = update(original, original.copy(title = "Renamed"))
+        assertThat(values).doesNotContainKey(CalendarContract.Events.EVENT_COLOR_KEY)
+        assertThat(values).doesNotContainKey(CalendarContract.Events.EVENT_COLOR)
+    }
+
+    @Test
+    fun `occurrence exception carries the palette key`() {
+        val values = buildOccurrenceExceptionValues(
+            form = form().copy(colorKey = "2", color = 0xFFE67C00.toInt()),
+            originalInstanceMillis = 0L,
+            zone = berlin,
+        )
+        assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR_KEY, "2")
+        assertThat(values).doesNotContainKey(CalendarContract.Events.EVENT_COLOR)
+    }
+
+    @Test
+    fun `occurrence exception with no colour clears both columns`() {
+        val values = buildOccurrenceExceptionValues(
+            form = form(),
+            originalInstanceMillis = 0L,
+            zone = berlin,
+        )
+        assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR, null)
+        assertThat(values).containsEntry(CalendarContract.Events.EVENT_COLOR_KEY, null)
+    }
+}

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

@@ -1,7 +1,9 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
+import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
 
 /**
@@ -13,6 +15,31 @@ internal class FakeCalendarDataSource : CalendarDataSource {
     var calendarsResult: List<CalendarSource> = emptyList()
     var instancesResult: (Long, Long) -> List<EventInstance> = { _, _ -> emptyList() }
     var eventDetailResult: (Long) -> EventDetail? = { null }
+    var eventColorPaletteResult: (Long) -> List<EventColorOption> = { emptyList() }
+    /** Set to make the next write call throw. */
+    var writeError: Exception? = null
+    /** Id returned by the next [insertEvent]. */
+    var nextInsertId: Long = 100L
+
+    val insertedForms = mutableListOf<EventForm>()
+    val updatedEvents = mutableListOf<Triple<Long, EventForm, EventForm>>()
+    val updatedOccurrences = mutableListOf<Triple<Long, Long, EventForm>>()
+    val updatedFromOccurrences = mutableListOf<Triple<Long, Long, EventForm>>()
+    val deletedEventIds = mutableListOf<Long>()
+    val deletedOccurrences = mutableListOf<Pair<Long, Long>>()
+    val deletedFromOccurrences = mutableListOf<Pair<Long, Long>>()
+    /** Id returned by the next [createLocalCalendar]. */
+    var nextCalendarId: Long = 500L
+    data class CreatedCalendar(val displayName: String, val color: Int, val description: String?)
+    data class UpdatedCalendar(
+        val id: Long,
+        val displayName: String,
+        val color: Int,
+        val description: String?,
+    )
+    val createdCalendars = mutableListOf<CreatedCalendar>()
+    val updatedCalendars = mutableListOf<UpdatedCalendar>()
+    val deletedCalendarIds = mutableListOf<Long>()
 
     private val listeners = mutableListOf<() -> Unit>()
 
@@ -20,6 +47,67 @@ internal class FakeCalendarDataSource : CalendarDataSource {
     override fun instances(beginMillis: Long, endMillis: Long): List<EventInstance> =
         instancesResult(beginMillis, endMillis)
     override fun eventDetail(eventId: Long): EventDetail? = eventDetailResult(eventId)
+    override fun eventColorPalette(calendarId: Long): List<EventColorOption> =
+        eventColorPaletteResult(calendarId)
+
+    override fun createLocalCalendar(displayName: String, color: Int, description: String?): Long {
+        writeError?.let { throw it }
+        createdCalendars += CreatedCalendar(displayName, color, description)
+        return nextCalendarId
+    }
+
+    override fun updateCalendar(id: Long, displayName: String, color: Int, description: String?) {
+        writeError?.let { throw it }
+        updatedCalendars += UpdatedCalendar(id, displayName, color, description)
+    }
+
+    override fun deleteCalendar(id: Long) {
+        writeError?.let { throw it }
+        deletedCalendarIds += id
+    }
+
+    override fun insertEvent(form: EventForm): Long {
+        writeError?.let { throw it }
+        insertedForms += form
+        return nextInsertId
+    }
+
+    override fun updateEvent(eventId: Long, original: EventForm, updated: EventForm) {
+        writeError?.let { throw it }
+        updatedEvents += Triple(eventId, original, updated)
+    }
+
+    override fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long {
+        writeError?.let { throw it }
+        updatedOccurrences += Triple(eventId, beginMillis, form)
+        return nextInsertId
+    }
+
+    override fun updateEventFromOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        original: EventForm,
+        updated: EventForm,
+    ): Long {
+        writeError?.let { throw it }
+        updatedFromOccurrences += Triple(eventId, beginMillis, updated)
+        return nextInsertId
+    }
+
+    override fun deleteEventFromOccurrence(eventId: Long, beginMillis: Long) {
+        writeError?.let { throw it }
+        deletedFromOccurrences += eventId to beginMillis
+    }
+
+    override fun deleteEvent(eventId: Long) {
+        writeError?.let { throw it }
+        deletedEventIds += eventId
+    }
+
+    override fun deleteOccurrence(eventId: Long, beginMillis: Long) {
+        writeError?.let { throw it }
+        deletedOccurrences += eventId to beginMillis
+    }
     override fun registerChangeListener(listener: () -> Unit) {
         listeners += listener
     }

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

@@ -4,6 +4,7 @@ import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.PreferenceDataStoreFactory
 import androidx.datastore.preferences.core.Preferences
 import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.EventFormField
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
 import kotlinx.datetime.DayOfWeek
@@ -60,6 +61,66 @@ class SettingsPrefsTest {
         assertThat(prefs.themeMode.first()).isEqualTo(ThemeMode.SYSTEM)
     }
 
+    @Test
+    fun `form fields default to location and description`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.defaultFormFields.first()).containsExactly(
+            EventFormField.Location,
+            EventFormField.Description,
+        )
+    }
+
+    @Test
+    fun `form field toggle round-trips`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.setFormFieldDefault(EventFormField.Reminders, enabled = true)
+        prefs.setFormFieldDefault(EventFormField.Location, enabled = false)
+        assertThat(prefs.defaultFormFields.first()).containsExactly(
+            EventFormField.Description,
+            EventFormField.Reminders,
+        )
+    }
+
+    @Test
+    fun `disabling every form field persists as none, not factory default`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        EventFormField.entries.forEach { prefs.setFormFieldDefault(it, enabled = false) }
+        assertThat(prefs.defaultFormFields.first()).isEmpty()
+    }
+
+    @Test
+    fun `unknown stored form-field names are dropped`(@TempDir tempDir: Path) = runTest {
+        val store = newDataStore(tempDir)
+        val prefs = SettingsPrefs(store)
+        store.updateData { p ->
+            val m = p.toMutablePreferences()
+            m[SettingsPrefs.FORM_FIELDS_KEY] = "Location,Hologram"
+            m
+        }
+        assertThat(prefs.defaultFormFields.first()).containsExactly(EventFormField.Location)
+    }
+
+    @Test
+    fun `reminders default to enabled, onboarding to not done`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.remindersEnabled.first()).isTrue()
+        assertThat(prefs.reminderOnboardingDone.first()).isFalse()
+    }
+
+    @Test
+    fun `reminders toggle round-trips`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.setRemindersEnabled(false)
+        assertThat(prefs.remindersEnabled.first()).isFalse()
+    }
+
+    @Test
+    fun `reminder onboarding completes one-way`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.setReminderOnboardingDone()
+        assertThat(prefs.reminderOnboardingDone.first()).isTrue()
+    }
+
     @Test
     fun `explicit week-start prefs resolve regardless of locale`() {
         assertThat(WeekStartPref.MONDAY.resolveFirstDay(Locale.US)).isEqualTo(DayOfWeek.MONDAY)

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

@@ -0,0 +1,85 @@
+package de.jeanlucmakiola.calendula.data.reminders
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.time.ZoneOffset
+import java.util.Locale
+
+class ReminderTimeTextTest {
+
+    private val berlin = ZoneId.of("Europe/Berlin")
+
+    private fun millisAt(dateTime: LocalDateTime, zone: ZoneId): Long =
+        dateTime.atZone(zone).toInstant().toEpochMilli()
+
+    private fun utcMidnight(date: LocalDate): Long =
+        date.atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
+
+    @Test
+    fun `timed event on one day shows just the time range`() {
+        val text = reminderTimeText(
+            beginMillis = millisAt(LocalDateTime.of(2026, 6, 11, 9, 30), berlin),
+            endMillis = millisAt(LocalDateTime.of(2026, 6, 11, 10, 0), berlin),
+            isAllDay = false,
+            zone = berlin,
+            locale = Locale.GERMANY,
+        )
+        assertThat(text).isEqualTo("09:30 – 10:00")
+    }
+
+    @Test
+    fun `timed event crossing midnight includes both dates`() {
+        val text = reminderTimeText(
+            beginMillis = millisAt(LocalDateTime.of(2026, 6, 11, 23, 30), berlin),
+            endMillis = millisAt(LocalDateTime.of(2026, 6, 12, 0, 30), berlin),
+            isAllDay = false,
+            zone = berlin,
+            locale = Locale.GERMANY,
+        )
+        assertThat(text).contains("11.06.2026")
+        assertThat(text).contains("12.06.2026")
+        assertThat(text).contains("23:30")
+    }
+
+    @Test
+    fun `all-day single day shows one date, read in UTC`() {
+        val text = reminderTimeText(
+            beginMillis = utcMidnight(LocalDate.of(2026, 6, 11)),
+            endMillis = utcMidnight(LocalDate.of(2026, 6, 12)),
+            isAllDay = true,
+            // Zone must not matter for all-day events: UTC midnight is
+            // 02:00 in Berlin — naive local reading would shift the day.
+            zone = berlin,
+            locale = Locale.GERMANY,
+        )
+        assertThat(text).isEqualTo("11.06.2026")
+    }
+
+    @Test
+    fun `all-day multi-day shows the last covered day, not the exclusive end`() {
+        val text = reminderTimeText(
+            beginMillis = utcMidnight(LocalDate.of(2026, 6, 11)),
+            endMillis = utcMidnight(LocalDate.of(2026, 6, 13)),
+            isAllDay = true,
+            zone = berlin,
+            locale = Locale.GERMANY,
+        )
+        assertThat(text).isEqualTo("11.06.2026 – 12.06.2026")
+    }
+
+    @Test
+    fun `degenerate all-day range never renders an inverted span`() {
+        val day = utcMidnight(LocalDate.of(2026, 6, 11))
+        val text = reminderTimeText(
+            beginMillis = day,
+            endMillis = day,
+            isAllDay = true,
+            zone = berlin,
+            locale = Locale.GERMANY,
+        )
+        assertThat(text).isEqualTo("11.06.2026")
+    }
+}

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

@@ -0,0 +1,272 @@
+package de.jeanlucmakiola.calendula.domain
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import org.junit.jupiter.api.Test
+import kotlin.time.Instant
+
+class EventFormTest {
+
+    private fun form(
+        calendarId: Long? = 1L,
+        isAllDay: Boolean = false,
+        start: LocalDateTime = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)),
+        end: LocalDateTime = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0)),
+    ): EventForm = EventForm(calendarId = calendarId, isAllDay = isAllDay, start = start, end = end)
+
+    @Test
+    fun `valid timed form has no problems`() {
+        assertThat(form().problems()).isEmpty()
+    }
+
+    @Test
+    fun `missing calendar is a problem`() {
+        assertThat(form(calendarId = null).problems())
+            .containsExactly(EventFormProblem.NoCalendar)
+    }
+
+    @Test
+    fun `timed end before start is a problem`() {
+        val bad = form(end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 0)))
+        assertThat(bad.problems()).containsExactly(EventFormProblem.EndBeforeStart)
+    }
+
+    @Test
+    fun `zero-length timed event is allowed`() {
+        val instant = form(end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)))
+        assertThat(instant.problems()).isEmpty()
+    }
+
+    @Test
+    fun `all-day single day is allowed even though times match`() {
+        val allDay = form(
+            isAllDay = true,
+            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
+        )
+        assertThat(allDay.problems()).isEmpty()
+    }
+
+    @Test
+    fun `all-day end date before start date is a problem`() {
+        val bad = form(
+            isAllDay = true,
+            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 10), LocalTime(0, 0)),
+        )
+        assertThat(bad.problems()).containsExactly(EventFormProblem.EndBeforeStart)
+    }
+
+    @Test
+    fun `problems accumulate`() {
+        val bad = form(
+            calendarId = null,
+            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 0)),
+        )
+        assertThat(bad.problems()).containsExactly(
+            EventFormProblem.NoCalendar,
+            EventFormProblem.EndBeforeStart,
+        )
+    }
+
+    @Test
+    fun `recurrence until before the first day is a problem`() {
+        // Days before the start, so it parses to an earlier date in any zone.
+        val bad = form().copy(rrule = "FREQ=DAILY;UNTIL=20260601T120000Z")
+        assertThat(bad.problems())
+            .containsExactly(EventFormProblem.RecurrenceEndsBeforeStart)
+    }
+
+    @Test
+    fun `recurrence until on or after the first day is fine`() {
+        // Date-only UNTIL parses zone-independently.
+        assertThat(form().copy(rrule = "FREQ=DAILY;UNTIL=20260611").problems()).isEmpty()
+        assertThat(form().copy(rrule = "FREQ=WEEKLY").problems()).isEmpty()
+    }
+
+    @Test
+    fun `complex rrules are not validated against the start`() {
+        // The picker can't have produced this ("second Monday" ordinal BYDAY);
+        // it is preserved verbatim and never flagged.
+        assertThat(form().copy(rrule = "FREQ=MONTHLY;BYDAY=2MO;UNTIL=20200101").problems()).isEmpty()
+    }
+
+    @Test
+    fun `weekly byday rules are validated against the start`() {
+        val bad = form().copy(rrule = "FREQ=WEEKLY;BYDAY=MO,FR;UNTIL=20200101")
+        assertThat(bad.problems())
+            .containsExactly(EventFormProblem.RecurrenceEndsBeforeStart)
+    }
+
+    private val berlin = TimeZone.of("Europe/Berlin")
+
+    private fun detail(
+        isAllDay: Boolean = false,
+        title: String = "Stand-up",
+        location: String? = "Berlin",
+        description: String? = "Body",
+        rrule: String? = null,
+        reminders: List<Reminder> = emptyList(),
+        availability: Availability = Availability.Busy,
+        accessLevel: AccessLevel = AccessLevel.Default,
+        rowStart: Long = 0L,
+        rowEnd: Long = 0L,
+        attendees: List<Attendee> = emptyList(),
+        eventColor: Int? = null,
+        eventColorKey: String? = null,
+    ): EventDetail = EventDetail(
+        instance = EventInstance(
+            instanceId = 1L,
+            eventId = 1L,
+            calendarId = 7L,
+            title = title,
+            start = Instant.fromEpochMilliseconds(rowStart),
+            end = Instant.fromEpochMilliseconds(rowEnd),
+            isAllDay = isAllDay,
+            color = 0,
+            location = location,
+        ),
+        description = description,
+        organizer = null,
+        attendees = attendees,
+        rrule = rrule,
+        reminders = reminders,
+        availability = availability,
+        accessLevel = accessLevel,
+        eventColor = eventColor,
+        eventColorKey = eventColorKey,
+    )
+
+    @Test
+    fun `toEditForm prefills a timed event from the occurrence times`() {
+        // 2026-06-11 is CEST (UTC+2): 08:00Z == 10:00 local.
+        val prefilled = detail().toEditForm(
+            beginMillis = 1_781_164_800_000L,
+            endMillis = 1_781_164_800_000L + 90L * 60L * 1000L,
+            zone = berlin,
+        )
+        assertThat(prefilled.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)))
+        assertThat(prefilled.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 30)))
+        assertThat(prefilled.isAllDay).isFalse()
+        assertThat(prefilled.calendarId).isEqualTo(7L)
+        assertThat(prefilled.title).isEqualTo("Stand-up")
+        assertThat(prefilled.location).isEqualTo("Berlin")
+        assertThat(prefilled.description).isEqualTo("Body")
+    }
+
+    @Test
+    fun `toEditForm turns the exclusive all-day end into the last covered day`() {
+        // 11th..13th = UTC midnights of the 11th and the (exclusive) 14th.
+        val prefilled = detail(isAllDay = true).toEditForm(
+            beginMillis = LocalDate(2026, 6, 11).toEpochDays() * 86_400_000L,
+            endMillis = LocalDate(2026, 6, 14).toEpochDays() * 86_400_000L,
+            zone = berlin,
+        )
+        assertThat(prefilled.start.date).isEqualTo(LocalDate(2026, 6, 11))
+        assertThat(prefilled.end.date).isEqualTo(LocalDate(2026, 6, 13))
+        assertThat(prefilled.isAllDay).isTrue()
+    }
+
+    @Test
+    fun `toEditForm sorts and dedupes reminder minutes and strips an RRULE prefix`() {
+        val prefilled = detail(
+            rrule = "RRULE:FREQ=WEEKLY",
+            reminders = listOf(
+                Reminder(30, ReminderMethod.Email),
+                Reminder(10, ReminderMethod.Alert),
+                Reminder(30, ReminderMethod.Alert),
+            ),
+        ).toEditForm(beginMillis = 0L, endMillis = 3_600_000L, zone = berlin)
+        assertThat(prefilled.reminders).containsExactly(10, 30).inOrder()
+        assertThat(prefilled.rrule).isEqualTo("FREQ=WEEKLY")
+    }
+
+    @Test
+    fun `snapshots of an unchanged event are equal`() {
+        val a = detail().toEditSnapshot(0L, 3_600_000L, berlin)
+        val b = detail().toEditSnapshot(0L, 3_600_000L, berlin)
+        assertThat(b).isEqualTo(a)
+    }
+
+    @Test
+    fun `an external field change makes snapshots differ`() {
+        val loaded = detail().toEditSnapshot(0L, 3_600_000L, berlin)
+        val fresh = detail(title = "Stand-up (moved)").toEditSnapshot(0L, 3_600_000L, berlin)
+        assertThat(fresh).isNotEqualTo(loaded)
+    }
+
+    @Test
+    fun `an external time move is caught by the row times the form cannot see`() {
+        // Both snapshots are taken for the same tapped occurrence, so the
+        // *forms* derive identical times — only rowStart/rowEnd betray the move.
+        val loaded = detail(rrule = "FREQ=WEEKLY", rowStart = 0L)
+            .toEditSnapshot(0L, 3_600_000L, berlin)
+        val fresh = detail(rrule = "FREQ=WEEKLY", rowStart = 86_400_000L)
+            .toEditSnapshot(0L, 3_600_000L, berlin)
+        assertThat(fresh.form).isEqualTo(loaded.form)
+        assertThat(fresh).isNotEqualTo(loaded)
+    }
+
+    @Test
+    fun `changes the form cannot write do not fake a conflict`() {
+        val loaded = detail().toEditSnapshot(0L, 3_600_000L, berlin)
+        val fresh = detail(
+            attendees = listOf(Attendee("Ada", "ada@example.org", AttendeeStatus.Accepted)),
+        ).toEditSnapshot(0L, 3_600_000L, berlin)
+        assertThat(fresh).isEqualTo(loaded)
+    }
+
+    @Test
+    fun `populatedFields reports exactly the sections holding values`() {
+        val empty = form().copy(location = "", description = "")
+        assertThat(empty.populatedFields()).isEmpty()
+
+        val full = form().copy(
+            location = "Berlin",
+            description = "Body",
+            reminders = listOf(10),
+            rrule = "FREQ=DAILY",
+            availability = Availability.Free,
+            accessLevel = AccessLevel.Private,
+            color = 0xFFD50000.toInt(),
+        )
+        assertThat(full.populatedFields()).containsExactly(
+            EventFormField.Location,
+            EventFormField.Description,
+            EventFormField.Reminders,
+            EventFormField.Recurrence,
+            EventFormField.Availability,
+            EventFormField.Visibility,
+            EventFormField.Color,
+        )
+    }
+
+    @Test
+    fun `toEditForm carries a palette colour as key plus swatch`() {
+        val prefilled = detail(eventColor = 0xFF33B679.toInt(), eventColorKey = "5")
+            .toEditForm(beginMillis = 0L, endMillis = 3_600_000L, zone = berlin)
+        assertThat(prefilled.colorKey).isEqualTo("5")
+        assertThat(prefilled.color).isEqualTo(0xFF33B679.toInt())
+        assertThat(prefilled.populatedFields()).contains(EventFormField.Color)
+    }
+
+    @Test
+    fun `toEditForm carries a raw colour with no key`() {
+        val prefilled = detail(eventColor = 0xFF8E24AA.toInt())
+            .toEditForm(beginMillis = 0L, endMillis = 3_600_000L, zone = berlin)
+        assertThat(prefilled.colorKey).isNull()
+        assertThat(prefilled.color).isEqualTo(0xFF8E24AA.toInt())
+    }
+
+    @Test
+    fun `toEditForm leaves an inheriting event without a colour`() {
+        val prefilled = detail()
+            .toEditForm(beginMillis = 0L, endMillis = 3_600_000L, zone = berlin)
+        assertThat(prefilled.colorKey).isNull()
+        assertThat(prefilled.color).isNull()
+        assertThat(prefilled.populatedFields()).doesNotContain(EventFormField.Color)
+    }
+}

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

@@ -0,0 +1,164 @@
+package de.jeanlucmakiola.calendula.domain
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import org.junit.jupiter.api.Test
+
+class RecurrenceTest {
+
+    private val utc = TimeZone.UTC
+    private val berlin = TimeZone.of("Europe/Berlin")
+
+    @Test
+    fun `plain frequency parses with defaults`() {
+        assertThat(parseSimpleRecurrence("FREQ=WEEKLY"))
+            .isEqualTo(SimpleRecurrence(RecurrenceFreq.Weekly))
+        assertThat(parseSimpleRecurrence("FREQ=DAILY"))
+            .isEqualTo(SimpleRecurrence(RecurrenceFreq.Daily))
+    }
+
+    @Test
+    fun `leading RRULE prefix and WKST are tolerated`() {
+        assertThat(parseSimpleRecurrence("RRULE:FREQ=MONTHLY;WKST=MO"))
+            .isEqualTo(SimpleRecurrence(RecurrenceFreq.Monthly))
+    }
+
+    @Test
+    fun `interval parses`() {
+        assertThat(parseSimpleRecurrence("FREQ=WEEKLY;INTERVAL=2"))
+            .isEqualTo(SimpleRecurrence(RecurrenceFreq.Weekly, interval = 2))
+    }
+
+    @Test
+    fun `until parses date-only and UTC datetime forms`() {
+        val expected = SimpleRecurrence(
+            RecurrenceFreq.Daily,
+            end = RecurrenceEnd.Until(LocalDate(2026, 8, 1)),
+        )
+        assertThat(parseSimpleRecurrence("FREQ=DAILY;UNTIL=20260801", utc)).isEqualTo(expected)
+        assertThat(parseSimpleRecurrence("FREQ=DAILY;UNTIL=20260801T235959Z", utc))
+            .isEqualTo(expected)
+    }
+
+    @Test
+    fun `until datetime converts from UTC into the given zone before taking the date`() {
+        // 21:59:59Z == 23:59:59 in Berlin (CEST) — still August 1 there.
+        assertThat(parseSimpleRecurrence("FREQ=DAILY;UNTIL=20260801T215959Z", berlin))
+            .isEqualTo(
+                SimpleRecurrence(RecurrenceFreq.Daily, end = RecurrenceEnd.Until(LocalDate(2026, 8, 1))),
+            )
+    }
+
+    @Test
+    fun `count parses`() {
+        assertThat(parseSimpleRecurrence("FREQ=YEARLY;COUNT=5"))
+            .isEqualTo(SimpleRecurrence(RecurrenceFreq.Yearly, end = RecurrenceEnd.Count(5)))
+    }
+
+    @Test
+    fun `weekly byday parses as weekday picks`() {
+        assertThat(parseSimpleRecurrence("FREQ=WEEKLY;BYDAY=MO,FR"))
+            .isEqualTo(
+                SimpleRecurrence(
+                    RecurrenceFreq.Weekly,
+                    byDays = setOf(DayOfWeek.MONDAY, DayOfWeek.FRIDAY),
+                ),
+            )
+    }
+
+    @Test
+    fun `rules beyond the simple shape are rejected`() {
+        // Ordinal BYDAY ("second Thursday") and BYDAY on non-weekly rules.
+        assertThat(parseSimpleRecurrence("FREQ=WEEKLY;BYDAY=MO,2TH")).isNull()
+        assertThat(parseSimpleRecurrence("FREQ=MONTHLY;BYDAY=MO")).isNull()
+        assertThat(parseSimpleRecurrence("FREQ=MONTHLY;BYMONTHDAY=15")).isNull()
+        assertThat(parseSimpleRecurrence("FREQ=HOURLY")).isNull()
+        assertThat(parseSimpleRecurrence("")).isNull()
+        assertThat(parseSimpleRecurrence("FREQ=DAILY;UNTIL=20260801;COUNT=3")).isNull()
+        assertThat(parseSimpleRecurrence("FREQ=DAILY;INTERVAL=0")).isNull()
+        assertThat(parseSimpleRecurrence("FREQ=DAILY;COUNT=abc")).isNull()
+    }
+
+    @Test
+    fun `toRRule renders the minimal form`() {
+        assertThat(SimpleRecurrence(RecurrenceFreq.Weekly).toRRule()).isEqualTo("FREQ=WEEKLY")
+        assertThat(SimpleRecurrence(RecurrenceFreq.Daily, interval = 3).toRRule())
+            .isEqualTo("FREQ=DAILY;INTERVAL=3")
+        assertThat(
+            SimpleRecurrence(RecurrenceFreq.Monthly, end = RecurrenceEnd.Count(12)).toRRule(),
+        ).isEqualTo("FREQ=MONTHLY;COUNT=12")
+    }
+
+    @Test
+    fun `toRRule renders weekdays in ISO order regardless of set order`() {
+        val rule = SimpleRecurrence(
+            RecurrenceFreq.Weekly,
+            byDays = setOf(DayOfWeek.FRIDAY, DayOfWeek.MONDAY, DayOfWeek.WEDNESDAY),
+        ).toRRule()
+        assertThat(rule).isEqualTo("FREQ=WEEKLY;BYDAY=MO,WE,FR")
+    }
+
+    @Test
+    fun `toRRule ignores weekday picks on non-weekly frequencies`() {
+        val rule = SimpleRecurrence(
+            RecurrenceFreq.Monthly,
+            byDays = setOf(DayOfWeek.MONDAY),
+        ).toRRule()
+        assertThat(rule).isEqualTo("FREQ=MONTHLY")
+    }
+
+    @Test
+    fun `toRRule writes until as the end of the chosen day in the given zone`() {
+        val rule = SimpleRecurrence(
+            RecurrenceFreq.Weekly,
+            interval = 2,
+            end = RecurrenceEnd.Until(LocalDate(2026, 8, 1)),
+        )
+        assertThat(rule.toRRule(utc))
+            .isEqualTo("FREQ=WEEKLY;INTERVAL=2;UNTIL=20260801T235959Z")
+        // 23:59:59 Berlin (CEST, +2) == 21:59:59Z.
+        assertThat(rule.toRRule(berlin))
+            .isEqualTo("FREQ=WEEKLY;INTERVAL=2;UNTIL=20260801T215959Z")
+    }
+
+    // 2026-06-19T23:59:00Z — a moment just before a June 20 occurrence.
+    private val cutoffMillis = 1_781_913_540_000L
+
+    @Test
+    fun `truncation replaces count and keeps every other part`() {
+        assertThat(rruleTruncatedAt("FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,FR;COUNT=30", cutoffMillis))
+            .isEqualTo("FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,FR;UNTIL=20260619T235900Z")
+    }
+
+    @Test
+    fun `truncation replaces an existing until`() {
+        assertThat(rruleTruncatedAt("FREQ=DAILY;UNTIL=20301231T235959Z", cutoffMillis))
+            .isEqualTo("FREQ=DAILY;UNTIL=20260619T235900Z")
+    }
+
+    @Test
+    fun `truncation works on rules the simple picker cannot express`() {
+        assertThat(rruleTruncatedAt("RRULE:FREQ=MONTHLY;BYDAY=2TH", cutoffMillis))
+            .isEqualTo("FREQ=MONTHLY;BYDAY=2TH;UNTIL=20260619T235900Z")
+    }
+
+    @Test
+    fun `parse and render round-trip`() {
+        val rules = listOf(
+            "FREQ=DAILY",
+            "FREQ=WEEKLY;INTERVAL=2",
+            "FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,FR;UNTIL=20301231T235959Z",
+            "FREQ=MONTHLY;COUNT=6",
+            "FREQ=YEARLY;UNTIL=20301231T235959Z",
+        )
+        rules.forEach { rule ->
+            assertThat(parseSimpleRecurrence(rule, utc)!!.toRRule(utc)).isEqualTo(rule)
+        }
+        // Round-trips through a non-UTC zone too: 22:59:59Z == 23:59:59 CET.
+        val berlinRule = "FREQ=WEEKLY;BYDAY=MO,FR;UNTIL=20301231T225959Z"
+        assertThat(parseSimpleRecurrence(berlinRule, berlin)!!.toRRule(berlin))
+            .isEqualTo(berlinRule)
+    }
+}

docs/ARCHITECTURE.md

@@ -0,0 +1,147 @@
+# Architecture
+
+Calendula is a single-activity Jetpack Compose app layered strictly on top
+of Android's calendar provider. This document is the orientation tour: the
+principles, the layers, and the three pipelines that are not obvious from
+the package list (recurring writes, save conflicts, reminder delivery).
+
+## Principles
+
+1. **`CalendarContract` is the single source of truth.** No app database,
+   no caching layer, no sync code. Reads query the provider; writes go
+   straight back to it. Sync is DAVx5's / Google's / the system's job.
+2. **Observer-driven UI.** A `ContentObserver` on the provider triggers
+   re-queries; every screen recomposes from fresh provider state. After a
+   write, nothing is patched by hand — the provider notifies, the views
+   refresh. This also covers external changes (sync) for free.
+3. **JVM-first testing.** Everything between the UI and the
+   `ContentResolver` is shaped so it runs as a plain JUnit 5 test: pure
+   domain logic, cursor-free mappers, a `FakeCalendarDataSource` for
+   repository tests. Instrumented tests are a last resort.
+4. **No network.** The app declares no `INTERNET` permission. Anything that
+   would need one is an explicit, documented product decision first
+   (see the roadmap's idea backlog).
+
+## Layers
+
+```mermaid
+flowchart TD
+    subgraph UI ["ui/ — Compose screens + ViewModels"]
+        Screens["Month / Week / Day\nDetail / Edit / Settings\nPermission + Reminder onboarding"]
+    end
+    subgraph Data ["data/"]
+        Repo["CalendarRepository\n(interface + impl, Flow-based, io-dispatched)"]
+        DS["CalendarDataSource\n(interface + AndroidCalendarDataSource)"]
+        Prefs["SettingsPrefs / CalendarPrefs\n(DataStore)"]
+        Rem["reminders/\nReminderAlertStore + ReminderNotifier"]
+    end
+    Provider[("CalendarContract\n(system calendar provider)")]
+
+    Screens --> Repo
+    Screens --> Prefs
+    Repo --> DS
+    DS --> Provider
+    Provider -. "ContentObserver tick" .-> Repo
+    Provider -. "EVENT_REMINDER broadcast" .-> Rem
+    Rem --> Provider
+```
+
+- **`domain/`** — pure Kotlin, no Android imports: models
+  (`EventInstance`, `EventDetail`, `CalendarSource`, …), the `EventForm`
+  with validation, `SimpleRecurrence` (RRULE parse/render for the picker),
+  and `EditSnapshot` (conflict detection). All JVM-tested.
+- **`data/calendar/`** — the provider seam. `AndroidCalendarDataSource`
+  owns every `ContentResolver` call; cursor parsing lives in mappers
+  (`InstanceMapper`, `EventDetailMapper`, `CalendarMapper`) that read
+  through a `ColumnReader` abstraction so tests feed them plain maps.
+  `EventWriteMapper` builds dirty-checked update value sets. `TimeBridge`
+  converts provider epoch millis ↔ `kotlin.time.Instant`.
+- **`data/reminders/`** — the notification pipeline (see below). Kept out
+  of `data/calendar/` because the receiver needs neither the repository
+  nor its flows.
+- **`data/prefs/`** — DataStore-backed settings (theme, week start, form
+  field defaults, reminders toggle) and small state (last-used calendar).
+- **`ui/`** — one package per screen, each with Screen + ViewModel +
+  UiState. Shared pieces in `ui/common/` (OptionCard — the app's only
+  sanctioned selection-dialog style —, recurrence humanizer, FAB column,
+  drawer, transitions).
+
+## Navigation
+
+There is no navigation library. `MainActivity` hosts `RootScreen`, which
+gates on the calendar permission and the one-time reminder onboarding, then
+shows `CalendarHost`. `CalendarHost` holds the active view (month/week/day)
+plus overlay state for detail, edit, and settings — full-screen overlays
+driven by `AnimatedVisibility` with a *held-key* pattern: the last shown
+key stays alive through the slide-out so content never flashes empty.
+A tapped reminder notification routes through `MainActivity` (`singleTop` +
+`onNewIntent`) as an external detail key that `CalendarHost` consumes
+exactly like an event tap.
+
+## Recurring writes
+
+The provider's invariants drive the design (learned the hard way, verified
+on-device — see plan 03):
+
+- Recurring rows carry `RRULE` + `DURATION` (no `DTEND`); one-off rows
+  carry `DTEND`.
+- *Only this event* → insert a **modified-occurrence exception** via
+  `CONTENT_EXCEPTION_URI` (the provider clones the series row, so empty
+  optionals are written as explicit NULLs).
+- *This and following* → **series split**: insert the new event first (if
+  that fails the original is untouched), then truncate the original's
+  RRULE with `UNTIL`.
+- Truncation updates must send the **complete time-column set**
+  (`DTSTART`/`DURATION`/`RRULE`/`ALL_DAY`/`EVENT_TIMEZONE`) — the provider
+  regenerates cached instances only from the values carried by the update
+  itself; an RRULE-only update leaves stale instances behind.
+- `UNTIL` is written as the local end of the previous day expressed in
+  UTC, so zones ahead of UTC can't leak an extra occurrence.
+- All-day events are normalised to UTC midnights with an exclusive end.
+
+## Save conflicts
+
+No locking. `openForEdit` keeps an `EditSnapshot` — the prefilled form
+*plus the raw Events-row times* (the form derives its times from the tapped
+occurrence, so a remotely moved event would otherwise be invisible to it).
+Right before writing, the event is re-read and snapshots compared: a
+mismatch parks the save in an overwrite/discard dialog; a vanished event
+informs and closes. Overwrite still writes only dirty fields, so external
+changes to untouched fields survive either way. Fields the form cannot
+write (attendees, status, reminder methods) are excluded so sync noise
+can't fake a conflict.
+
+## Reminder delivery
+
+The provider schedules reminder alarms (for `METHOD_ALERT` rows only) and
+broadcasts `EVENT_REMINDER` — but posts no notification; a calendar app
+must (the Etar model):
+
+```mermaid
+sequenceDiagram
+    participant P as CalendarProvider
+    participant R as EventReminderReceiver
+    participant S as ReminderAlertStore
+    participant N as ReminderNotifier
+    P->>R: EVENT_REMINDER broadcast (manifest receiver, exported)
+    R->>S: dueAlerts(now) — CalendarAlerts: SCHEDULED, alarmTime ≤ now
+    S-->>R: due alerts
+    R->>N: post(alert) — one notification per alert, tag = alert id
+    R->>S: markFired(ids) — best effort, needs WRITE_CALENDAR
+```
+
+Posting happens before marking: a crash in between re-posts silently (same
+tag + `setOnlyAlertOnce`) rather than losing a reminder. Swiped
+notifications never return because `FIRED` rows are never re-queried.
+Deliberately absent until real devices prove it necessary: own alarm
+scheduling, `BOOT_COMPLETED`, snooze/dismiss actions, battery-exemption
+prompts.
+
+## Testing
+
+JUnit 5 + Truth + Turbine on the JVM. The seams that make it work:
+`CalendarDataSource` is faked (`FakeCalendarDataSource` records writes),
+mappers parse `ColumnReader`/plain maps instead of cursors, domain logic
+(recurrence, validation, snapshots, write-value building) is pure. CI
+(Gitea Actions) runs `lint test assembleDebug` on every push; release tags
+additionally build, sign, and publish to the self-hosted F-Droid repo.

docs/README.md

@@ -0,0 +1,20 @@
+# Documentation map
+
+Where to look for what:
+
+| Document | What it is |
+|---|---|
+| [`ARCHITECTURE.md`](ARCHITECTURE.md) | Orientation tour: principles, layers, navigation, recurring-write / conflict / reminder pipelines, testing |
+| [`../CHANGELOG.md`](../CHANGELOG.md) | Release history (Keep a Changelog, SemVer) |
+| [`../.planning/ROADMAP.md`](../.planning/ROADMAP.md) | Living roadmap: shipped milestones, current scope, idea backlog |
+| [`../.planning/PROJECT.md`](../.planning/PROJECT.md) | What the project is, stack, naming, infrastructure |
+| [`../.planning/REQUIREMENTS.md`](../.planning/REQUIREMENTS.md) | Requirement checklist per milestone |
+| [`../.planning/STATE.md`](../.planning/STATE.md) | Snapshot of where development currently stands |
+| [`superpowers/specs/`](superpowers/specs/) | The original design spec (2026-06-08) — historical record, not updated |
+| [`superpowers/plans/`](superpowers/plans/) | Per-milestone implementation plans with task checklists — historical record of how each slice was built, including provider lessons learned |
+| [`../fdroid-metadata/`](../fdroid-metadata/) | F-Droid/fastlane store metadata: descriptions, icon, screenshots (DE + EN) |
+
+Conventions: plans and specs under `superpowers/` are point-in-time
+artifacts of the agentic workflow that built each milestone — they get
+status updates but are never rewritten. The `.planning/` files are living
+documents and should stay current.

docs/RELEASING.md

@@ -0,0 +1,101 @@
+# Releasing Calendula
+
+Calendula is distributed through a self-hosted F-Droid repository. Every
+release is built, signed, and published automatically by
+`.gitea/workflows/release.yaml` when a version tag is pushed.
+
+## Versioning — the git tag is the single source of truth
+
+A release is defined by its tag, `vMAJOR.MINOR.PATCH` (e.g. `v2.1.0`). At
+release time the workflow derives both Gradle fields from the tag:
+
+- `versionName` = the tag without the leading `v` (`2.1.0`)
+- `versionCode` = `MAJOR*10000 + MINOR*100 + PATCH` (`2.1.0` → `20100`)
+
+So `MINOR` and `PATCH` each have room for 0–99. The values committed in
+`app/build.gradle.kts` are only the dev/local default — CI overwrites them
+from the tag. Keep the committed `versionCode`/`versionName` matching the
+**latest released tag** so local builds are sanely versioned; the published
+value always comes from the tag.
+
+Published version codes so far: `v0.1.0`→100 … `v1.0.0`→10000 … `v2.0.0`→20000.
+
+## Cutting a release
+
+1. Move the `## [Unreleased]` section of `CHANGELOG.md` under a new
+   `## [X.Y.Z] — <date>` heading (Keep a Changelog format). The text between
+   that heading and the next `## [` becomes both the Gitea release notes and
+   the F-Droid per-version changelog.
+2. Optionally bump the committed `versionCode`/`versionName` in
+   `app/build.gradle.kts` to match the new version (keeps local builds tidy).
+3. Commit, then tag and push:
+   ```bash
+   git tag vX.Y.Z
+   git push origin vX.Y.Z
+   ```
+4. The push triggers the release workflow. **Hold UI releases for on-device
+   review and explicit go-ahead before tagging.**
+
+## What the pipeline does
+
+`release.yaml` has three jobs:
+
+- **ci** — unit tests + a debug assemble (sanity).
+- **build-and-deploy** — derives the version, builds & signs the release APK
+  with the app key, copies it into the F-Droid repo, generates the per-version
+  changelog, re-signs the F-Droid index with the **repo key**, uploads
+  `repo/` + `metadata/` to the box, and attaches the R8 `mapping.txt` to the
+  Gitea release (best-effort).
+- **gitea-release** — creates/updates the Gitea release carrying the tag's
+  CHANGELOG section as notes. Gated on `ci` only (not the deploy) so notes
+  publish even if the F-Droid upload hiccups.
+
+### Manual re-sign / recovery
+
+A manual `workflow_dispatch` of the release workflow **from a branch** (not a
+tag) runs a **re-sign-only** path: it skips the APK build and just re-signs
+the existing F-Droid index with the configured repo key and re-uploads. Use
+this for key rotation or repo recovery without publishing a new app version.
+
+## Secrets (Gitea → repo Settings → Actions → Secrets)
+
+| Secret | Purpose |
+| --- | --- |
+| `KEYSTORE_BASE64`, `KEY_PASSWORD`, `KEY_ALIAS` | **App** signing key — signs the APK. Losing it means existing installs can't be updated. |
+| `FDROID_KEYSTORE_BASE64` | **F-Droid repo** signing key (`keystore.p12`, base64). Signs the repo index. |
+| `FDROID_CONFIG_BASE64` | F-Droid `config.yml` (base64) — repo metadata + keystore passwords. |
+| `HETZNER_HOST`, `HETZNER_USER`, `HETZNER_PASS` | Upload target for the F-Droid repo. |
+| `GITHUB_TOKEN` | Provided by Gitea Actions; used to create the release + attach assets. |
+
+The two keys are independent: the **app key** signs APKs; the **repo key**
+signs the index (its fingerprint is what users pin). Neither key nor the
+F-Droid `config.yml` is ever uploaded to the server — they live only in CI
+secrets and are reconstructed in-runner. If `FDROID_KEYSTORE_BASE64` /
+`FDROID_CONFIG_BASE64` are unset the workflow **fails loudly** rather than
+minting a new repo key (which would break every user's pinned fingerprint).
+
+## Key custody & recovery
+
+- **Offline backups** of both keys (and passwords) live in a password manager.
+  These are the only safe copies — losing them is unrecoverable.
+- **App key lost** → no existing install can be updated again; you'd have to
+  ship a new app under a new applicationId.
+- **Repo key lost or compromised** → rotate it, publish the new fingerprint in
+  the README, and have users remove + re-add the repo. To rotate: generate a
+  new `keystore.p12` + `config.yml`, set them as the `FDROID_*` secrets, update
+  the README fingerprint, and run the manual re-sign dispatch above.
+
+## F-Droid repo
+
+- URL: `https://apps.dev.jeanlucmakiola.de/dev/fdroid/repo`
+- Fingerprint (current): `C2C0640402BF458FC0ED957AF0B37AA4C14022E72F89CE90B5965B458CF73425`
+- Served from the Hetzner storage box. **nginx serves only `…/fdroid/repo/`** —
+  the working dir (key, config, metadata) sits above it and must never be
+  web-reachable. After any webserver change, verify `keystore.p12` and
+  `config.yml` return 404 while `repo/index-v2.json` returns 200.
+
+## Crash deobfuscation
+
+Each release attaches `mapping-<version>.txt.gz` (the R8 mapping) to its Gitea
+release. To deobfuscate a user stacktrace, download the mapping for that
+version and run it through `retrace`.

docs/superpowers/plans/2026-06-11-03-write-support.md

@@ -0,0 +1,204 @@
+# Calendula - Plan 03: Write Support (Milestone 2 / v2.0)
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Calendula kann Events anlegen, bearbeiten und löschen — direkt über
+`CalendarContract`-Writes, ohne eigene DB. Der V1-Spec dient als Leitplanke,
+nicht als Gesetz: Ausgeliefert wird in vier Slices (v1.1 → v2.0), jeder Slice
+ist für sich releasebar und lässt `./gradlew lint test assembleDebug` grün.
+
+**Architecture:** Writes laufen durch dieselbe Schichtung wie Reads:
+`ui/` → `CalendarRepository` (Interface) → `CalendarDataSource` →
+`ContentResolver.insert/update/delete`. Kein neuer Layer, keine Transaktions-
+Abstraktion — der Provider notified nach jedem Write selbst, der bestehende
+`ContentObserver`-Tick aktualisiert alle Views automatisch (F3 gilt unverändert).
+Domain bleibt pure Kotlin.
+
+**Leitentscheidungen (Abweichungen / Präzisierungen ggü. Spec §2 "V2"):**
+
+1. **Permission-Strategie:** `WRITE_CALENDAR` kommt ins Manifest. Das Onboarding
+   fragt READ+WRITE zusammen an (eine System-Dialog-Gruppe), zwingend bleibt
+   nur READ — wer Write ablehnt, nutzt die App weiter read-only.
+   v1.0-Upgrader (haben nur READ) bekommen den WRITE-Request kontextuell beim
+   ersten Schreib-Versuch. Onboarding-Footnote verliert die "Nur Lesezugriff"-
+   Behauptung (wäre mit Manifest-Eintrag gelogen).
+2. **Read-only-Kalender respektieren:** `Calendars.CALENDAR_ACCESS_LEVEL` wird
+   mitgelesen (`canModifyContents` = Level ≥ `CAL_ACCESS_CONTRIBUTOR`).
+   Edit/Delete-Actions erscheinen gar nicht erst für WebCal-Subscriptions,
+   Geburtstags- und andere read-only-Kalender.
+3. **Recurring Events:** Löschen bietet "Nur dieser Termin" (Exception-Insert
+   via `Events.CONTENT_EXCEPTION_URI` mit `STATUS_CANCELED` +
+   `ORIGINAL_INSTANCE_TIME`) vs. "Ganze Serie" (Delete der Events-Row).
+   Bearbeiten startet mit "ganze Serie"; Occurrence-Edit (Exception mit neuen
+   Werten) folgt erst, wenn das Serien-Edit stabil ist.
+4. **Kein RRULE-Editor in v1.2:** Create startet ohne Wiederholungs-UI
+   (einmalige Events). Ein einfacher Recurrence-Picker (täglich/wöchentlich/
+   monatlich/jährlich + Ende) kommt mit v1.3/v2.0.
+5. **Conflict UX (Spec V2 "event modified externally during edit"):** kein
+   Locking. Beim Speichern wird gegen die beim Laden gemerkte Row verglichen
+   (Dirty-Check auf den editierten Feldern); bei externem Konflikt Dialog
+   "Überschreiben / Verwerfen". Mehr ist YAGNI.
+
+---
+
+## Slices
+
+| Slice | Inhalt | Status |
+|---|---|---|
+| v1.1 | Write-Fundament: `WRITE_CALENDAR`, `canModifyContents`, Delete (Serie + einzelnes Vorkommen) | ausgeliefert (v1.1.0, 2026-06-11) |
+| v1.2 | Create: Event-Formular (Titel, Kalender, ganztägig, Start/Ende, Ort, Beschreibung), FAB, Default-Kalender-Pref | ausgeliefert (v1.2.0, 2026-06-11) |
+| v1.3 | Edit: Formular wiederverwendet, Serien-Edit, Reminder-Edit, einfacher Recurrence-Picker | ausgeliefert (v1.3.0, 2026-06-11) |
+| v2.0 | Konflikt-Dialog, Polish-Pass (Store-Copy, Screenshots), Release | ausgeliefert (v2.0.0, 2026-06-11) |
+
+## v1.1 — Write-Fundament + Delete
+
+**Build/Manifest:**
+- [x] `AndroidManifest.xml`: `WRITE_CALENDAR` ergänzen
+
+**Data layer:**
+- [x] `Projections.kt`: `CALENDAR_ACCESS_LEVEL` in `CalendarProjection`
+- [x] `Models.kt`: `CalendarSource.canModifyContents: Boolean` (Default `false`).
+      Kein neuer `FailureReason` — Delete-Fehler sind ein Snackbar-Fall, kein
+      Full-Screen-Failure
+- [x] `CalendarMapper.kt`: Access-Level → `canModifyContents`
+- [x] `CalendarDataSource`: `deleteEvent(eventId)`, `deleteOccurrence(eventId, beginMillis)`
+      — Impl in `AndroidCalendarDataSource` (`delete` auf Events-URI bzw.
+      Exception-Insert), `WriteFailedException` bei 0 rows / null-Uri
+- [x] `CalendarRepository(+Impl)`: beide Methoden durchreichen, auf `io`
+
+**UI:**
+- [x] `EventDetailUiState.Success.canModify` (Kalender-Lookup im ViewModel)
+- [x] `EventDetailViewModel`: `delete(mode)` mit eigenem One-Shot-State
+      (Idle/Deleting/Deleted/Failed); `SecurityException` → kontextueller
+      WRITE-Request statt Failure-Screen
+- [x] `EventDetailScreen`: Edit/Delete nur wenn `canModify`; Delete →
+      Confirm-Dialog (recurring: "Nur dieser Termin" / "Ganze Serie"),
+      Erfolg → zurück, Fehler → Snackbar
+- [x] Onboarding (`PermissionScreen`): `RequestMultiplePermissions` READ+WRITE,
+      Gate bleibt READ; Copy-Anpassung (Footnote, Rationale-Body) DE+EN
+
+**Tests:**
+- [x] `FakeCalendarDataSource`: Write-Ops aufnehmen
+- [x] `CalendarRepositoryImplTest`: delete-Pfade (Erfolg, Fehler)
+- [x] `CalendarMapperTest`: Access-Level-Mapping
+
+## v1.2 — Create
+
+- [x] `EventForm`-Domain-Modell + Validierung (`problems()`: EndBeforeStart,
+      NoCalendar; leerer Titel und Instant-Events erlaubt)
+- [x] `EventEditScreen` (ein Formular, ab v1.3 auch für Edit), M3-Date/Time-Picker
+- [x] FAB-Stack auf allen drei Hauptansichten (`CalendarFabColumn`: "+" immer,
+      Heute-Pill darüber), vorbelegt mit dem sichtbaren Tag
+- [x] Kalender-Vorauswahl: explizit > zuletzt benutzt
+      (`CalendarPrefs.lastUsedCalendarId` statt Settings-Eintrag) > erster
+      beschreibbarer; Picker bietet nur beschreibbare Kalender an
+- [x] `insertEvent(form): Long` im DataSource; `EventWriteMapper` (JVM-testbar)
+      normalisiert all-day auf UTC-Mitternächte mit exklusivem DTEND
+
+## v1.3 — Edit
+
+**Domain:**
+- [x] `EventForm.rrule` (roher RRULE-Wert, null = einmalig); komplexe Regeln
+      (ordinales BYDAY wie "2TH", BYMONTHDAY etc.) bleiben verbatim erhalten,
+      solange der Picker sie nicht ersetzt
+- [x] `SimpleRecurrence` (FREQ + INTERVAL + UNTIL/COUNT + wöchentliches
+      BYDAY — Review-Feedback: "jede Woche Mo+Fr" muss gehen) mit
+      `parseSimpleRecurrence`/`toRRule` (Recurrence.kt, JVM-getestet)
+- [x] `EventDetail.toEditForm(begin, end, zone)` — Prefill inkl. all-day-
+      Rückrechnung (exklusives DTEND → letzter abgedeckter Tag)
+- [x] Validierung: `RecurrenceEndsBeforeStart` (UNTIL vor erstem Tag hieße
+      null Vorkommen — Event würde unsichtbar)
+
+**Data layer:**
+- [x] `buildEventUpdateValues(original, updated, seriesDtStart, zone)` —
+      Dirty-Check, nur geänderte Spalten; Zeitfelder als Einheit:
+      einmalig → DTSTART/DTEND (RRULE/DURATION genullt), wiederkehrend →
+      Serien-DTSTART verschiebt sich um das User-Delta, DURATION statt DTEND
+- [x] `CalendarDataSource.updateEvent(eventId, original, updated)` — Events-Row-
+      Update + Reminder-Diff nach Minuten (unberührte Rows behalten ihre Methode)
+- [x] `insertEvent` versteht RRULE (RRULE+DURATION statt DTEND — Provider-Invariante)
+- [x] `CalendarRepository(+Impl).updateEvent` durchgereicht, auf `io`
+- [x] `EventDetailMapper`: Titel bleibt roh (kein "(Ohne Titel)"-Fallback mehr —
+      der Detail-Screen ersetzt selbst lokalisiert, das Formular braucht den Rohwert)
+
+**UI:**
+- [x] `EventEditViewModel.openForEdit` (lädt Detail, merkt Original für
+      Dirty-Check; unverändertes Formular speichert als No-Op); Felder mit
+      Werten werden unabhängig vom Settings-Default eingeblendet
+- [x] `EventEditScreen`: `editKey`-Parameter, Kalender im Edit-Modus fixiert,
+      Repeat-Karte + `RecurrencePickerDialog` (Presets per Tap, Custom-Schritt
+      mit Intervall/Einheit + Wochentags-Toggles bei "Wochen" (Wochenstart
+      nach Locale, Start-Wochentag vorausgewählt) + Ende nie/Datum/Anzahl,
+      OptionCard-Stil)
+- [x] Recurrence-Humanizer nach `ui/common/RecurrenceText.kt` (Detail + Formular)
+- [x] `EventDetailScreen`: Edit-Action (nur `canModify`, kontextueller
+      WRITE-Request wie Delete); Save schließt Formular **und** Detail (die
+      getappte Occurrence existiert danach evtl. nicht mehr)
+- [x] **Occurrence-Edit (aus v2.0 vorgezogen, Review-Feedback):** Die
+      Scope-Frage kommt **beim Speichern** (Google-Modell, Review-Feedback):
+      ein dirty wiederkehrender Termin parkt in `SaveUiState.AwaitingScope`,
+      der Dialog bietet "Nur dieser Termin / Dieser und alle folgenden /
+      Ganze Serie"; bei geänderter Wiederholungsregel entfällt "nur dieser"
+      (eine Exception-Row trägt keine eigene Regel). "Nur dieser" schreibt
+      eine Modified-Occurrence-Exception (`CONTENT_EXCEPTION_URI`, alle
+      Formularwerte, leere Optionals als explizite NULLs weil der Provider
+      die Serien-Row klont), Reminder werden gegen die tatsächlichen
+      Provider-Rows abgeglichen. "Dieser und folgende" = Serien-Split:
+      neues Event mit den Formularwerten (insert zuerst — schlägt es fehl,
+      bleibt das Original unberührt), dann Original-RRULE per UNTIL gekappt;
+      ab der ersten Occurrence = normales Serien-Update. Ein mitgenommenes
+      COUNT zählt in der neuen Serie neu (kein Rest-COUNT-Rechnen wie AOSP)
+- [x] **Delete dreistufig (Review-Feedback):** "Nur dieser Termin" /
+      "Dieser und alle folgenden" (RRULE-Truncation via `rruleTruncatedAt`)
+      / "Alle Termine der Serie"; ab der ersten Occurrence = ganze Serie
+      löschen
+- [x] **Split-Duplikat-Bugfix (On-Device-Review):** Nach dem Serien-Split
+      blieb die getappte Occurrence doppelt sichtbar. Root cause (per
+      adb-Probe verifiziert): der Provider regeneriert die Instances eines
+      Events nur aus den **Values des Updates selbst** — ein RRULE-only-
+      Update lässt die alten Instances stehen, und ein Teilset (nur DTSTART)
+      erzeugt kaputte Nulllängen-Instanzen. Truncation-Updates schicken
+      deshalb das komplette Zeit-Set (DTSTART/DURATION/RRULE/ALL_DAY/
+      EVENT_TIMEZONE) zusammen (`truncateSeries`), wie AOSPs
+      EditEventHelper. Zusätzlich (Robustheit, Google-Modell): Cutoff =
+      Ende des Vortags in der Event-Zeitzone (`previousLocalDayEndUtcMillis`)
+      statt Occurrence−1s, und der Recurrence-Picker rendert UNTIL als
+      lokales Tagesende in UTC (`toRRule(zone)`) statt pauschal `T235959Z`
+      (sonst kann bei UTC+x ein Extra-Tag hineinrutschen)
+- [x] `CalendarHost`: Edit-Overlay mit Held-Key-Pattern
+- [x] `EventFormField.Recurrence` (Formular, "Mehr Felder", Settings-Default)
+- [x] Strings DE+EN
+
+**Tests:**
+- [x] `RecurrenceTest` (Parse/Render/Roundtrip, Ablehnung komplexer Regeln)
+- [x] `EventFormTest`: Prefill (timed/all-day), `populatedFields`, UNTIL-Validierung
+- [x] `EventWriteMapperTest`: Duration-Format, Dirty-Check-Pfade (Text-only,
+      Zeit einmalig/wiederkehrend, Recurrence an/aus, Reminder-only)
+- [x] `CalendarRepositoryImplTest` + `FakeCalendarDataSource`: update-Pfade
+- [x] `EventDetailMapperTest`: roher Titel
+
+Bewusst nicht in v1.3 (→ v2.0): Konflikt-Dialog, Kalender-Wechsel beim
+Bearbeiten (Sync-Adapter-Minenfeld, sperren auch alle Stock-Apps).
+
+## v2.0 — Abschluss (Scope-Recut 2026-06-11, nach v1.4)
+
+- ~~Quick-Add-Sheet (Titel + Zeit, Rest Defaults)~~ — **gestrichen**: das
+  Formular öffnet bereits vorbefüllt (sichtbarer Tag, zuletzt benutzter
+  Kalender, optionale Felder versteckt); der Sheet spart nur einen
+  Screen-Übergang und kostet eine zweite Create-Surface. Nur bei
+  Praxis-Feedback wieder aufnehmen
+- ~~Occurrence-Edit (Exception mit geänderten Werten)~~ — schon in v1.3
+  ausgeliefert (vorgezogen)
+- [x] Konflikt-Dialog beim Speichern (Leitentscheidung 5): `EditSnapshot`
+      (Formular + rohe Row-Zeiten) wird beim Laden gemerkt und vor dem
+      Schreiben gegen einen frischen Read verglichen; Abweichung parkt den
+      Save in `AwaitingConflict` (Überschreiben/Verwerfen/Abbrechen,
+      OptionCard-Stil), gelöschtes Event → `Gone`-Dialog. "Überschreiben"
+      schreibt weiterhin nur dirty Felder
+- Kalender-Wechsel beim Bearbeiten → v3-Backlog (copy+delete-Modell)
+- [x] Polish: F-Droid-Description + README auf Write-Support + Reminder
+      aktualisiert (DE+EN)
+- [x] F-Droid-Screenshots (de-DE + en-US, je 6: Woche/Monat/Tag/Detail/
+      Formular/Onboarding) — mit Demo-Kalendern auf dem Gerät aufgenommen
+- [x] Changelog, Release-Tag v2.0.0 (ausgeliefert 2026-06-11 — Milestone 2
+      damit abgeschlossen)

docs/superpowers/plans/2026-06-11-04-reminder-notifications.md

@@ -0,0 +1,119 @@
+# Calendula - Plan 04: Reminder Notifications (v1.4)
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Calendula stellt Erinnerungen selbst als Notification zu (Etar-Modell).
+Der Provider plant die Alarme und broadcastet
+`android.intent.action.EVENT_REMINDER` — die sichtbare Notification postet er
+**nicht**, das muss eine Kalender-App tun. Für Nutzer, deren einzige
+Kalender-App Calendula ist, ist das essenziell, kein Nice-to-have.
+`./gradlew lint test assembleDebug` bleibt grün; Release erst nach
+On-Device-Review.
+
+**Architecture:** Eigenes kleines Datenmodul `data/reminders/` neben
+`data/calendar/` — der Receiver braucht weder Repository noch Flows. Schichtung
+wie gehabt: `EventReminderReceiver` (Hilt-EntryPoint) →
+`ReminderAlertStore` (Interface, Android-Impl auf `CalendarAlerts`) →
+`ReminderNotifier` (NotificationManager). Domain bleibt pure Kotlin
+(`ReminderAlert`-Modell, JVM-testbare Textformatierung).
+
+**Recherche-Befunde (AOSP `CalendarAlarmManager` + Etar, 2026-06-11):**
+
+1. Der Provider legt `CalendarAlerts`-Rows **nur für `METHOD_ALERT`-Reminder**
+   an (AOSP-Query: `AND method=1`). Der im Roadmap-Eintrag geforderte
+   METHOD-Filter (E-Mail überspringen) passiert also schon upstream — wir
+   filtern nicht doppelt. Calendula schreibt eigene Reminder ohnehin als
+   `METHOD_ALERT`.
+2. Der Broadcast ist implizit (Action + `content://com.android.calendar/…`-URI,
+   Extra `alarmTime`). Etars Manifest-Receiver ist `exported="true"` mit
+   `<data android:scheme="content"/>` — das übernehmen wir (plus Host,
+   enger gefasst). Den URI-Inhalt werten wir nicht aus; wir queryen selbst
+   "fällig & noch SCHEDULED".
+3. Etar postet aus dem Zustand `SCHEDULED ∪ FIRED` und verwaltet Dismiss über
+   eigene Services. Wir vereinfachen: nur `STATE_SCHEDULED AND alarmTime <= now`
+   posten, danach best-effort auf `FIRED` setzen (braucht `WRITE_CALENDAR`;
+   `SecurityException` wird geschluckt). Weggewischte Notifications kommen so
+   nie wieder, ohne deleteIntent-Maschinerie: FIRED-Rows fassen wir nicht an.
+   Re-Broadcasts ohne Write-Recht ersetzen still (Tag pro Alert +
+   `setOnlyAlertOnce`).
+
+**Leitentscheidungen:**
+
+1. **Kein eigenes Alarm-Scheduling** (kein `SCHEDULE_EXACT_ALARM`, kein
+   `BOOT_COMPLETED`, kein WorkManager): Zustellung hängt am Provider-Broadcast.
+   Etars Zusatz-Maschinerie (eigener AlarmScheduler) kommt erst, wenn sich
+   Zuverlässigkeit auf echten Geräten als Problem zeigt (Roadmap: bewusst
+   verschoben, ebenso Snooze-/Dismiss-Actions und Battery-Exemption).
+2. **Toggle default ON, Onboarding-Schritt danach:** Nach dem Kalender-Grant
+   folgt ein zweiter Onboarding-Screen (gleiche Shell wie der Permission-
+   Screen): erklärt Reminder, warnt vor Duplikaten (zweite Kalender-App mit
+   aktiven Notifications), fragt `POST_NOTIFICATIONS` an (nur API 33+ zeigt
+   einen Dialog; minSdk 29). "Später" schaltet den Toggle aus. Der Schritt
+   erscheint genau einmal (`reminder_onboarding_done`-Pref) — auch für
+   v1.0–v1.3-Upgrader, die das Feature so entdecken.
+3. **Settings-Spiegel:** Abschnitt "Erinnerungen" mit demselben Toggle +
+   Duplikat-Hinweis. Einschalten fordert `POST_NOTIFICATIONS` kontextuell an,
+   wenn sie fehlt.
+4. **Tap öffnet das Event-Detail:** Notification-Intent trägt
+   eventId/begin/end; `MainActivity` wird `singleTop`, reicht den Key als
+   Compose-State an `CalendarHost` durch (gleiches LongArray-Key-Muster wie
+   der Detail-Overlay selbst).
+5. **Ein Kanal, einfache Inhalte:** Kanal "Erinnerungen"
+   (`IMPORTANCE_HIGH`), pro Alert eine Notification (Tag = Alert-Id):
+   Titel = Eventtitel (Fallback "(Ohne Titel)"), Text = Zeitspanne
+   (ganztägig: Datum, UTC gelesen) + Ort. Kein Grouping/Summary, kein
+   Vollbild-Alarm.
+
+---
+
+## Tasks
+
+**Manifest / Resourcen:**
+- [x] `POST_NOTIFICATIONS` ins Manifest; Receiver `.reminders.EventReminderReceiver`
+      `exported="true"`, Intent-Filter `EVENT_REMINDER` + `data scheme=content
+      host=com.android.calendar`; `MainActivity` → `launchMode="singleTop"`
+- [x] Monochromes Notification-Icon `drawable/ic_notification.xml`
+- [x] Strings DE+EN: Kanal, Onboarding-Copy, Settings-Abschnitt + Hinweis
+
+**Prefs:**
+- [x] `SettingsPrefs.remindersEnabled` (default **true**) + Setter;
+      `reminderOnboardingDone` (default false) + Setter; `SettingsPrefsTest`
+
+**Data layer (`data/reminders/`):**
+- [x] `ReminderAlert`-Modell (in `data/reminders/`, nicht domain — Alerts
+      erreichen nie einen Screen): alertId, eventId, begin/end als Millis,
+      title, location, isAllDay
+- [x] `ReminderAlertStore` (Interface) + `AndroidReminderAlertStore`:
+      `dueAlerts(nowMillis)` = `CalendarAlerts` mit
+      `STATE_SCHEDULED AND ALARM_TIME <= now`;
+      `markFired(ids, nowMillis)` setzt STATE/RECEIVED_TIME/NOTIFY_TIME,
+      `SecurityException` → Log (Write-Recht optional)
+- [x] `ReminderNotifier`: Kanal lazy anlegen, eine Notification pro Alert
+      (Tag = alertId, `setOnlyAlertOnce`, autoCancel, `when` = begin,
+      Category EVENT), Content-PendingIntent auf `MainActivity` mit
+      eventId/begin/end
+- [x] Zeitspannen-Text als pure Funktion (JVM-testbar) + Test
+
+**Receiver:**
+- [x] `EventReminderReceiver` (`@AndroidEntryPoint`): Action prüfen,
+      `goAsync()`; raus, wenn Pref aus, READ_CALENDAR fehlt oder
+      Notifications systemseitig geblockt; sonst posten → `markFired`
+
+**UI:**
+- [x] Onboarding-Shell aus `PermissionScreen` extrahieren
+      (`OnboardingScaffold` + BenefitRow, intern wiederverwendet)
+- [x] `NotificationOnboardingScreen` + ViewModel: Benefit-Rows (verpasst
+      nichts / Duplikat-Warnung), Primär-Button fordert `POST_NOTIFICATIONS`
+      (API 33+) und lässt den Toggle an, "Später" schaltet ihn aus; beide
+      setzen `reminder_onboarding_done`
+- [x] `RootScreen`: Kalender-Gate → Reminder-Schritt (einmalig) → `CalendarHost`
+- [x] `CalendarHost`: externer Detail-Key (Notification-Tap) wird wie ein
+      Event-Tap konsumiert; `MainActivity` parst Intent (onCreate +
+      onNewIntent) in Compose-State
+- [x] Settings: Abschnitt "Benachrichtigungen" — Toggle (mit kontextuellem
+      Permission-Request beim Einschalten) + Duplikat-Hinweistext
+
+**Abschluss:**
+- [x] `./gradlew lint test assembleDebug` grün
+- [x] CHANGELOG (`[Unreleased]`), ROADMAP-Status; **kein** Tag/Release vor
+      On-Device-Review

fdroid-metadata/de.jeanlucmakiola.calendula/de-DE/description.txt

@@ -1,12 +1,17 @@
-Calendula ist eine moderne, quelloffene Kalender-App für Android. Sie liest
-direkt aus dem System-Kalender-Provider — jede Quelle, die mit deinem Gerät
-synchronisiert ist (Nextcloud über DAVx5, Google, lokal, WebCal-Subscriptions)
-erscheint automatisch.
+Calendula ist eine moderne, quelloffene Kalender-App für Android. Sie
+arbeitet direkt auf dem System-Kalender-Provider — jede Quelle, die mit
+deinem Gerät synchronisiert ist (Nextcloud über DAVx5, Google, lokal,
+WebCal-Subscriptions), erscheint automatisch, und deine Änderungen
+synchronisieren auf demselben Weg zurück.
+
+Termine erstellen, bearbeiten und löschen — auch wiederkehrende, mit
+wählbarer Reichweite (nur dieser Termin / dieser und alle folgenden / ganze
+Serie) und einem einfachen Wiederholungs-Picker. Erinnerungen stellt
+Calendula selbst als Benachrichtigung zu — ein Tipp darauf öffnet den
+Termin.
 
 Der Unterschied liegt im Design: echtes Material 3 Expressive durchgehend,
 mit Dynamic Color, expressiven Animationen und neuen Shape-Sprachen.
 
-V1 ist read-only. Erstellen, Bearbeiten und Löschen von Events kommt mit V2.
-
-Datenschutz: keinerlei Telemetrie, kein Tracking, kein Netzwerkzugriff — deine
-Daten bleiben auf dem Gerät.
+Datenschutz: keinerlei Telemetrie, kein Tracking, kein Netzwerkzugriff —
+deine Daten bleiben auf dem Gerät.

fdroid-metadata/de.jeanlucmakiola.calendula/en-US/description.txt

@@ -1,11 +1,15 @@
-Calendula is a modern, open-source calendar app for Android. It reads from
-the system calendar provider, so any source synced to your device — Nextcloud
-via DAVx5, Google, local, WebCal subscriptions — shows up automatically.
+Calendula is a modern, open-source calendar app for Android. It works
+directly on the system calendar provider, so any source synced to your
+device — Nextcloud via DAVx5, Google, local, WebCal subscriptions — shows up
+automatically, and changes you make sync back the same way.
 
-The differentiator is the design: real Material 3 Expressive throughout, with
-dynamic color, expressive motion, and expressive shapes.
+Create, edit and delete events, including recurring events with scoped
+changes (only this event / this and all following / the whole series) and a
+simple repeat picker. Calendula also delivers your event reminders as
+notifications — tap one and you're on the event.
 
-V1 is read-only. Event creation, editing, and deletion are planned for V2.
+The differentiator is the design: real Material 3 Expressive throughout,
+with dynamic color, expressive motion, and expressive shapes.
 
 Privacy: zero telemetry, no analytics, no network access — your data never
 leaves the device.