Merge pull request 'release: v2.8.0' (!34) from release/v2.8.0 into main

Reviewed-on: #34

.gitea/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,23 @@
+---
+name: Bug report
+about: Something doesn't work the way it should
+title: ""
+labels:
+  - bug
+---
+
+### What happened
+
+
+### What you expected
+
+
+### Steps to reproduce
+1.
+2.
+3.
+
+### Environment
+- Calendula version: <!-- Settings → bottom of the screen -->
+- Android version:
+- Device:

.gitea/ISSUE_TEMPLATE/crash_report.md

@@ -0,0 +1,26 @@
+---
+name: Crash report
+about: Report a crash. Calendula can capture this for you (Settings → Report a problem, or the prompt after a crash) — it copies the report to your clipboard and prefills this form.
+title: "Crash: "
+labels:
+  - bug
+  - crash
+---
+
+<!--
+Thanks for reporting a crash in Calendula!
+
+If the app prefilled this for you, the crash report is already below — just add
+what you were doing and submit. Otherwise, paste the report from your clipboard
+into the code block. The report contains only app/Android/device versions and the
+stack trace — no personal data or calendar content.
+-->
+
+### What happened
+
+
+### Crash report
+
+```
+(paste the crash report here)
+```

.gitea/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,16 @@
+---
+name: Feature request
+about: Suggest an idea or improvement
+title: ""
+labels:
+  - enhancement
+---
+
+### What would you like Calendula to do?
+
+
+### Why — what problem does it solve?
+
+
+### Anything else
+<!-- mockups, examples from other apps, alternatives you considered -->

.gitea/workflows/ci.yaml

@@ -1,18 +1,23 @@
 name: CI
 
+# One gate per pull request. Branch pushes no longer trigger CI on their own,
+# so a change is built once on its PR (covering feature -> release/* and
+# release/* -> main) instead of once per push and again on the merge to main.
+# The merge itself is handled by release.yaml, which only does heavy work when
+# the merge actually cuts a release.
 on:
-  push:
+  pull_request:
-    branches:
-      - '**'
-    tags-ignore:
-      - '**'
 
-# Cancel superseded runs on the same branch.
+# Cancel superseded runs for the same PR.
 concurrency:
   group: ci-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:
+  # Single job named `ci` so the required "CI" status check is always reported,
+  # even for docs-only PRs: those just skip the Android build and the job still
+  # succeeds (fast green check) instead of being filtered out and leaving the
+  # required check pending forever.
   ci:
     runs-on: docker
     env:
@@ -21,14 +26,53 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          # Full history so the base..HEAD diff below has a merge-base.
+          fetch-depth: 0
+
+      # Cheap, always-on guard: the release build must stay reproducible for the
+      # official F-Droid repo (no AGP VCS-info embedding). Runs regardless of
+      # change scope so a regression can't slip through on a "docs-only" PR.
+      - name: Reproducible-release invariant
+        run: bash scripts/check_reproducible_release.sh
+
+      # Decide whether anything that affects the app build changed. Docs,
+      # F-Droid metadata and the licence don't, so those PRs skip the SDK +
+      # Gradle work below but still report a green `ci`.
+      - name: Classify change scope
+        id: scope
+        run: |
+          set -e
+          BASE="${{ github.base_ref }}"
+          # Full (not --depth=1) base fetch so the merge-base is present even when
+          # the PR branch forked several commits back; a shallow tip has no merge
+          # base with a divergent branch and `git diff base...HEAD` aborts.
+          git fetch --no-tags origin "$BASE"
+          MB=$(git merge-base "origin/$BASE" HEAD 2>/dev/null || true)
+          if [ -z "$MB" ]; then
+            # No common ancestor available — don't risk skipping the build.
+            echo "No merge base with origin/$BASE — running the full build to be safe."
+            echo "code=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          CHANGED=$(git diff --name-only "$MB" HEAD)
+          echo "Changed files:"; echo "$CHANGED"
+          if echo "$CHANGED" | grep -vE '(\.md$|^docs/|^fdroid-metadata/|^fastlane/|^LICENSE$)' | grep -q .; then
+            echo "code=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "code=false" >> "$GITHUB_OUTPUT"
+            echo "Docs/metadata-only change — skipping the Android build."
+          fi
 
       - name: Setup Java
+        if: steps.scope.outputs.code == 'true'
         uses: actions/setup-java@v4
         with:
           distribution: 'zulu'
           java-version: '17'
 
       - name: Setup Android SDK
+        if: steps.scope.outputs.code == 'true'
         uses: android-actions/setup-android@v3
         with:
           # Default ("tools platform-tools") drags in the Android Emulator
@@ -36,12 +80,14 @@ jobs:
           packages: ''
 
       - name: Setup Android SDK cache
+        if: steps.scope.outputs.code == 'true'
         uses: actions/cache@v4
         with:
           path: /opt/android-sdk
           key: ${{ runner.os }}-android-sdk-37-36.0.0
 
       - name: Install Android SDK packages
+        if: steps.scope.outputs.code == 'true'
         run: |
           yes | sdkmanager --licenses >/dev/null || true
           sdkmanager \
@@ -50,6 +96,7 @@ jobs:
             "build-tools;36.0.0"
 
       - name: Setup Gradle cache
+        if: steps.scope.outputs.code == 'true'
         uses: actions/cache@v4
         with:
           path: |
@@ -60,21 +107,25 @@ jobs:
             ${{ runner.os }}-gradle-
 
       - name: Grant execute permission for gradlew
+        if: steps.scope.outputs.code == 'true'
         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)
+        if: steps.scope.outputs.code == 'true'
         run: ./gradlew lintDebug
 
       - name: Unit tests
+        if: steps.scope.outputs.code == 'true'
         run: ./gradlew testDebugUnitTest
 
       - name: Assemble debug APK
+        if: steps.scope.outputs.code == 'true'
         run: ./gradlew assembleDebug
 
       - name: Trivy filesystem scan
-        if: github.ref == 'refs/heads/main'
+        if: steps.scope.outputs.code == 'true'
         run: |
           set -e
           SUDO=""

.gitea/workflows/release.yaml

@@ -1,75 +1,84 @@
 name: Release — F-Droid repo + Gitea release
 
+# A release is cut by merging a release branch into main with a bumped
+# versionName (see docs/RELEASING.md). This workflow reads that versionName and,
+# if no matching tag exists yet, runs tests, builds + signs the APK, publishes
+# it to the F-Droid repo, and only then creates the vX.Y.Z tag + Gitea release
+# itself — the tag is an output of the pipeline, not its trigger. Ordinary
+# merges (no version bump) fall through `detect` and do nothing.
+#
+# A manual workflow_dispatch (from a branch) runs the re-sign-only recovery
+# path: it re-signs the existing F-Droid index with the repo key and re-uploads,
+# without building an APK or creating a release. Used for key rotation / repo
+# recovery.
 on:
   push:
-    tags:
+    branches: [main]
-      - '*'
   workflow_dispatch:
 
+concurrency:
+  group: release
+  cancel-in-progress: false
+
 jobs:
-  ci:
+  # Cheap gate: resolve the version from the committed build.gradle and decide
+  # whether this push actually cuts a new release (no tag for it yet). Keeps the
+  # heavy job from running on every merge to main.
+  detect:
     runs-on: docker
-    env:
+    outputs:
-      ANDROID_HOME: /opt/android-sdk
+      is_release: ${{ steps.v.outputs.is_release }}
-      ANDROID_SDK_ROOT: /opt/android-sdk
+      version: ${{ steps.v.outputs.version }}
+      version_code: ${{ steps.v.outputs.version_code }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Setup Java
+      - name: Resolve version and whether it is a new release
-        uses: actions/setup-java@v4
+        id: v
-        with:
+        env:
-          distribution: 'zulu'
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          java-version: '17'
+          API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
-
-      - 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
+          set -e
-          sdkmanager \
+          VERSION=$(grep -oP 'versionName\s*=\s*"\K[^"]+' app/build.gradle.kts)
-            "platform-tools" \
+          if [ -z "$VERSION" ]; then echo "No versionName in app/build.gradle.kts" >&2; exit 1; fi
-            "platforms;android-37.0" \
+          MAJOR=$(echo "$VERSION" | cut -d. -f1); MINOR=$(echo "$VERSION" | cut -d. -f2); PATCH=$(echo "$VERSION" | cut -d. -f3)
-            "build-tools;36.0.0"
+          MAJOR=${MAJOR:-0}; MINOR=${MINOR:-0}; PATCH=${PATCH:-0}
+          VERSION_CODE=$(( MAJOR * 10000 + MINOR * 100 + PATCH ))
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "version_code=$VERSION_CODE" >> "$GITHUB_OUTPUT"
+          echo "Resolved version $VERSION (code $VERSION_CODE)"
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            echo "Manual dispatch — re-sign path, not a release."
+            echo "is_release=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          # A tag for this version already existing means the release shipped on
+          # an earlier push; do nothing. Absent => this merge cuts the release.
+          STATUS=$(curl -s -o /dev/null -w '%{http_code}' \
+            -H "Authorization: token $TOKEN" "$API/git/refs/tags/v$VERSION")
+          if [ "$STATUS" = "200" ]; then
+            echo "Tag v$VERSION already exists — nothing to release."
+            echo "is_release=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "No tag for v$VERSION yet — cutting the release."
+            echo "is_release=true" >> "$GITHUB_OUTPUT"
+          fi
 
-      - name: Setup Gradle cache
+  # Releases: build + sign + publish, then mint the tag and Gitea release.
-        uses: actions/cache@v4
+  # Also runs on manual dispatch, where it skips the build and just re-signs and
-        with:
+  # re-uploads the existing index (recovery path).
-          path: |
+  release:
-            ~/.gradle/caches
+    needs: detect
-            ~/.gradle/wrapper
+    if: needs.detect.outputs.is_release == 'true' || github.event_name == 'workflow_dispatch'
-          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
-
-      # Lint already enforced on every push to main via ci.yaml.
-      # Release sanity only re-runs tests + a debug build to catch
-      # any tag-resolved drift (e.g. version code substitution issues).
-
-      - name: Unit tests
-        run: ./gradlew testDebugUnitTest
-
-      - name: Assemble debug APK (sanity)
-        run: ./gradlew assembleDebug
-
-  build-and-deploy:
-    needs: ci
     runs-on: docker
     env:
       ANDROID_HOME: /opt/android-sdk
       ANDROID_SDK_ROOT: /opt/android-sdk
+      VERSION: ${{ needs.detect.outputs.version }}
+      VERSION_CODE: ${{ needs.detect.outputs.version_code }}
+      IS_RELEASE: ${{ needs.detect.outputs.is_release }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -121,31 +130,26 @@ jobs:
             $SUDO apk add --no-cache jq
           fi
 
-      # Tag-only build steps. On a manual workflow_dispatch (ref = a branch,
+      - name: Grant execute permission for gradlew
-      # not a tag) these are skipped: the job then just re-signs the existing
+        run: chmod +x ./gradlew
-      # index with the configured repo key and re-uploads — used for key
+
-      # rotation / repo recovery without publishing a new APK.
+      # The committed versionName is the source of truth. Pin versionCode to the
-      - name: Set version from git tag
+      # value derived from it so the published APK's code is always
-        if: startsWith(github.ref, 'refs/tags/')
+      # MAJOR*10000 + MINOR*100 + PATCH even if the committed code was forgotten.
+      - name: Pin versionCode to versionName
+        if: env.IS_RELEASE == 'true'
         run: |
           set -e
-          RAW_TAG="${GITHUB_REF_NAME:-${GITHUB_REF##*/}}"
-          VERSION="${RAW_TAG#v}"
-          MAJOR=$(echo "$VERSION" | cut -d. -f1)
-          MINOR=$(echo "$VERSION" | cut -d. -f2)
-          PATCH=$(echo "$VERSION" | cut -d. -f3)
-          MAJOR=${MAJOR:-0}; MINOR=${MINOR:-0}; PATCH=${PATCH:-0}
-          VERSION_CODE=$(( MAJOR * 10000 + MINOR * 100 + PATCH ))
-          echo "Version: $VERSION, VersionCode: $VERSION_CODE"
-          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"
+      # Test the exact commit being shipped (only on a real release).
-          echo "VERSION_CODE=$VERSION_CODE" >> "$GITHUB_ENV"
+      - name: Unit tests
+        if: env.IS_RELEASE == 'true'
+        run: ./gradlew testDebugUnitTest
 
       - name: Setup Android Keystore
-        if: startsWith(github.ref, 'refs/tags/')
+        if: env.IS_RELEASE == 'true'
         env:
           KEYSTORE_BASE64: ${{ secrets.KEYSTORE_BASE64 }}
           KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
@@ -160,11 +164,8 @@ jobs:
           storeFile=upload-keystore.jks
           EOF
 
-      - name: Grant execute permission for gradlew
-        run: chmod +x ./gradlew
-
       - name: Build release APK
-        if: startsWith(github.ref, 'refs/tags/')
+        if: env.IS_RELEASE == 'true'
         run: ./gradlew assembleRelease
 
       - name: Setup F-Droid Server Tools
@@ -202,8 +203,7 @@ jobs:
           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`
+          # user's pinned repo.
-          # 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
@@ -216,42 +216,33 @@ jobs:
           mkdir -p fdroid/repo/icons
 
       - name: Copy new APK to repo
-        if: startsWith(github.ref, 'refs/tags/')
+        if: env.IS_RELEASE == 'true'
         run: |
           set -e
           mkdir -p fdroid/repo
-          REF_NAME="${GITHUB_REF_NAME:-${GITHUB_REF##*/}}"
+          cp app/build/outputs/apk/release/app-release.apk "fdroid/repo/calendula_v${VERSION}.apk"
-          SAFE_REF_NAME="$(echo "$REF_NAME" | tr '/ ' '__' | tr -cd '[:alnum:]_.-')"
-          if [ -z "$SAFE_REF_NAME" ]; then
-            SAFE_REF_NAME="${GITHUB_SHA:-manual}"
-          fi
-          cp app/build/outputs/apk/release/app-release.apk "fdroid/repo/calendula_${SAFE_REF_NAME}.apk"
 
-      - name: Copy metadata to F-Droid repo
+      # Per-version "What's New": ensure this version's changelog exists in the
+      # fastlane tree (committed at release-cut time for the official repo; this
+      # regenerates it from CHANGELOG.md so the self-hosted repo never depends on
+      # the commit having happened). The transform below then carries it across.
+      - name: Ensure this version's changelog is in the fastlane tree
+        if: env.IS_RELEASE == 'true'
+        run: bash scripts/sync_changelog_to_fastlane.sh
+
+      - name: Build F-Droid metadata from fastlane (single source of truth)
         run: |
           mkdir -p fdroid/metadata
-          cp -r fdroid-metadata/* fdroid/metadata/
+          # App-level control file (Categories/License/links) for the self-hosted
-
+          # repo's `fdroid update`.
-      # Per-version "What's New" for F-Droid clients: the tag's CHANGELOG
+          cp fdroid-metadata/de.jeanlucmakiola.calendula.yml fdroid/metadata/
-      # section written to changelogs/<versionCode>.txt (same extraction as the
+          # Localized text + graphics + per-version changelogs come from the SAME
-      # Gitea release notes). en-US only — F-Droid falls back to it for locales
+          # fastlane tree the official F-Droid repo harvests from source,
-      # without their own changelog. fdroid update bakes this into the index.
+          # transformed into the F-Droid repo "localized" layout. One source of
-      - name: Generate F-Droid changelog for this version
+          # truth, both channels.
-        if: startsWith(github.ref, 'refs/tags/')
+          bash scripts/fastlane_to_fdroid_localized.sh \
-        run: |
+            fastlane/metadata/android \
-          set -e
+            fdroid/metadata/de.jeanlucmakiola.calendula
-          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: |
@@ -272,97 +263,46 @@ jobs:
           SFTP
           # 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
+          # releases. keystore.p12 and config.yml are NEVER uploaded.
-          # 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.
+      # The APK is published and the index re-signed — now record the release.
-      # Attached to the Gitea release (it's not an APK, so it fits the
+      # Creating it with target_commitish makes Gitea create the vX.Y.Z tag at
-      # no-binaries rule). Best-effort: never fail a release over it.
+      # this commit, so the tag only ever marks a fully-shipped release (and a
-      - name: Attach R8 mapping to Gitea release
+      # failure before here leaves no tag, so re-running the workflow retries).
-        if: startsWith(github.ref, 'refs/tags/')
+      - name: Create tag + Gitea release
-        continue-on-error: true
+        if: env.IS_RELEASE == 'true'
         env:
           TOKEN: ${{ secrets.GITHUB_TOKEN }}
           API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
+          SHA: ${{ github.sha }}
         run: |
           set -e
-          MAP="app/build/outputs/mapping/release/mapping.txt"
+          TAG="v$VERSION"
-          if [ ! -f "$MAP" ]; then echo "No mapping.txt (R8 off?) — skipping."; exit 0; fi
+          # Notes = this version's CHANGELOG section.
-          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 ---"
+          python3 - "$TAG" "$SHA" <<'PY' > payload.json
-          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],
+              "target_commitish": sys.argv[2],
               "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
+          # Upsert (re-run safe): PATCH if a release for the tag already exists,
-          # first (to attach the mapping asset), so PATCH the notes if it
+          # else POST a new one (which also creates the tag at target_commitish).
-          # 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)
+          ID=$(jq -r '.id // empty' existing.json 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" \
@@ -376,6 +316,33 @@ jobs:
           fi
           cat response.json
           if [ "$CODE" != "$OK" ]; then
-            echo "Release upsert failed with HTTP $CODE (expected $OK)"
+            echo "Release upsert failed with HTTP $CODE (expected $OK)" >&2
             exit 1
           fi
+          echo "Created/updated release $TAG at $SHA"
+
+      # Archive the R8 mapping so user crash stacktraces stay deobfuscatable.
+      # Attached to the 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: env.IS_RELEASE == 'true'
+        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="v$VERSION"
+          ASSET="mapping-${VERSION}.txt.gz"
+          gzip -c "$MAP" > "/tmp/$ASSET"
+          ID=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/tags/$TAG" | jq -r '.id // empty')
+          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"

.gitea/workflows/renovate.yml

@@ -0,0 +1,42 @@
+name: Renovate
+
+on:
+  # Weekly sweep. Mondays 05:00 UTC — this cron owns the cadence; the repo's
+  # renovate.json5 deliberately has no internal schedule (avoids double-gating).
+  schedule:
+    - cron: '0 5 * * 1'
+  # Manual run for an on-demand sweep from the Actions tab.
+  workflow_dispatch:
+
+# Never let two Renovate runs touch the repo at once.
+concurrency:
+  group: renovate
+  cancel-in-progress: false
+
+jobs:
+  renovate:
+    runs-on: docker
+    # Run the Renovate image *as* the job container and invoke the `renovate`
+    # binary directly. The renovatebot/github-action wrapper is a thin Node
+    # action that shells out to `docker run …` — it needs a Docker CLI + socket
+    # inside the job, which the Gitea runner's plain node container has not, so
+    # it died on "Unable to locate executable file: docker". Running the image
+    # directly drops the docker-in-docker requirement entirely.
+    # Full tag pinned; Renovate's github-actions manager keeps it bumped.
+    container:
+      image: ghcr.io/renovatebot/renovate:43.232.0
+    steps:
+      - name: Run Renovate
+        run: renovate
+        env:
+          # Self-hosted Gitea, not github.com.
+          RENOVATE_PLATFORM: gitea
+          RENOVATE_ENDPOINT: https://gitea.jeanlucmakiola.de/api/v1
+          # Bot-account token (Gitea secret). Needs repo read/write + PR scope.
+          RENOVATE_TOKEN: ${{ secrets.RENOVATE_TOKEN }}
+          # Scope to this repo only — no org-wide autodiscovery.
+          RENOVATE_AUTODISCOVER: 'false'
+          RENOVATE_REPOSITORIES: '["makiolaj/calendula"]'
+          # Commits/PRs authored as the bot, not a real maintainer.
+          RENOVATE_GIT_AUTHOR: 'Renovate Bot <renovate@jeanlucmakiola.de>'
+          LOG_LEVEL: info

.gitea/workflows/translations.yaml

@@ -0,0 +1,37 @@
+name: Translations
+
+# Fast, SDK-free parity check for translation resources, so Weblate PRs (which
+# only touch values-*/strings.xml) get quick feedback without the full Android
+# build. The deeper checks still run in CI via lintDebug (ExtraTranslation).
+on:
+  pull_request:
+    paths:
+      - 'app/src/main/res/values*/strings.xml'
+      - 'app/src/main/res/xml/locales_config.xml'
+      - 'scripts/check_translations.py'
+      - '.gitea/workflows/translations.yaml'
+
+concurrency:
+  group: translations-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    runs-on: docker
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Ensure python3
+        run: |
+          if ! command -v python3 >/dev/null 2>&1; then
+            if command -v apt-get >/dev/null 2>&1; then
+              apt-get update && apt-get install -y python3
+            elif command -v apk >/dev/null 2>&1; then
+              apk add --no-cache python3
+            fi
+          fi
+          python3 --version
+
+      - name: Check translation parity
+        run: python3 scripts/check_translations.py

.planning/ROADMAP.md

@@ -232,10 +232,38 @@ pass on the existing controls; new toggles ride in with their own features.
 7. ~~Home-screen widget — built on the agenda data source from #6~~ *(done, v2.5.0 — agenda + month widgets)*
 8. App shortcuts: ~~launcher long-press → New event~~ *(done, v2.5.0)*; optional quick-settings tile still open
 
-**Tier 4 — interop & bigger-ticket**
+**Tier 4 — reliability, data-safety & interop** *(re-ranked 2026-06-17)*
-9. Share event as .ics + receive/open .ics into a prefilled create form
+9. **Reminders — defaults + delivery reliability** *(shipped v2.6.0)* — global
-10. Default reminder applied to new events; then snooze/dismiss notification actions
+   default reminder **+ per-calendar override**, bundled with battery-exemption
-11. Drag & drop rescheduling in day/week — big-ticket, own slice (recurring drops reuse the scope dialog)
+   hardening. Full sketch in "Reminders — defaults & delivery reliability" below.
+10. **The `.ics` engine — export + import** *(shipped v2.7.0, 2026-06-18)* — one
+    hand-rolled serializer/parser (zero deps, stays on `kotlinx-datetime`),
+    four surfaces all shipped: single-event share + whole-calendar backup
+    (export), open-`.ics`→form + whole-calendar bulk import (import). Closed the
+    device-local-calendar data-loss gap (#10/#11 merged here). Built as two
+    sequential branches: `feat/ics-export` (write side + UID-on-create precursor)
+    then `feat/ics-import` (parser, restore, dedup by UID). Import is
+    liberal-in/strict-out: skip-and-report foreign `VTIMEZONE` / `RECURRENCE-ID`
+    / guest lists it can't model. Plans:
+    `docs/superpowers/plans/2026-06-18-05-ics-export.md` + `…-06-ics-import.md`.
+11. **Snooze / dismiss notification actions** *(merged into release/v2.8.0)* —
+    followed the `.ics` work; inherits v2.6's deferred exact-alarm/WorkManager
+    decision (snooze must re-fire an alarm).
+
+**Tier 5 — close the read/write gap on the event model** *(opened 2026-06-22)*
+12. **Attendee editing** *(next — promoted from the gated "Locations & People"
+    bucket, owner says high-importance 2026-06-22)* — attendees are already
+    *read* (queried, mapped, shown on the detail screen since v0.6) but the
+    event form can't *write* them, the last big read-only gap in the event
+    model. Add an attendees section to `EventEditScreen` / `EventForm`: add by
+    typed email (contact-picker entry can follow later), edit/remove rows, set
+    role (required / optional) — writing `CalendarContract.Attendees` rows on
+    insert + dirty-checked update, mirroring the reminders-diff pattern.
+    **Caveat to resolve first:** writing `Attendees` rows triggers sync-adapter
+    *invitation* behavior that differs by backend (Google auto-emails invites;
+    DAVx5/CalDAV writes the `ATTENDEE` property and lets the server decide) —
+    decide and document what Calendula promises before building. Full sketch in
+    "Attendee editing" under Locations & People below.
 
 **Gated — explicit go/no-go before any work (mostly INTERNET-permission calls)**
 - Remote calendar create/edit (re-implements DAVx5; INTERNET + credential storage)
@@ -247,10 +275,13 @@ pass on the existing controls; new toggles ride in with their own features.
   2026-06-17; cheap but low value, pick up only if asked
 
 **Unranked / fill-in** — pinch-to-zoom time scale, tablet/foldable layouts,
-full-text search, ICS file import. Pulled in opportunistically, not sequenced.
+full-text search. Pulled in opportunistically, not sequenced.
 
-Debatable calls worth a second look: widget (#7) vs .ics interop (#9) ordering;
+Tier 4 is now fully shipped (#9 reminders defaults v2.6.0, #10 `.ics`
-whether drag-drop (#11) jumps ahead given its daily-driver impact.
+export/import v2.7.0, #11 snooze/dismiss in release/v2.8.0; drag-drop rejected).
+**Next committed work is Tier 5 #12 — attendee editing** (the last read-only gap
+in the event model). After it: the theme-group ideas and Tier 2/3 leftovers
+(quick-settings tile, now-line, week numbers in month, full-text search).
 
 ## Navigation & views
 
@@ -260,14 +291,17 @@ whether drag-drop (#11) jumps ahead given its daily-driver impact.
 - 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)
+- Current-time "now" line in day/week — standard in every calendar, cheap,
+  currently absent. Daily-driver polish.
+- Week numbers in the **month** grid — week view already shows the badge
+  (`WeekNumberBadge`, `WeekScreen.kt`); extend to month for ISO/European users.
 - Pinch-to-zoom time scale in day/week
 - Tablet / foldable layouts *(was v3.0)*
-- Full-text search *(was v3.0)*
+- Full-text search *(was v3.0)* — promote out of "fill-in": for a daily driver
+  with real event history, finding an event is core completeness, not optional.
 
 ## 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
@@ -297,23 +331,124 @@ whether drag-drop (#11) jumps ahead given its daily-driver impact.
   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)*
+- ~~**Local-calendar backup / export** *(Tier 4 #10)*~~ **shipped v2.7.0** —
+  device-only (`ACCOUNT_TYPE_LOCAL`) calendars had no sync and therefore no
+  backup. Settings → Calendars → Export writes every event to a user-chosen
+  `.ics` file (SAF); restore is the bulk-import path (pick a calendar, dedup by
+  UID). Closed the silent data-loss gap.
 
-## Reminders, round two
+## Reminders — defaults & delivery reliability *(implemented 2026-06-17, `feat/default-reminders` — pending on-device review)*
+
+Two themes bundled because both are "make reminders trustworthy" — the core of
+the "Calendula is your only calendar app" promise.
+
+**Built in this slice (A + the safe half of B):** global timed default reminder
++ a **separate all-day default** (day-scale lead times) + per-calendar override
+(timed events), applied on create with manual-edit / calendar-switch / all-day-
+toggle handling; three pickers + per-calendar override list in Settings →
+Notifications; battery-optimisation exemption row (status + system deep-link, no
+extra permission). `resolveDefaultReminder` + prefs round-trips unit-tested.
+Resolution model: all-day events use the all-day global default outright;
+per-calendar overrides govern timed events only. Reviewed (8-angle), fixes
+applied: form-reset state race, label-fn consolidation with the detail screen,
+inline wrapper + single combined flow read.
+
+**Deliberately deferred (documented decisions, not oversights):**
+- *Absolute time-of-day for all-day reminders* — the all-day default is still
+  minutes-before-midnight (day-scale presets), not "9am the day before" (open
+  decision #2's richer half). Per-calendar all-day overrides also deferred.
+- *Self-scheduled alarms* — kept the existing provider-broadcast architecture
+  (open decision #1). The battery exemption is the reliability lever; no
+  `AlarmManager`/`USE_EXACT_ALARM` subsystem was added.
+- *Test-reminder diagnostic* and *battery prompt inside onboarding* — the
+  exemption lives only in Settings for now (onboarding flow untouched to keep
+  the change reviewable).
+
+### A. Default reminders (global + per-calendar override)
+
+**No provider backing.** `CalendarContract` has no column that auto-applies a
+default reminder per calendar — Google's per-calendar defaults live server-side.
+So both the global default *and* the per-calendar override are **app-side
+preferences**, applied by us at event-insert time. We inherit nothing from the
+synced calendar.
+
+- **Storage (DataStore):**
+  - `defaultReminderMinutes: Int?` — global default; `null` = "no reminder".
+  - `defaultAllDayReminderMinutes: Int?` — separate all-day default (all-day
+    reminders are expressed as minutes before midnight / day-before-at-time, not
+    minutes before a start instant — they need their own value).
+  - `perCalendarReminderOverride: Map<Long, Int?>` — keyed by calendar id;
+    **absent key = inherit global**, explicit `null` = "no reminder for this
+    calendar". (Same for an all-day override map if we want per-calendar all-day.)
+- **Apply on create:** a fresh event prefills its reminders list from
+  override-or-global for the preselected calendar. Changing the calendar in the
+  form re-applies the *new* calendar's default **only if the user hasn't manually
+  edited the reminders** — track a dirty flag, mirroring the per-event-color
+  reset pattern (v2.4).
+- **Edit semantics:** defaults apply to **new events only**; never rewrite
+  reminders on existing events on open or on calendar-switch-during-edit.
+- **Settings UI (Notifications sub-page):**
+  - Global default via OptionCard (None / at time of event / 5 / 10 / 15 / 30 min
+    / 1 h / 1 day / custom), plus the separate all-day default.
+  - Per-calendar overrides: a row per writable calendar (in the Calendars screen
+    or a Notifications subsection), each opening the same OptionCard with a
+    leading **"Use global default"** option.
+
+### B. Delivery reliability (exact alarms + battery)
+
+The provider broadcasts `EVENT_REMINDER`, but on modern Android (Doze / OEM
+battery managers) delivery can be silently delayed or dropped. v1.4 deferred this;
+it directly undermines the feature's premise, so it rides in here.
+
+- **Exact alarm — decision first:** trust the provider broadcast, or
+  self-schedule via `AlarmManager.setExactAndAllowWhileIdle` for reliability?
+  If we self-schedule, declare `USE_EXACT_ALARM` (API 33+, auto-granted for
+  calendar/alarm-category apps, F-Droid-clean) with a `SCHEDULE_EXACT_ALARM`
+  fallback for API 31–32 (user-revocable → settings deep-link prompt).
+- **Battery-optimization exemption:** a *soft, optional* prompt via
+  `ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS` (settings deep-link — never the
+  auto-grant intent), honest copy: "Android may delay reminders to save battery;
+  exempt Calendula for on-time delivery." Shown once after the existing
+  `POST_NOTIFICATIONS` onboarding step, reversible in Settings → Notifications.
+- **Diagnostics:** a "send a test reminder in 1 minute" button in Notifications
+  settings so users can verify delivery on their specific OEM (Samsung / Xiaomi
+  are notorious for suppressing it).
+
+### Open decisions (resolve before building)
+
+1. Self-schedule via `AlarmManager` vs trust the provider broadcast
+   (reliability vs simplicity + battery cost).
+2. All-day reminder representation (minutes-before vs absolute time-of-day).
+3. Where per-calendar overrides live in the UI (rows on the Calendars screen vs
+   a list inside the Notifications sub-page).
+
+### Later (round two)
 
 - Snooze + dismiss actions on the notification (snooze needs an
-  exact-alarm / WorkManager decision)
+  exact-alarm / WorkManager decision) — Tier 4 #13.
-- Settings default reminder applied to new events
 
 ## Sharing & interop
 
-- Share event as .ics + open/receive .ics into a prefilled create form
+- ~~Share event as .ics + open/receive .ics into a prefilled create form~~
-  (front-runs the import below)
+  **shipped v2.7.0** — single-event share from detail; opening an `.ics` with one
-- ICS file import (drag-and-drop) *(was v3.0, optional)*
+  event prefills the create form, many events opens a bulk import (dedup by UID)
+- ~~ICS file import~~ **shipped v2.7.0** — covered by the open/receive `.ics`
+  flow above (single → form, many → bulk import)
 
 ## Platform & launchers
 
-- Home-screen widget *(was v3.0)*
+- ~~Home-screen widget~~ **shipped v2.5.0** — agenda + month widgets
-- App shortcuts (launcher long-press → New event), maybe a quick-settings tile
+- ~~App shortcuts (launcher long-press → New event)~~ **shipped v2.5.0** —
+  optional quick-settings tile still open
+
+## Quality & reliability
+
+- **Accessibility pass** — TalkBack content descriptions across all screens,
+  dynamic-type / large-font reflow, touch-target audit. Quality bar for an
+  F-Droid app; nothing tracks it yet.
+- **Reminder delivery reliability** — exact alarms + battery-optimization
+  exemption; specced in the "Reminders — defaults & delivery reliability" slice
+  above (Tier 4 #9).
 
 ## Locations & People *(go/no-go, captured 2026-06-11)*
 
@@ -332,9 +467,57 @@ in detail yet:
   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
+- **Attendee editing** *(promoted out of this gated bucket 2026-06-22 — now
-  `Attendees` rows touches sync-adapter invitation behavior (Google vs
+  Tier 5 #12, high-importance; the no-permission typed-email path is not an
-  DAVx5 differ).
+  INTERNET/contacts call)*. See the "Attendee editing" sketch below.
+
+### Attendee editing *(Tier 5 #12, opened 2026-06-22)*
+
+The last read-only gap in the event model: attendees are read & shown on the
+detail screen (since v0.6) but the form can't write them. Make guests editable.
+
+- **Read side already done:** `Attendee` domain model + status/relationship/type
+  enums, `queryAttendees` + `EventDetailMapper.toAttendee` (with tests), and the
+  attendees `DetailCard` + `AttendeeRow` in `EventDetailScreen`. Nothing to add
+  there.
+- **Write side — SHIPPED (`feat/attendee-editing`, commit b0f34ff, 2026-06-22):**
+  `attendees` on `EventForm`; a Guests section in `EventEditScreen` rendered as an
+  inline grouped list — each guest a tonal card (avatar, name/email, tappable
+  Required/Optional role chip, remove), the trailing card an inline email field
+  (type → Done commits). Persisted by `reconcileAttendees` diffing the provider's
+  `CalendarContract.Attendees` rows on insert + dirty-checked update (new guests =
+  `RELATIONSHIP_ATTENDEE` / `STATUS_INVITED`; kept rows keep their status, only the
+  required/optional type updates; organizer/resource/no-email rows untouched).
+  Reminders restyled to the same grouped-list pattern in passing. Needs only the
+  existing `WRITE_CALENDAR` — no new permission.
+- **Name on manual add — SHIPPED via a contact picker** (2026-06-22). The inline
+  field is email-only (the quick path); the add row also has a **"from contacts"
+  button**: `ACTION_PICK` on `ContactsContract.CommonDataKinds.Email.CONTENT_URI` →
+  the system Contacts app returns a URI to the picked email row, queried for
+  `Email.ADDRESS` **and** the contact `DISPLAY_NAME`, so a picked guest gets both
+  email and name in one tap. The result Intent grants temporary read access, so
+  **no `READ_CONTACTS` permission** — one-shot and user-driven, same no-permission
+  mechanism as the location address picker above. Self/organizer rows stay
+  non-editable.
+- **Invitation behavior — DECIDED 2026-06-22: record-only, all writable
+  calendars.** Calendula has no INTERNET and never sends an invitation itself; it
+  only writes `Attendees` rows. Whether a guest is notified is decided downstream:
+  local calendars notify no one (no sync); CalDAV/DAVx5 PUTs the `ATTENDEE` lines
+  and the *server* decides iMIP delivery; Google's sync adapter pushes the change
+  and Google decides (third-party attendee writes are historically unreliable
+  there). Editing is allowed on **any writable calendar** — not gated to local.
+  - **Honest, backend-aware copy is mandatory** (this is the whole point of the
+    decision): on a synced calendar show "Calendula doesn't send invitations —
+    your calendar account may email guests when it syncs"; on a local calendar
+    show "Stored on this device. No one is notified."
+  - Calendula must **not fabricate an ORGANIZER** or otherwise fake scheduling
+    state to coax a send — it writes the guest list faithfully and leaves
+    scheduling entirely to the backend.
+  - The optional "send an .ics invite via your email app" delegate (`ACTION_SEND`,
+    still no INTERNET) was considered and **deferred** — revisit only if users ask
+    to notify guests explicitly.
+- **Out of scope (for now):** RSVP/your-own-response editing, free/busy lookups,
+  resource booking — all carry server round-trips or richer sync semantics.
 
 ## Consciously rejected
 
@@ -342,3 +525,5 @@ in detail yet:
 - 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)
+- Drag & drop rescheduling in day/week — **rejected** (owner decision,
+  reaffirmed 2026-06-22): not wanted. Rescheduling stays via the edit form.

.planning/STATE.md

@@ -1,17 +1,27 @@
 # Calendula — Current State
 
-*Last updated: 2026-06-17*
+*Last updated: 2026-06-22*
 
 ## Status
 
-**Milestone:** 2 (write support) **complete** — v2.0.0 shipped 2026-06-11;
+**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.x theme-based backlog work (organised in `ROADMAP.md`).
-**Phase:** post-2.1 backlog work. v2.2.0 (tap-to-create in day/week + local
+**Latest released tag: v2.7.5.** The whole Tier 4 (reliability/data-safety/
-calendar management) and v2.3.0 (Material 3 grouped-list redesign of Settings,
+interop) arc is now done or in flight:
-the calendar manager and the navigation drawer) both shipped 2026-06-16;
+- v2.4.0 per-event colors (2026-06-17)
-v2.4.0 (per-event colors) and v2.5.0 (jump-to-date, Agenda view, home-screen
+- v2.5.0 jump-to-date, Agenda view, agenda + month home-screen widgets, "New
-agenda + month widgets, and a "New event" launcher shortcut) shipped
+  event" launcher shortcut (2026-06-17)
-2026-06-17. The backlog is now organised by theme in `ROADMAP.md`.
+- v2.6.0 default reminders (global + per-calendar override, all-day default,
+  battery-exemption row) + system per-app language (2026-06-18)
+- v2.7.0 **`.ics` engine** — single-event share, local-calendar backup export,
+  open/receive `.ics` (single → form, many → bulk import, dedup by UID)
+  (2026-06-18)
+- v2.7.1–v2.7.5 — crash-reporting + F-Droid reproducible-build hardening + fixes
+
+**Next release `release/v2.8.0` (integration branch, not yet cut to main):**
+holds crash reports via the public Codeberg tracker (MR !27) + reminder
+snooze/dismiss notification actions (MR !28). Version bump to 2.8.0 happens at
+release-cut.
 
 ## Progress
 
@@ -120,11 +130,48 @@ agenda + month widgets, and a "New event" launcher shortcut) shipped
   sync" warning on the picker and in Settings. Color writes flow through
   insert / dirty-checked update / occurrence-exception; mapper + form tests.
 
+- [x] v2.5 (shipped 2026-06-17) — Agenda view (4th top-level view),
+  jump-to-date drawer date picker, two home-screen widgets (scrolling
+  "Upcoming" agenda + month grid), and a "New event" launcher long-press
+  shortcut
+
+- [x] v2.6 (shipped 2026-06-18) — default reminders: global timed default +
+  separate all-day default + per-calendar override (timed), applied on create
+  with dirty-flag handling; three pickers + override list in Settings →
+  Notifications; battery-optimisation exemption row (status + system deep-link,
+  no new permission). Plus system per-app language (Android 13+) and an
+  immediate-effect fix for the in-app language picker
+
+- [x] v2.7 (shipped 2026-06-18) — the `.ics` engine: share a single event as
+  `.ics` from the detail screen; back up local calendars (Settings → Calendars
+  → Export) to a SAF file; open/receive an `.ics` — one event prefills the
+  create form, many events open a bulk import into a chosen calendar (dedup by
+  UID, skip-and-report unrepresentable VTIMEZONE / RECURRENCE-ID / guests).
+  Hand-rolled serializer/parser, zero deps. Plus all-day single-day UTC fix and
+  a widget R8 keep-rule crash fix
+
+- [x] v2.7.1–v2.7.5 (2026-06-21) — launch crash fix (listener before grant),
+  user-controlled crash reporting, widget loading-spinner R8 keep rule, and
+  F-Droid reproducible-build cleanups for the official repo
+
+- [~] release/v2.8.0 (not yet cut) — crash reports via the public Codeberg
+  tracker (MR !27) + reminder snooze/dismiss notification actions (MR !28,
+  snooze self-schedules an exact alarm; primary delivery stays provider-broadcast)
+
 ## Next
 
-1. Monitor the F-Droid build/publish for the v2.4.0 tag
+1. Cut **v2.8.0** from `release/v2.8.0` (bump versionName → tag via the
-2. Decide the "Locations & People" and "remote calendar create/edit"
+   merge-driven pipeline) once on-device review signs off
-   go/no-go calls (both hinge on the INTERNET permission) — see `ROADMAP.md`
+2. **Attendee editing** — the committed next feature (Tier 5 #12, high-
-3. **Duplicate event** and **jump-to-date** are the cheap follow-ups; then
+   importance, opened 2026-06-22). Attendees are already read & shown on the
-   agenda view (strategic, backs a future widget). Full ranked sequence in
+   detail screen since v0.6; the gap is the write side — make guests editable
-   `ROADMAP.md` → "Near-term sequence".
+   in `EventEditScreen` / `EventForm` (add by typed email, role, remove),
+   persisted by diffing `CalendarContract.Attendees`. No new permission for the
+   typed-email path. **Invitation behavior DECIDED 2026-06-22: record-only on all
+   writable calendars** — Calendula never sends (no INTERNET); honest backend-aware
+   copy ("your account may email guests when it syncs" on synced calendars, "no one
+   is notified" on local). Full sketch in `ROADMAP.md` → "Attendee editing".
+3. Then: the two INTERNET go/no-go calls (OSM autocomplete, remote calendar
+   create/edit) and Tier 2/3 leftovers (quick-settings tile, now-line, week
+   numbers in month, full-text search, accessibility pass). Drag-and-drop
+   rescheduling is **rejected**.

CHANGELOG.md

@@ -5,7 +5,127 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [2.8.0] — 2026-06-23
+
+### Added
+- Find events fast. A search button in the top bar of every calendar view opens
+  a search box — type a couple of letters and matching events (by title,
+  location or description) appear, soonest first with past events below. Tap a
+  result to open it. Search covers your whole calendar, not just what's on
+  screen, and skips calendars you've hidden. A recurring event shows its next
+  occurrence rather than the date the series first started.
+- A current-time line in the day and week views. A thin coloured line marks the
+  present moment across today's column, so you can see at a glance where you are
+  in the day. It updates every minute and only appears when today is in view.
+- Add and remove event guests. The create/edit form now has a Guests section:
+  add people by email or pick them from your contacts, mark each as required or
+  optional, and remove them. Calendula never sends invitations itself (it has no
+  internet access) — it only records the guests; if the event lives on a synced
+  account, that account may email them when it syncs, and on a local calendar no
+  one is notified. The form tells you which applies. Picking a guest from
+  contacts needs no contacts permission.
+- Pick a location from your contacts. A contacts button beside the location
+  field drops a contact's address straight into an event — handy for a meeting
+  at someone's home or office. Like the guest picker, it needs no contacts
+  permission.
+- A "New event" Quick Settings tile. Add it to your quick settings to jump
+  straight into the new-event form from anywhere. Settings → New event has a
+  one-tap button to add the tile (Android 13+); on older versions you can add it
+  from the quick-settings editor.
+- Snooze and dismiss buttons on reminder notifications. Dismiss clears the
+  reminder; snooze hides it and brings it back after a delay you pick in
+  Settings → Notifications (5 to 60 minutes, default 10). Android's calendar
+  system won't re-post a reminder on its own, so Calendula schedules an exact
+  alarm to bring a snoozed one back on time.
+
+### Changed
+- Event details now show each guest's email beneath their name, instead of only
+  when no name is available.
+- Crash and problem reports now open on the project's public Codeberg tracker,
+  where anyone can register and file an issue. Nothing is sent automatically —
+  you still review the report and submit it yourself in the browser.
+
+## [2.7.5] — 2026-06-21
+
+### Changed
+- Further build cleanup for the official F-Droid repository: stopped embedding
+  AGP's dependency-metadata block in the APK, which F-Droid's reproducible-build
+  scanner rejects as an extra signing block. No functional or visible changes —
+  the same app as 2.7.4, just without that Play-oriented metadata blob.
+
+## [2.7.4] — 2026-06-21
+
+### Changed
+- Build cleanup that lets Calendula ship in the official F-Droid repository:
+  removed an unused Gradle toolchain-resolver plugin, which F-Droid's offline,
+  reproducible build process disallows. No functional or visible changes — this
+  is the same app as 2.7.3.
+
+## [2.7.3] — 2026-06-21
+
+### Fixed
+- Home-screen widgets no longer get stuck on a loading spinner in the published
+  (F-Droid) release build. They render via Android's background-work system, and
+  release optimisation (R8) was stripping a helper class it loads by name, so the
+  render job never ran. Added the missing keep rule — widgets now load normally.
+
+## [2.7.2] — 2026-06-21
+
+### Added
+- Crash reporting you control. If Calendula closes unexpectedly, it now captures
+  a technical report and, on the next launch, offers to send it as an issue on
+  the project's tracker. Nothing is uploaded automatically — the report stays on
+  your device until you choose to share it, it contains no personal data or
+  calendar content (only the app, Android and device versions plus the stack
+  trace), and you see the full text before sending. There's also a "Report a
+  problem" entry in Settings, and if the app ever fails to start repeatedly, a
+  minimal recovery screen still lets you send the report.
+
+## [2.7.1] — 2026-06-21
+
+### Fixed
+- Fixed the app crashing immediately on launch whenever calendar access hadn't
+  been granted yet (a fresh install, or after revoking the permission). The app
+  set up its live calendar-change listener before the permission screen could
+  appear, which newer Android versions reject outright — so the app died before
+  you could grant access. The listener now waits for the permission and attaches
+  itself the moment it's granted.
+
+## [2.7.0] — 2026-06-18
+
+### Added
+- Share a single event as an `.ics` file from the event detail screen — hands a
+  standard calendar file to any app via the system share sheet.
+- Back up your local (device-only) calendars: Settings → Calendars → Export as
+  `.ics` file writes every event of your on-device calendars to a file you
+  choose. Local calendars aren't synced anywhere, so this is their only backup.
+- Open or share an `.ics` file into Calendula: a single event opens the create
+  form prefilled for review, while a file with many events (e.g. a backup) opens
+  a bulk import — pick a calendar and import them all. Re-importing a backup
+  won't create duplicates (events are matched by their unique identifier), and
+  anything Calendula can't represent (changed recurring occurrences, guest
+  lists) is reported rather than silently dropped.
+
+### Fixed
+- All-day events that cover a single day (e.g. a birthday) no longer show up on
+  the following day as well — in the day, week and month views or on the event
+  detail screen. The extra day came from interpreting the all-day date range in
+  the device's time zone instead of UTC.
+- Fixed the app crashing immediately on every launch in the optimized release
+  build: release code-shrinking (R8) was stripping a database class the
+  home-screen widget framework needs, so the app died at startup before showing
+  anything. Added the missing keep rule.
+
+## [2.6.0] — 2026-06-18
+
+### Added
+- App language can now be set from Android's system per-app language settings
+  (Android 13+), in addition to the in-app picker in Settings — and the app is
+  set up so further languages can be added by community translators
+
+### Fixed
+- Changing the app language in Settings now takes effect immediately; the
+  picker previously had no effect
 
 ## [2.5.0] — 2026-06-17
 

README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-<img src="fdroid-metadata/de.jeanlucmakiola.calendula/en-US/icon.png" width="112" alt="Calendula icon">
+<img src="fastlane/metadata/android/en-US/images/icon.png" width="112" alt="Calendula icon">
 
 <h1>Calendula</h1>
 
@@ -16,11 +16,11 @@ Reads, writes, and reminds — on top of the system calendar, with zero network
 </p>
 
 <p>
-<img src="fdroid-metadata/de.jeanlucmakiola.calendula/en-US/phoneScreenshots/01-week.png" width="19%" alt="Week view">&nbsp;
+<img src="fastlane/metadata/android/en-US/images/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="fastlane/metadata/android/en-US/images/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="fastlane/metadata/android/en-US/images/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="fastlane/metadata/android/en-US/images/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">
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/06-onboarding.png" width="19%" alt="Reminder onboarding">
 </p>
 
 </div>

app/build.gradle.kts

@@ -23,13 +23,13 @@ android {
         applicationId = "de.jeanlucmakiola.calendula"
         minSdk = 29
         targetSdk = 36
-        // The git tag is the single source of truth for released builds: at
+        // These committed values ARE the source of truth for a release: merging
-        // release time .gitea/workflows/release.yaml derives both fields from
+        // a bumped versionName into main triggers .gitea/workflows/release.yaml,
-        // the tag, with versionCode = MAJOR*10000 + MINOR*100 + PATCH
+        // which builds this version and then creates the matching vX.Y.Z tag +
-        // (e.g. v2.0.0 -> 20000). These committed values are the dev/local
+        // release itself (versionCode is pinned to MAJOR*10000 + MINOR*100 +
-        // default; keep them matching the latest released tag. See docs/RELEASING.md.
+        // PATCH from versionName, e.g. 2.7.2 -> 20702). See docs/RELEASING.md.
-        versionCode = 20500
+        versionCode = 20800
-        versionName = "2.5.0"
+        versionName = "2.8.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -47,6 +47,11 @@ android {
 
     buildTypes {
         release {
+            // Keep release builds reproducible for F-Droid: don't let AGP embed
+            // build-environment git metadata (META-INF/version-control-info.textproto),
+            // whose `revision`/path content varies by build machine and is the only
+            // thing that otherwise differs from a clean from-source rebuild.
+            vcsInfo { include = false }
             isMinifyEnabled = true
             isShrinkResources = true
             proguardFiles(
@@ -61,6 +66,21 @@ android {
             applicationIdSuffix = ".debug"
             isMinifyEnabled = false
         }
+        // A locally-installable twin of `release`: same R8 shrinking + obfuscation
+        // and resource shrinking, but debug-signed and given its own applicationId
+        // suffix so it installs alongside both the production app (signed with the
+        // real key) and the debug build. Used to smoke-test a release candidate on
+        // a real device before tagging — R8-only breakage and first-run/permission
+        // states don't surface in the unminified debug build, nor on a device that
+        // already holds the permission. Never published. See docs/RELEASING.md.
+        create("releaseTest") {
+            initWith(getByName("release"))
+            applicationIdSuffix = ".releasetest"
+            signingConfig = signingConfigs.getByName("debug")
+            isMinifyEnabled = true
+            isShrinkResources = true
+            matchingFallbacks += "release"
+        }
     }
 
     compileOptions {
@@ -72,12 +92,31 @@ android {
         compose = true
     }
 
+    // Don't embed AGP's dependency-metadata block in the APK signing block. It's
+    // a Play-oriented blob, and F-Droid's reproducible-build scanner rejects any
+    // "extra signing block" — so leaving it in blocks publishing to the official
+    // repo. It lives in the signing block, not the zip entries, so disabling it
+    // doesn't change the build output (reproducibility is unaffected).
+    dependenciesInfo {
+        includeInApk = false
+        includeInBundle = false
+    }
+
     packaging {
         resources {
             excludes += "/META-INF/{AL2.0,LGPL2.1}"
         }
     }
 
+    lint {
+        // Community translations are expected to be partial — a missing string
+        // falls back to the English base at runtime — so don't fail the build on
+        // it. Stale/extra keys (ExtraTranslation) stay fatal; scripts/
+        // check_translations.py guards the same invariants with clearer,
+        // translator-facing messages.
+        informational += "MissingTranslation"
+    }
+
     testOptions {
         unitTests {
             all { it.useJUnitPlatform() }

app/proguard-rules.pro

@@ -4,3 +4,25 @@
 
 # Compose Compiler may keep its own; defaults are fine
 -dontwarn org.jetbrains.annotations.**
+
+# Room database implementations (pulled in transitively via
+# androidx.glance:glance-appwidget → androidx.work → androidx.room).
+# The widgets rely on Glance, whose WorkManager backend stores state in a Room
+# database. Under R8 full mode (AGP 9 default) the generated *_Impl subclasses
+# of RoomDatabase lose their usable no-arg constructor / are marked abstract,
+# so Room's reflective instantiation throws InstantiationException and the app
+# crashes at startup with "Failed to create an instance of ...WorkDatabase".
+# Keep the generated Room database implementations fully intact.
+-keep class * extends androidx.room.RoomDatabase { *; }
+-dontwarn androidx.room.paging.**
+
+# WorkManager instantiates an InputMerger reflectively (Class.newInstance) from
+# the fully-qualified class name persisted in the WorkSpec, so the class must
+# keep both its name and a no-arg constructor. Glance renders every widget
+# through a WorkManager worker (androidx.glance.session.SessionWorker) whose
+# default merger is androidx.work.OverwritingInputMerger. Under R8 full mode
+# (AGP 9 default) that unused no-arg constructor was stripped, so WorkManager
+# threw "OverwritingInputMerger has no zero argument constructor", the
+# SessionWorker never ran, and widgets were stuck on their loading layout
+# (a blank spinner) in release builds. Keep every InputMerger's name + ctor.
+-keep class * extends androidx.work.InputMerger { <init>(...); }

app/src/main/AndroidManifest.xml

@@ -5,6 +5,24 @@
     <uses-permission android:name="android.permission.READ_CALENDAR" />
     <uses-permission android:name="android.permission.WRITE_CALENDAR" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <!--
+      Lets the "Reliable delivery" setting open the direct system dialog to
+      exempt Calendula from battery optimisation (so reminder broadcasts aren't
+      delayed by Doze). Used only to launch that dialog; falls back to the
+      battery-optimisation list if the OS declines the direct intent.
+    -->
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
+
+    <!--
+      Re-fire a snoozed reminder at an exact time (the calendar provider won't —
+      its alert is already fired). USE_EXACT_ALARM is auto-granted to calendar
+      apps on API 33+; SCHEDULE_EXACT_ALARM covers API 31–32 (user-revocable,
+      with an inexact fallback if withheld). F-Droid-clean: no Play allowlisting.
+    -->
+    <uses-permission
+        android:name="android.permission.SCHEDULE_EXACT_ALARM"
+        android:maxSdkVersion="32" />
+    <uses-permission android:name="android.permission.USE_EXACT_ALARM" />
 
     <!-- Package visibility (Android 11+): without this, getLaunchIntentForPackage
          returns null and the calendar manager's per-account "manage" button can't
@@ -25,6 +43,7 @@
         android:fullBackupContent="@xml/backup_rules"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
+        android:localeConfig="@xml/locales_config"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.Calendula"
@@ -39,12 +58,50 @@
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
 
+            <!-- Open a .ics file (file manager / email attachment / browser). -->
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="content" android:mimeType="text/calendar" />
+                <data android:scheme="file" android:mimeType="text/calendar" />
+            </intent-filter>
+            <!-- Receive a .ics shared from another app. -->
+            <intent-filter>
+                <action android:name="android.intent.action.SEND" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="text/calendar" />
+            </intent-filter>
+
             <!-- Launcher long-press shortcuts (e.g. "New event"). -->
             <meta-data
                 android:name="android.app.shortcuts"
                 android:resource="@xml/shortcuts" />
         </activity>
 
+        <!-- Standalone surface for a captured crash report. MainActivity routes
+             here on a startup crash-loop, so it stays clear of the app's Hilt
+             graph and Compose content. Not exported: launched only by us. -->
+        <activity
+            android:name=".ui.crash.CrashReportActivity"
+            android:exported="false"
+            android:excludeFromRecents="true"
+            android:launchMode="singleTask" />
+
+        <!-- Quick Settings tile: a one-tap "New event" shortcut in the QS panel.
+             Exported with BIND_QUICK_SETTINGS_TILE so only the system QS host can
+             bind it; the action mirrors the launcher "New event" shortcut. -->
+        <service
+            android:name=".qs.NewEventTileService"
+            android:exported="true"
+            android:icon="@drawable/ic_qs_new_event"
+            android:label="@string/qs_tile_new_event_label"
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+            <intent-filter>
+                <action android:name="android.service.quicksettings.action.QS_TILE" />
+            </intent-filter>
+        </service>
+
         <!-- 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. -->
@@ -59,6 +116,13 @@
             </intent-filter>
         </receiver>
 
+        <!-- Snooze / dismiss actions on a reminder notification, plus the snooze
+             re-show alarm. Not exported: only our own notification buttons and
+             AlarmManager PendingIntents target it. -->
+        <receiver
+            android:name=".data.reminders.ReminderActionReceiver"
+            android:exported="false" />
+
         <!-- Home-screen widgets (Glance). Exported: the launcher/host binds them. -->
         <receiver
             android:name=".widget.agenda.AgendaWidgetReceiver"
@@ -104,6 +168,19 @@
             </intent-filter>
         </receiver>
 
+        <!-- Hands .ics files we stage in the cache to other apps via a content
+             Uri (single-event share). Authority tracks applicationId so the
+             debug suffix doesn't break getUriForFile. -->
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
+
         <!-- 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/CalendulaApp.kt

@@ -2,10 +2,19 @@ package de.jeanlucmakiola.calendula
 
 import android.app.Application
 import dagger.hilt.android.HiltAndroidApp
+import de.jeanlucmakiola.calendula.data.crash.CrashReporter
 
 /**
  * Application entry point. Registered as android:name=".CalendulaApp"
  * in AndroidManifest.xml. Hilt initializes its component graph here.
  */
 @HiltAndroidApp
-class CalendulaApp : Application()
+class CalendulaApp : Application() {
+
+    override fun onCreate() {
+        super.onCreate()
+        // Install first thing so startup crashes are captured too (privacy-
+        // respecting, on-device; the user submits the report by hand).
+        CrashReporter.install(this)
+    }
+}

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

@@ -2,29 +2,35 @@ package de.jeanlucmakiola.calendula
 
 import android.content.Context
 import android.content.Intent
+import android.net.Uri
 import android.os.Bundle
-import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.appcompat.app.AppCompatActivity
 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.content.IntentCompat
 import androidx.core.net.toUri
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import dagger.hilt.android.AndroidEntryPoint
+import de.jeanlucmakiola.calendula.data.crash.CrashReporter
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.ui.RootScreen
 import de.jeanlucmakiola.calendula.ui.WidgetNavRequest
+import de.jeanlucmakiola.calendula.ui.crash.CrashReportActivity
+import de.jeanlucmakiola.calendula.ui.crash.CrashReportDialog
+import de.jeanlucmakiola.calendula.ui.crash.submitCrashReport
 import de.jeanlucmakiola.calendula.ui.settings.SettingsViewModel
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaTheme
 import kotlinx.datetime.LocalDate
 
 @AndroidEntryPoint
-class MainActivity : ComponentActivity() {
+class MainActivity : AppCompatActivity() {
 
     // The occurrence a reminder notification was tapped for (eventId, begin,
     // end — the detail screen's key shape). singleTop + onNewIntent route a
@@ -35,11 +41,35 @@ class MainActivity : ComponentActivity() {
     // create). Consumed once by CalendarHost, same pattern as the detail key.
     private var requestedNav by mutableStateOf<WidgetNavRequest?>(null)
 
+    // An .ics file opened/shared into the app (ACTION_VIEW/SEND). Consumed once
+    // by CalendarHost's import flow.
+    private var requestedImportUri by mutableStateOf<Uri?>(null)
+
+    // A captured crash report awaiting the user's decision, surfaced as a dialog
+    // over the calendar on the next launch (the single-crash path). A startup
+    // crash-loop is handled out of band, before setContent — see below.
+    private var pendingCrashReport by mutableStateOf<String?>(null)
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+
+        // If the app keeps crashing as it starts, the main UI can't be trusted
+        // to come up — route to the standalone report screen instead of
+        // re-entering the crashing graph.
+        if (CrashReporter.isCrashLoop(this)) {
+            startActivity(
+                Intent(this, CrashReportActivity::class.java)
+                    .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK),
+            )
+            finish()
+            return
+        }
+
         enableEdgeToEdge()
         requestedDetailKey = intent.detailKeyOrNull()
         requestedNav = intent.navRequestOrNull()
+        requestedImportUri = intent.importUriOrNull()
+        if (CrashReporter.shouldPrompt(this)) pendingCrashReport = CrashReporter.pendingReport(this)
         setContent {
             // One activity-scoped SettingsViewModel drives both the theme here
             // and the Settings screen, so a theme change applies app-wide at once.
@@ -60,15 +90,54 @@ class MainActivity : ComponentActivity() {
                     onDetailKeyConsumed = { requestedDetailKey = null },
                     widgetNavRequest = requestedNav,
                     onWidgetNavConsumed = { requestedNav = null },
+                    requestedImportUri = requestedImportUri,
+                    onImportConsumed = { requestedImportUri = null },
+                )
+                pendingCrashReport?.let { report ->
+                    CrashReportDialog(
+                        report = report,
+                        onSend = {
+                            submitCrashReport(this@MainActivity, report)
+                            CrashReporter.clearReport(this@MainActivity)
+                            pendingCrashReport = null
+                        },
+                        onDismiss = {
+                            // Keep the report (Settings can still reach it); just
+                            // stop it popping on every launch.
+                            CrashReporter.dismissPrompt(this@MainActivity)
+                            pendingCrashReport = null
+                        },
                     )
                 }
             }
         }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        // Reaching a running UI means startup succeeded; reset the loop trail.
+        CrashReporter.markHealthy(this)
+    }
 
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         intent.detailKeyOrNull()?.let { requestedDetailKey = it }
         intent.navRequestOrNull()?.let { requestedNav = it }
+        intent.importUriOrNull()?.let { requestedImportUri = it }
+    }
+
+    /**
+     * The `.ics` Uri an external app asked us to open (file manager `ACTION_VIEW`)
+     * or share into us (`ACTION_SEND`). Restricted to content/file schemes so the
+     * app's own `calendula://` deep-links never match.
+     */
+    private fun Intent.importUriOrNull(): Uri? {
+        val uri = when (action) {
+            Intent.ACTION_VIEW -> data
+            Intent.ACTION_SEND -> IntentCompat.getParcelableExtra(this, Intent.EXTRA_STREAM, Uri::class.java)
+            else -> null
+        } ?: return null
+        return uri.takeIf { it.scheme == "content" || it.scheme == "file" }
     }
 
     private fun Intent.navRequestOrNull(): WidgetNavRequest? = when {

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

@@ -0,0 +1,70 @@
+package de.jeanlucmakiola.calendula.data.calendar
+
+import java.time.Instant
+import java.time.LocalDate
+import java.time.LocalTime
+import java.time.ZoneId
+import java.time.ZoneOffset
+import java.time.temporal.ChronoUnit
+
+/**
+ * Translates an all-day reminder between the **semantic** lead time the UI
+ * speaks (whole days before the event — "1 day before") and the **raw**
+ * `CalendarContract.Reminders.MINUTES` offset the provider stores.
+ *
+ * Calendula schedules no alarms itself: the provider fires a reminder at
+ * `DTSTART − MINUTES` (the Etar model). An all-day event's DTSTART is **UTC
+ * midnight** (see [EventWriteTimes]), so a raw `MINUTES = 1440` ("1 day") lands
+ * on UTC-midnight of the previous day — 02:00 local in CEST, not the morning.
+ *
+ * To fire at a chosen wall-clock time we encode that time *into* the offset:
+ * `MINUTES = UTC-midnight(startDate) − (localInstant of [timeOfDayMinutes] on the
+ * day [semanticMinutes] before)`. The single fixed offset can only be tuned for
+ * the event's own date, so a recurring all-day series or a post-creation
+ * timezone change drifts the fire time by the offset delta (±1h across DST) —
+ * an inherent limit of the provider model, shared by Etar.
+ */
+private const val MINUTES_PER_DAY = 1_440
+private const val MILLIS_PER_MINUTE = 60_000L
+
+/**
+ * Raw provider `MINUTES` for an all-day reminder set [semanticMinutes] before the
+ * event (a whole-day multiple; sub-day remainders are dropped), so it fires at
+ * [timeOfDayMinutes] (minutes from local midnight) in [zone]. The result may be
+ * **negative** — e.g. "at time of event" at 09:00 CEST encodes to −420, meaning
+ * the provider fires *after* DTSTART; this is valid and must not be clamped.
+ * A negative [semanticMinutes] is the "provider default" sentinel and passes
+ * through unchanged.
+ */
+internal fun toProviderAllDayMinutes(
+    semanticMinutes: Int,
+    startDate: LocalDate,
+    zone: ZoneId,
+    timeOfDayMinutes: Int,
+): Int {
+    if (semanticMinutes < 0) return semanticMinutes
+    val utcMidnight = startDate.atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
+    val fire = startDate.minusDays((semanticMinutes / MINUTES_PER_DAY).toLong())
+        .atTime(LocalTime.of(timeOfDayMinutes / 60, timeOfDayMinutes % 60))
+        .atZone(zone).toInstant().toEpochMilli()
+    return ((utcMidnight - fire) / MILLIS_PER_MINUTE).toInt()
+}
+
+/**
+ * Recover the semantic whole-day lead time from a raw all-day reminder
+ * [rawMinutes]. Keys off the **local date** of the encoded fire instant, so it
+ * returns the right day count regardless of which [timeOfDayMinutes] wrote the
+ * row — including pre-feature rows (raw multiples of 1440, fired at UTC midnight)
+ * and rows written under a different timezone. A negative [rawMinutes] (fire
+ * after DTSTART) folds to day 0.
+ */
+internal fun fromProviderAllDayMinutes(
+    rawMinutes: Int,
+    startDate: LocalDate,
+    zone: ZoneId,
+): Int {
+    val utcMidnight = startDate.atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
+    val fireLocalDate = Instant.ofEpochMilli(utcMidnight - rawMinutes * MILLIS_PER_MINUTE)
+        .atZone(zone).toLocalDate()
+    return ChronoUnit.DAYS.between(fireLocalDate, startDate).toInt() * MINUTES_PER_DAY
+}

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

@@ -1,9 +1,11 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
+import android.Manifest
 import android.content.ContentResolver
 import android.content.ContentUris
 import android.content.ContentValues
 import android.content.Context
+import android.content.pm.PackageManager
 import android.database.ContentObserver
 import android.database.Cursor
 import android.net.Uri
@@ -11,17 +13,24 @@ import android.os.Handler
 import android.os.Looper
 import android.provider.CalendarContract
 import android.util.Log
+import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.domain.Attendee
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventAttendee
 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.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
+import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import de.jeanlucmakiola.calendula.domain.rruleTruncatedAt
+import kotlinx.datetime.toJavaLocalDate
 import java.time.ZoneId
 import java.time.ZoneOffset
+import java.util.UUID
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -38,6 +47,14 @@ interface CalendarDataSource {
     fun instances(beginMillis: Long, endMillis: Long): List<EventInstance>
     fun eventDetail(eventId: Long): EventDetail?
 
+    /**
+     * Master/one-off events whose title, description or location contains
+     * [query] (case-insensitive), across all calendars, newest first. Reads the
+     * Events table directly so the search is unbounded in time; exception rows
+     * are excluded (see [SearchProjection]). [query] is assumed non-blank.
+     */
+    fun searchEvents(query: String): List<EventInstance>
+
     /**
      * The event-colour palette the calendar's account publishes
      * (`CalendarContract.Colors`, `TYPE_EVENT`), sorted by key. Empty when the
@@ -47,6 +64,26 @@ interface CalendarDataSource {
      */
     fun eventColorPalette(calendarId: Long): List<EventColorOption>
 
+    /**
+     * Every master/one-off event of the writable local calendars, mapped for a
+     * whole-calendar `.ics` backup. Modified-occurrence and cancelled-exception
+     * rows are excluded (see [EventExportProjection]).
+     */
+    fun exportableEvents(): List<IcsEvent>
+
+    /**
+     * The non-empty `Events.UID_2445` values present in [calendarId] — used to
+     * dedup an `.ics` import so re-importing a backup doesn't double events.
+     */
+    fun existingUids(calendarId: Long): Set<String>
+
+    /**
+     * Insert a parsed `.ics` event into [calendarId], preserving its UID (or
+     * minting one when absent); returns the new `Events._ID`. Reminders are
+     * written as the file's raw lead minutes (METHOD_ALERT).
+     */
+    fun insertImportedEvent(event: ParsedIcsEvent, calendarId: Long): Long
+
     /**
      * Create a new device-only (`ACCOUNT_TYPE_LOCAL`) calendar the app owns;
      * returns its `Calendars._ID`. Inserted through the sync-adapter URI so the
@@ -60,24 +97,40 @@ interface CalendarDataSource {
     /** 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
+     * Insert a new event; returns the new `Events._ID`. [allDayReminderTimeMinutes]
+     * (minutes from local midnight) is the wall-clock time all-day reminders
+     * should fire at — encoded into each all-day reminder's provider offset
+     * (ignored for timed events).
+     */
+    fun insertEvent(form: EventForm, allDayReminderTimeMinutes: Int): 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.
+     * [allDayReminderTimeMinutes]: see [insertEvent].
      */
-    fun updateEvent(eventId: Long, original: EventForm, updated: EventForm)
+    fun updateEvent(
+        eventId: Long,
+        original: EventForm,
+        updated: EventForm,
+        allDayReminderTimeMinutes: Int,
+    )
 
     /**
      * 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`.
+     * row's `Events._ID`. [allDayReminderTimeMinutes]: see [insertEvent].
      */
-    fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long
+    fun updateOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        form: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ): Long
 
     /**
      * Change a recurring event from the occurrence at [beginMillis] onwards
@@ -92,6 +145,7 @@ interface CalendarDataSource {
         beginMillis: Long,
         original: EventForm,
         updated: EventForm,
+        allDayReminderTimeMinutes: Int,
     ): Long
 
     /**
@@ -120,14 +174,52 @@ class AndroidCalendarDataSource @Inject constructor(
 ) : CalendarDataSource {
 
     private val resolver: ContentResolver get() = context.contentResolver
-    private val observers = mutableMapOf<() -> Unit, ContentObserver>()
 
-    override fun calendars(): List<CalendarSource> = resolver.query(
+    // All access to these two collections is guarded by [observerLock] because
+    // listeners are registered on the main thread (repository init, via ViewModel
+    // creation) while [ensureObserversRegistered] runs on the IO dispatcher.
+    private val observerLock = Any()
+    private val observers = mutableMapOf<() -> Unit, ContentObserver>()
+    private val registeredObservers = mutableSetOf<ContentObserver>()
+
+    private fun hasCalendarPermission(): Boolean =
+        ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CALENDAR) ==
+            PackageManager.PERMISSION_GRANTED
+
+    /**
+     * Attach any not-yet-registered observers to the provider, but only once the
+     * calendar permission is held. Registering a ContentObserver on the calendar
+     * provider without that permission throws SecurityException on newer Android
+     * (it used to silently no-op), which crashed the app at launch — the repo
+     * registers its observer eagerly, before the permission gate. Called from the
+     * observed reads ([calendars]/[instances]) so the observer re-attaches the
+     * first time a screen queries after the permission is granted.
+     */
+    private fun ensureObserversRegistered() {
+        if (!hasCalendarPermission()) return
+        synchronized(observerLock) {
+            if (registeredObservers.size == observers.size) return
+            observers.values.forEach(::registerObserverLocked)
+        }
+    }
+
+    private fun registerObserverLocked(obs: ContentObserver) {
+        if (obs in registeredObservers || !hasCalendarPermission()) return
+        runCatching {
+            resolver.registerContentObserver(CalendarContract.CONTENT_URI, true, obs)
+        }.onSuccess { registeredObservers += obs }
+            .onFailure { Log.w(TAG, "Calendar observer registration skipped", it) }
+    }
+
+    override fun calendars(): List<CalendarSource> {
+        ensureObserversRegistered()
+        return resolver.query(
             CalendarContract.Calendars.CONTENT_URI,
             CalendarProjection.COLUMNS,
             null, null,
             CalendarContract.Calendars.CALENDAR_DISPLAY_NAME + " ASC",
         )?.use { it.mapAll(::toCalendarSource) } ?: emptyList()
+    }
 
     /**
      * Calendar-row writes must address the provider as a sync adapter and name
@@ -162,7 +254,8 @@ class AndroidCalendarDataSource @Inject constructor(
             putDescription(description)
         }
         val uri = resolver.insert(localCalendarsUri(), values)
-            ?: throw WriteFailedException("create local calendar '$name'")
+            // No calendar name in the message — it can reach a crash report.
+            ?: throw WriteFailedException("create local calendar")
         return ContentUris.parseId(uri)
     }
 
@@ -200,6 +293,7 @@ class AndroidCalendarDataSource @Inject constructor(
     }
 
     override fun instances(beginMillis: Long, endMillis: Long): List<EventInstance> {
+        ensureObserversRegistered()
         val uri = CalendarContract.Instances.CONTENT_URI.buildUpon().apply {
             ContentUris.appendId(this, beginMillis)
             ContentUris.appendId(this, endMillis)
@@ -212,6 +306,89 @@ class AndroidCalendarDataSource @Inject constructor(
         )?.use { c -> c.mapAllNotNull { CursorColumnReader(c).toEventInstance() } } ?: emptyList()
     }
 
+    override fun searchEvents(query: String): List<EventInstance> {
+        ensureObserversRegistered()
+        val trimmed = query.trim()
+        if (trimmed.isEmpty()) return emptyList()
+        // Escape the SQL LIKE wildcards so a literal % or _ in the query matches
+        // itself instead of acting as a wildcard.
+        val escaped = trimmed
+            .replace("\\", "\\\\")
+            .replace("%", "\\%")
+            .replace("_", "\\_")
+        val like = "%$escaped%"
+        val match = "${CalendarContract.Events.TITLE} LIKE ? ESCAPE '\\' OR " +
+            "${CalendarContract.Events.DESCRIPTION} LIKE ? ESCAPE '\\' OR " +
+            "${CalendarContract.Events.EVENT_LOCATION} LIKE ? ESCAPE '\\'"
+        val selection = "($match) AND " +
+            "${CalendarContract.Events.DELETED} = 0 AND " +
+            "${CalendarContract.Events.ORIGINAL_ID} IS NULL"
+        return resolver.query(
+            CalendarContract.Events.CONTENT_URI,
+            SearchProjection.COLUMNS,
+            selection,
+            arrayOf(like, like, like),
+            CalendarContract.Events.DTSTART + " DESC",
+        )?.use { c ->
+            val reader = CursorColumnReader(c)
+            val out = ArrayList<EventInstance>(c.count)
+            while (c.moveToNext()) {
+                val base = reader.toSearchResult() ?: continue
+                // A recurring master's DTSTART is the series start; show its
+                // nearest occurrence instead so the date is the one the user
+                // actually cares about (and sorting reflects it).
+                val recurring = !reader.getString(SearchProjection.IDX_RRULE).isNullOrEmpty() ||
+                    !reader.getString(SearchProjection.IDX_RDATE).isNullOrEmpty()
+                out += if (recurring) {
+                    nearestOccurrenceMillis(base.eventId)?.let { (begin, end) ->
+                        base.copy(
+                            start = begin.toKotlinInstantFromEpochMillis(),
+                            end = end.toKotlinInstantFromEpochMillis(),
+                        )
+                    } ?: base
+                } else {
+                    base
+                }
+            }
+            out
+        } ?: emptyList()
+    }
+
+    /**
+     * The occurrence of [eventId] nearest to now: the soonest upcoming one
+     * within [OCCURRENCE_WINDOW_MILLIS] ahead, else the most recent past one
+     * within the same window behind. Null when neither exists (e.g. a series
+     * that only starts further out than the window) — the caller then keeps the
+     * series-start DTSTART. Returns (begin, end) epoch millis.
+     */
+    private fun nearestOccurrenceMillis(eventId: Long): Pair<Long, Long>? {
+        val now = System.currentTimeMillis()
+        return occurrenceInWindow(eventId, now, now + OCCURRENCE_WINDOW_MILLIS, soonestFirst = true)
+            ?: occurrenceInWindow(eventId, now - OCCURRENCE_WINDOW_MILLIS, now, soonestFirst = false)
+    }
+
+    private fun occurrenceInWindow(
+        eventId: Long,
+        beginMillis: Long,
+        endMillis: Long,
+        soonestFirst: Boolean,
+    ): Pair<Long, Long>? {
+        val uri = CalendarContract.Instances.CONTENT_URI.buildUpon().apply {
+            ContentUris.appendId(this, beginMillis)
+            ContentUris.appendId(this, endMillis)
+        }.build()
+        val order = CalendarContract.Instances.BEGIN + if (soonestFirst) " ASC" else " DESC"
+        return resolver.query(
+            uri,
+            arrayOf(CalendarContract.Instances.BEGIN, CalendarContract.Instances.END),
+            "${CalendarContract.Instances.EVENT_ID} = ?",
+            arrayOf(eventId.toString()),
+            order,
+        )?.use { c ->
+            if (!c.moveToFirst()) null else c.getLong(0) to c.getLong(1)
+        }
+    }
+
     override fun eventDetail(eventId: Long): EventDetail? {
         val attendees = queryAttendees(eventId)
         val reminders = queryReminders(eventId)
@@ -247,6 +424,112 @@ class AndroidCalendarDataSource @Inject constructor(
             ?: emptyList()
     }
 
+    override fun exportableEvents(): List<IcsEvent> {
+        // Only the local calendars the app owns and can write — synced calendars
+        // already have a backup (their server). Map id → display name for the
+        // X-CALENDULA-CALENDAR tag a restore uses to fan back out.
+        val names = calendars()
+            .filter { it.isLocal && it.canModifyContents }
+            .associate { it.id to it.displayName }
+        if (names.isEmpty()) return emptyList()
+
+        val idList = names.keys.joinToString(",")
+        return resolver.query(
+            CalendarContract.Events.CONTENT_URI,
+            EventExportProjection.COLUMNS,
+            // Skip soft-deleted rows and exception rows (modified occurrences /
+            // cancellations) — v1 exports masters + one-offs only.
+            "${CalendarContract.Events.CALENDAR_ID} IN ($idList) AND " +
+                "${CalendarContract.Events.DELETED} = 0 AND " +
+                "${CalendarContract.Events.ORIGINAL_ID} IS NULL",
+            null,
+            CalendarContract.Events.DTSTART + " ASC",
+        )?.use { c ->
+            c.mapAll {
+                val reader = CursorColumnReader(c)
+                val eventId = reader.getLong(EventExportProjection.IDX_ID)
+                val calendarId = reader.getLong(EventExportProjection.IDX_CALENDAR_ID)
+                reader.toIcsEvent(
+                    reminderMinutes = queryReminders(eventId).map { it.minutes },
+                    calendarName = names[calendarId],
+                )
+            }
+        } ?: emptyList()
+    }
+
+    override fun existingUids(calendarId: Long): Set<String> = resolver.query(
+        CalendarContract.Events.CONTENT_URI,
+        arrayOf(CalendarContract.Events.UID_2445),
+        "${CalendarContract.Events.CALENDAR_ID} = ? AND " +
+            "${CalendarContract.Events.UID_2445} IS NOT NULL",
+        arrayOf(calendarId.toString()),
+        null,
+    )?.use { c ->
+        buildSet { while (c.moveToNext()) c.getString(0)?.takeIf { it.isNotEmpty() }?.let(::add) }
+    } ?: emptySet()
+
+    override fun insertImportedEvent(event: ParsedIcsEvent, calendarId: Long): Long {
+        val startMillis = event.start.toEpochMillis()
+        val endMillis = event.end.toEpochMillis()
+        val values = ContentValues().apply {
+            put(CalendarContract.Events.CALENDAR_ID, calendarId)
+            // Preserve the file's UID so a re-import dedups against it; mint one
+            // only when the source event carried none.
+            put(
+                CalendarContract.Events.UID_2445,
+                event.uid?.takeIf { it.isNotBlank() } ?: "${UUID.randomUUID()}@calendula",
+            )
+            put(CalendarContract.Events.TITLE, event.summary.trim())
+            put(CalendarContract.Events.ALL_DAY, if (event.isAllDay) 1 else 0)
+            put(CalendarContract.Events.DTSTART, startMillis)
+            if (event.recurrenceRule == null) {
+                put(CalendarContract.Events.DTEND, endMillis)
+            } else {
+                put(CalendarContract.Events.RRULE, event.recurrenceRule)
+                put(
+                    CalendarContract.Events.DURATION,
+                    importDuration(startMillis, endMillis, event.isAllDay),
+                )
+            }
+            // All-day rows live at UTC midnights (the file already encodes them so);
+            // timed rows keep the event's own zone.
+            put(CalendarContract.Events.EVENT_TIMEZONE, if (event.isAllDay) "UTC" else event.zoneId)
+            put(CalendarContract.Events.AVAILABILITY, event.availability.toProviderValue())
+            put(CalendarContract.Events.STATUS, event.status.toProviderStatus())
+            event.location?.trim()?.takeIf { it.isNotEmpty() }
+                ?.let { put(CalendarContract.Events.EVENT_LOCATION, it) }
+            event.description?.trim()?.takeIf { it.isNotEmpty() }
+                ?.let { put(CalendarContract.Events.DESCRIPTION, it) }
+        }
+        val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values)
+            ?: throw WriteFailedException("import event into calendar id=$calendarId")
+        val eventId = ContentUris.parseId(uri)
+        // Raw lead minutes straight from the file's VALARMs (best-effort, like insertEvent).
+        event.reminderMinutes.distinct().filter { it >= 0 }.forEach { minutes ->
+            val 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 imported event $eventId")
+            }
+        }
+        return eventId
+    }
+
+    /** Provider DURATION for an imported recurring row: whole days / seconds. */
+    private fun importDuration(startMillis: Long, endMillis: Long, isAllDay: Boolean): String {
+        val span = (endMillis - startMillis).coerceAtLeast(0)
+        return if (isAllDay) "P${span / 86_400_000L}D" else "P${span / 1_000L}S"
+    }
+
+    private fun EventStatus.toProviderStatus(): Int = when (this) {
+        EventStatus.Confirmed -> CalendarContract.Events.STATUS_CONFIRMED
+        EventStatus.Tentative -> CalendarContract.Events.STATUS_TENTATIVE
+        EventStatus.Cancelled -> CalendarContract.Events.STATUS_CANCELED
+    }
+
     /** The account a calendar belongs to, for scoping a `Colors` lookup. */
     private fun calendarAccount(calendarId: Long): CalendarAccount? = resolver.query(
         ContentUris.withAppendedId(CalendarContract.Calendars.CONTENT_URI, calendarId),
@@ -265,13 +548,44 @@ class AndroidCalendarDataSource @Inject constructor(
 
     private data class CalendarAccount(val name: String, val type: String)
 
-    override fun insertEvent(form: EventForm): Long {
+    /**
+     * The raw provider `MINUTES` to store for one of [form]'s reminders: an
+     * all-day reminder is shifted to fire at [allDayReminderTimeMinutes] local
+     * (see [toProviderAllDayMinutes]); a timed reminder is its lead time as-is.
+     */
+    private fun providerReminderMinutes(
+        form: EventForm,
+        minutes: Int,
+        allDayReminderTimeMinutes: Int,
+    ): Int = if (form.isAllDay) {
+        toProviderAllDayMinutes(
+            semanticMinutes = minutes,
+            startDate = form.start.date.toJavaLocalDate(),
+            zone = ZoneId.systemDefault(),
+            timeOfDayMinutes = allDayReminderTimeMinutes,
+        )
+    } else {
+        minutes
+    }
+
+    /** [form]'s reminders as the distinct raw provider offsets to store. */
+    private fun encodedReminders(form: EventForm, allDayReminderTimeMinutes: Int): List<Int> =
+        form.reminders
+            .map { providerReminderMinutes(form, it, allDayReminderTimeMinutes) }
+            .distinct()
+
+    override fun insertEvent(form: EventForm, allDayReminderTimeMinutes: Int): Long {
         val times = form.toWriteTimes(ZoneId.systemDefault())
         val values = ContentValues().apply {
             put(
                 CalendarContract.Events.CALENDAR_ID,
                 requireNotNull(form.calendarId) { "EventForm.calendarId is required" },
             )
+            // A globally-unique UID so a later .ics backup/restore can identify
+            // the event and not duplicate it on re-import (the provider leaves
+            // this null for events it didn't sync). Older rows without one fall
+            // back to a stable synthesised UID at export time (deriveIcsUid).
+            put(CalendarContract.Events.UID_2445, "${UUID.randomUUID()}@calendula")
             put(CalendarContract.Events.TITLE, form.title.trim())
             put(CalendarContract.Events.ALL_DAY, if (form.isAllDay) 1 else 0)
             put(CalendarContract.Events.DTSTART, times.dtStartMillis)
@@ -303,7 +617,8 @@ class AndroidCalendarDataSource @Inject constructor(
         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 ->
+        encodedReminders(form, allDayReminderTimeMinutes)
+            .forEach { minutes ->
                 val reminder = ContentValues().apply {
                     put(CalendarContract.Reminders.EVENT_ID, eventId)
                     put(CalendarContract.Reminders.MINUTES, minutes)
@@ -313,10 +628,19 @@ class AndroidCalendarDataSource @Inject constructor(
                     Log.w(TAG, "Failed to attach reminder ($minutes min) to event $eventId")
                 }
             }
+        // Guests are best-effort like reminders: a row that fails to attach is
+        // logged, not surfaced as a failed create. Calendula never sends an
+        // invitation — it only writes the rows; the backend decides delivery.
+        insertAttendees(eventId, form.attendees)
         return eventId
     }
 
-    override fun updateEvent(eventId: Long, original: EventForm, updated: EventForm) {
+    override fun updateEvent(
+        eventId: Long,
+        original: EventForm,
+        updated: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ) {
         val values = buildEventUpdateValues(
             original = original,
             updated = updated,
@@ -332,13 +656,25 @@ class AndroidCalendarDataSource @Inject constructor(
             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.
+        // disturb provider rows the form never knew about. The diff is on the
+        // form's semantic minutes; reconcile works in encoded provider minutes.
         if (updated.reminders.toSet() != original.reminders.toSet()) {
-            reconcileReminders(eventId, updated.reminders)
+            reconcileReminders(eventId, encodedReminders(updated, allDayReminderTimeMinutes))
+        }
+        // Same untouched-set guard for guests: only reconcile when the form's
+        // attendees actually changed, so unrelated edits never disturb the
+        // organizer/resource rows the form doesn't model.
+        if (updated.attendees.toSet() != original.attendees.toSet()) {
+            reconcileAttendees(eventId, updated.attendees)
         }
     }
 
-    override fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long {
+    override fun updateOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        form: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ): Long {
         // The provider clones the series row and applies these values on top.
         val values = buildOccurrenceExceptionValues(
             form = form,
@@ -352,7 +688,8 @@ class AndroidCalendarDataSource @Inject constructor(
         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)
+        reconcileReminders(exceptionId, encodedReminders(form, allDayReminderTimeMinutes))
+        reconcileAttendees(exceptionId, form.attendees)
         return exceptionId
     }
 
@@ -361,16 +698,17 @@ class AndroidCalendarDataSource @Inject constructor(
         beginMillis: Long,
         original: EventForm,
         updated: EventForm,
+        allDayReminderTimeMinutes: Int,
     ): 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)
+            updateEvent(eventId, original, updated, allDayReminderTimeMinutes)
             return eventId
         }
         // Insert the new series first: if it fails, the original is untouched.
-        val newEventId = insertEvent(updated)
+        val newEventId = insertEvent(updated, allDayReminderTimeMinutes)
         truncateSeries(eventId, row, beginMillis)
         return newEventId
     }
@@ -456,9 +794,11 @@ class AndroidCalendarDataSource @Inject constructor(
     }
 
     /**
-     * Make the event's reminder rows match [targetMinutes]: rows with other
+     * Make the event's reminder rows match [targetMinutes] — the raw provider
-     * lead times are deleted, missing ones inserted as best-effort ALERTs
+     * offsets to store (already encoded via [encodedReminders], so all-day shifts
-     * (like insertEvent). Rows whose minutes survive keep their method.
+     * are baked in and the diff matches the stored rows). Rows with other offsets
+     * 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()
@@ -483,6 +823,135 @@ class AndroidCalendarDataSource @Inject constructor(
         }
     }
 
+    /** Normalised key an attendee is matched/deduped on (case-insensitive email). */
+    private fun EventAttendee.key(): String = email.trim().lowercase()
+
+    /** Distinct guests by email; blanks dropped (we key and write on the address). */
+    private fun List<EventAttendee>.distinctByEmail(): List<EventAttendee> {
+        val seen = HashSet<String>()
+        return filter { it.email.isNotBlank() && seen.add(it.key()) }
+    }
+
+    private fun attendeeValues(eventId: Long, attendee: EventAttendee): ContentValues =
+        ContentValues().apply {
+            put(CalendarContract.Attendees.EVENT_ID, eventId)
+            put(CalendarContract.Attendees.ATTENDEE_EMAIL, attendee.email.trim())
+            attendee.name.trim().takeIf { it.isNotEmpty() }
+                ?.let { put(CalendarContract.Attendees.ATTENDEE_NAME, it) }
+            // A plain guest — never the organizer (we don't fabricate scheduling
+            // identity; the backend owns that). Invited = awaiting their reply.
+            put(
+                CalendarContract.Attendees.ATTENDEE_RELATIONSHIP,
+                CalendarContract.Attendees.RELATIONSHIP_ATTENDEE,
+            )
+            put(CalendarContract.Attendees.ATTENDEE_TYPE, attendee.providerType())
+            put(
+                CalendarContract.Attendees.ATTENDEE_STATUS,
+                CalendarContract.Attendees.ATTENDEE_STATUS_INVITED,
+            )
+        }
+
+    private fun EventAttendee.providerType(): Int = if (optional) {
+        CalendarContract.Attendees.TYPE_OPTIONAL
+    } else {
+        CalendarContract.Attendees.TYPE_REQUIRED
+    }
+
+    /** Best-effort attendee inserts (like reminders); emails are never logged. */
+    private fun insertAttendees(eventId: Long, attendees: List<EventAttendee>) {
+        attendees.distinctByEmail().forEach { attendee ->
+            if (resolver.insert(
+                    CalendarContract.Attendees.CONTENT_URI,
+                    attendeeValues(eventId, attendee),
+                ) == null
+            ) {
+                Log.w(TAG, "Failed to attach a guest to event $eventId")
+            }
+        }
+    }
+
+    private data class AttendeeRow(
+        val id: Long,
+        val email: String,
+        val relationship: Int,
+        val type: Int,
+    ) {
+        val key: String get() = email.trim().lowercase()
+    }
+
+    private fun queryAttendeeRows(eventId: Long): List<AttendeeRow> = resolver.query(
+        CalendarContract.Attendees.CONTENT_URI,
+        arrayOf(
+            CalendarContract.Attendees._ID,
+            CalendarContract.Attendees.ATTENDEE_EMAIL,
+            CalendarContract.Attendees.ATTENDEE_RELATIONSHIP,
+            CalendarContract.Attendees.ATTENDEE_TYPE,
+        ),
+        CalendarContract.Attendees.EVENT_ID + " = ?",
+        arrayOf(eventId.toString()),
+        null,
+    )?.use { c ->
+        buildList {
+            while (c.moveToNext()) {
+                add(
+                    AttendeeRow(
+                        id = c.getLong(0),
+                        email = c.getString(1).orEmpty(),
+                        relationship = c.getInt(2),
+                        type = c.getInt(3),
+                    ),
+                )
+            }
+        }
+    } ?: emptyList()
+
+    /**
+     * Make the event's *editable* guest rows match [attendees]. Only rows we
+     * own — has an email, not the organizer, not a resource — are reconciled;
+     * everything else the backend put there is left untouched. Matched rows keep
+     * their response status (only the required/optional type is updated if it
+     * changed); dropped rows are deleted; new guests inserted. Calendula sends
+     * nothing — the backend decides if anyone is notified on sync.
+     */
+    private fun reconcileAttendees(eventId: Long, attendees: List<EventAttendee>) {
+        val target = attendees.distinctByEmail()
+        val targetByKey = target.associateBy { it.key() }
+        val editable = queryAttendeeRows(eventId).filter {
+            it.email.isNotBlank() &&
+                it.relationship != CalendarContract.Attendees.RELATIONSHIP_ORGANIZER &&
+                it.type != CalendarContract.Attendees.TYPE_RESOURCE
+        }
+        val editableKeys = editable.map { it.key }.toSet()
+        editable.forEach { row ->
+            val want = targetByKey[row.key]
+            if (want == null) {
+                resolver.delete(
+                    CalendarContract.Attendees.CONTENT_URI,
+                    CalendarContract.Attendees._ID + " = ?",
+                    arrayOf(row.id.toString()),
+                )
+            } else if (row.type != want.providerType()) {
+                resolver.update(
+                    CalendarContract.Attendees.CONTENT_URI,
+                    ContentValues().apply {
+                        put(CalendarContract.Attendees.ATTENDEE_TYPE, want.providerType())
+                    },
+                    CalendarContract.Attendees._ID + " = ?",
+                    arrayOf(row.id.toString()),
+                )
+            }
+        }
+        target.filterNot { it.key() in editableKeys }.forEach { attendee ->
+            if (resolver.insert(
+                    CalendarContract.Attendees.CONTENT_URI,
+                    attendeeValues(eventId, attendee),
+                ) == null
+            ) {
+                Log.w(TAG, "Failed to attach a guest to event $eventId")
+            }
+        }
+    }
+
     private fun Map<String, Any?>.toContentValues(): ContentValues =
         ContentValues().also { cv ->
             forEach { (column, value) ->
@@ -491,7 +960,8 @@ class AndroidCalendarDataSource @Inject constructor(
                     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")
+                    // Only the type, never the value — a cell value can be event content.
+                    else -> error("Unsupported value type for column '$column': ${value::class.simpleName}")
                 }
             }
         }
@@ -524,16 +994,20 @@ class AndroidCalendarDataSource @Inject constructor(
                 listener()
             }
         }
+        synchronized(observerLock) {
             observers[listener] = obs
-        resolver.registerContentObserver(
+            // Attach now if we already hold the permission; otherwise it stays
-            CalendarContract.CONTENT_URI,
+            // pending and re-attaches on the first read after the grant.
-            /* notifyForDescendants = */ true,
+            registerObserverLocked(obs)
-            obs,
+        }
-        )
     }
 
     override fun unregisterChangeListener(listener: () -> Unit) {
-        observers.remove(listener)?.let { resolver.unregisterContentObserver(it) }
+        synchronized(observerLock) {
+            observers.remove(listener)?.let { obs ->
+                if (registeredObservers.remove(obs)) resolver.unregisterContentObserver(obs)
+            }
+        }
     }
 
     private fun queryAttendees(eventId: Long): List<Attendee> = resolver.query(
@@ -572,5 +1046,12 @@ class AndroidCalendarDataSource @Inject constructor(
          * together (by account) in the filter sheet and calendar manager.
          */
         const val LOCAL_ACCOUNT_NAME = "Calendula"
+
+        /**
+         * How far ahead/behind a search looks for a recurring event's nearest
+         * occurrence (~2 years). Wide enough for everyday series; a series that
+         * next fires beyond it falls back to its series-start date.
+         */
+        const val OCCURRENCE_WINDOW_MILLIS = 2L * 365 * 24 * 60 * 60 * 1000
     }
 }

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

@@ -5,6 +5,9 @@ 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.ics.IcsEvent
+import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import kotlinx.coroutines.flow.Flow
 import kotlin.time.Instant
 
@@ -13,6 +16,13 @@ interface CalendarRepository {
     fun instances(range: ClosedRange<Instant>): Flow<List<EventInstance>>
     suspend fun eventDetail(eventId: Long): EventDetail
 
+    /**
+     * Events whose title, description or location contains [query], with hidden
+     * calendars removed and newest first. Empty when [query] is blank. Searches
+     * the whole history/future (see [CalendarDataSource.searchEvents]).
+     */
+    suspend fun searchEvents(query: String): List<EventInstance>
+
     /**
      * The event-colour palette a calendar's account publishes; empty when it
      * exposes none (see [CalendarDataSource.eventColorPalette]).
@@ -28,6 +38,19 @@ interface CalendarRepository {
     /** Permanently delete a local calendar the app owns, with all its events. */
     suspend fun deleteCalendar(id: Long)
 
+    /**
+     * Every event of the writable local calendars, ready to serialise into a
+     * whole-calendar `.ics` backup (see [CalendarDataSource.exportableEvents]).
+     */
+    suspend fun exportEvents(): List<IcsEvent>
+
+    /**
+     * Bulk-import parsed `.ics` [events] into [targetCalendarId]. Events whose
+     * UID already exists in the target are skipped (idempotent restore); the
+     * rest are inserted. See [CalendarDataSource.insertImportedEvent].
+     */
+    suspend fun importEvents(targetCalendarId: Long, events: List<ParsedIcsEvent>): IcsImportSummary
+
     /** Create a new event from a validated form; returns the new `Events._ID`. */
     suspend fun createEvent(form: EventForm): Long
 

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

@@ -2,15 +2,19 @@ package de.jeanlucmakiola.calendula.data.calendar
 
 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.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.ics.IcsImportSummary
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.onStart
@@ -28,9 +32,14 @@ import javax.inject.Singleton
 class CalendarRepositoryImpl @Inject constructor(
     private val dataSource: CalendarDataSource,
     private val prefs: CalendarPrefs,
+    private val settingsPrefs: SettingsPrefs,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : CalendarRepository {
 
+    /** The configured wall-clock fire time for all-day reminders, read per write. */
+    private suspend fun allDayReminderTimeMinutes(): Int =
+        settingsPrefs.allDayReminderTimeMinutes.first()
+
     private val ticks = MutableSharedFlow<Unit>(
         replay = 0,
         extraBufferCapacity = 1,
@@ -71,6 +80,13 @@ class CalendarRepositoryImpl @Inject constructor(
         dataSource.eventDetail(eventId) ?: throw NoSuchEventException(eventId)
     }
 
+    override suspend fun searchEvents(query: String): List<EventInstance> = withContext(io) {
+        if (query.isBlank()) return@withContext emptyList()
+        val hidden = prefs.hiddenCalendarIds.first()
+        dataSource.searchEvents(query)
+            .let { if (hidden.isEmpty()) it else it.filterNot { e -> e.calendarId in hidden } }
+    }
+
     override suspend fun eventColorPalette(calendarId: Long): List<EventColorOption> =
         withContext(io) { dataSource.eventColorPalette(calendarId) }
 
@@ -92,8 +108,30 @@ class CalendarRepositoryImpl @Inject constructor(
     override suspend fun deleteCalendar(id: Long) =
         withContext(io) { dataSource.deleteCalendar(id) }
 
+    override suspend fun exportEvents() = withContext(io) { dataSource.exportableEvents() }
+
+    override suspend fun importEvents(
+        targetCalendarId: Long,
+        events: List<ParsedIcsEvent>,
+    ): IcsImportSummary = withContext(io) {
+        val existing = dataSource.existingUids(targetCalendarId)
+        var imported = 0
+        var skipped = 0
+        for (event in events) {
+            // A known UID means the event is already in this calendar — skip,
+            // keeping a restore idempotent (no overwrite this pass).
+            if (event.uid != null && event.uid in existing) {
+                skipped++
+            } else {
+                dataSource.insertImportedEvent(event, targetCalendarId)
+                imported++
+            }
+        }
+        IcsImportSummary(imported = imported, skippedDuplicate = skipped)
+    }
+
     override suspend fun createEvent(form: EventForm): Long = withContext(io) {
-        dataSource.insertEvent(form)
+        dataSource.insertEvent(form, allDayReminderTimeMinutes())
     }
 
     override suspend fun updateEvent(
@@ -101,7 +139,7 @@ class CalendarRepositoryImpl @Inject constructor(
         original: EventForm,
         updated: EventForm,
     ) = withContext(io) {
-        dataSource.updateEvent(eventId, original, updated)
+        dataSource.updateEvent(eventId, original, updated, allDayReminderTimeMinutes())
     }
 
     override suspend fun deleteEvent(eventId: Long) = withContext(io) {
@@ -113,7 +151,7 @@ class CalendarRepositoryImpl @Inject constructor(
         beginMillis: Long,
         form: EventForm,
     ): Long = withContext(io) {
-        dataSource.updateOccurrence(eventId, beginMillis, form)
+        dataSource.updateOccurrence(eventId, beginMillis, form, allDayReminderTimeMinutes())
     }
 
     override suspend fun updateEventFromOccurrence(
@@ -122,7 +160,9 @@ class CalendarRepositoryImpl @Inject constructor(
         original: EventForm,
         updated: EventForm,
     ): Long = withContext(io) {
-        dataSource.updateEventFromOccurrence(eventId, beginMillis, original, updated)
+        dataSource.updateEventFromOccurrence(
+            eventId, beginMillis, original, updated, allDayReminderTimeMinutes(),
+        )
     }
 
     override suspend fun deleteOccurrence(eventId: Long, beginMillis: Long) = withContext(io) {

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

@@ -13,6 +13,9 @@ import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
 import de.jeanlucmakiola.calendula.domain.ReminderMethod
+import java.time.Instant
+import java.time.ZoneId
+import java.time.ZoneOffset
 
 private const val TAG = "EventDetailMapper"
 
@@ -58,6 +61,7 @@ internal fun ColumnReader.toEventDetailCore(
     val color = eventColor ?: getInt(EventDetailProjection.IDX_CALENDAR_COLOR)
 
     val eventId = getLong(EventDetailProjection.IDX_EVENT_ID)
+    val isAllDay = getInt(EventDetailProjection.IDX_ALL_DAY) != 0
     val instance = EventInstance(
         instanceId = eventId,
         eventId = eventId,
@@ -65,11 +69,23 @@ internal fun ColumnReader.toEventDetailCore(
         title = title,
         start = begin.toKotlinInstantFromEpochMillis(),
         end = end.toKotlinInstantFromEpochMillis(),
-        isAllDay = getInt(EventDetailProjection.IDX_ALL_DAY) != 0,
+        isAllDay = isAllDay,
         color = color,
         location = getString(EventDetailProjection.IDX_LOCATION),
     )
 
+    // All-day reminders are stored as a wall-clock-shifted offset (see
+    // AllDayReminderEncoding); decode back to the whole-day lead time the form
+    // and detail screen speak. DTSTART is UTC midnight for all-day events, so the
+    // event's date is its UTC date.
+    val displayReminders = if (isAllDay) {
+        val startDate = Instant.ofEpochMilli(begin).atZone(ZoneOffset.UTC).toLocalDate()
+        val zone = ZoneId.systemDefault()
+        reminders.map { it.copy(minutes = fromProviderAllDayMinutes(it.minutes, startDate, zone)) }
+    } else {
+        reminders
+    }
+
     // STATUS shares its 0 value with STATUS_TENTATIVE, so a missing column must
     // be distinguished from a present 0 — an absent status means "just confirmed".
     val status = if (isNull(EventDetailProjection.IDX_STATUS)) {
@@ -84,7 +100,7 @@ internal fun ColumnReader.toEventDetailCore(
         organizer = getString(EventDetailProjection.IDX_ORGANIZER),
         attendees = attendees,
         rrule = getString(EventDetailProjection.IDX_RRULE),
-        reminders = reminders,
+        reminders = displayReminders,
         status = status,
         // BUSY and DEFAULT are both 0, so a null column folds into the same
         // default these mappers already return — no isNull guard needed.

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

@@ -0,0 +1,54 @@
+package de.jeanlucmakiola.calendula.data.calendar
+
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
+import de.jeanlucmakiola.calendula.domain.ics.deriveIcsUid
+import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
+
+/**
+ * Map one Events row (read through [EventExportProjection]) into an [IcsEvent]
+ * for backup. [reminderMinutes] are the row's raw provider reminder offsets and
+ * [calendarName] the display name of its calendar (emitted as
+ * `X-CALENDULA-CALENDAR`). Pure given a [ColumnReader] — JVM-tested with
+ * MapColumnReader.
+ */
+internal fun ColumnReader.toIcsEvent(
+    reminderMinutes: List<Int>,
+    calendarName: String?,
+): IcsEvent {
+    val eventId = getLong(EventExportProjection.IDX_ID)
+    val dtStart = getLong(EventExportProjection.IDX_DTSTART)
+    val rrule = getString(EventExportProjection.IDX_RRULE)?.takeIf { it.isNotBlank() }
+
+    // Recurring rows store DURATION instead of DTEND; reconstruct the end from it
+    // so the writer can render DTEND. A missing/blank both means a zero-length event.
+    val end = when {
+        !isNull(EventExportProjection.IDX_DTEND) -> getLong(EventExportProjection.IDX_DTEND)
+        else -> dtStart + parseRfc2445DurationMillis(getString(EventExportProjection.IDX_DURATION))
+    }
+
+    // STATUS shares value 0 with TENTATIVE, so an absent column must read as Confirmed.
+    val status = if (isNull(EventExportProjection.IDX_STATUS)) {
+        EventStatus.Confirmed
+    } else {
+        mapEventStatus(getInt(EventExportProjection.IDX_STATUS))
+    }
+
+    return IcsEvent(
+        uid = deriveIcsUid(getString(EventExportProjection.IDX_UID), eventId, dtStart),
+        summary = getString(EventExportProjection.IDX_TITLE).orEmpty(),
+        start = dtStart.toKotlinInstantFromEpochMillis(),
+        end = end.toKotlinInstantFromEpochMillis(),
+        isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0,
+        zoneId = getString(EventExportProjection.IDX_EVENT_TIMEZONE)?.takeIf { it.isNotBlank() }
+            ?: "UTC",
+        recurrenceRule = rrule,
+        location = getString(EventExportProjection.IDX_LOCATION),
+        description = getString(EventExportProjection.IDX_DESCRIPTION),
+        reminderMinutes = reminderMinutes,
+        status = status,
+        availability = mapAvailability(getInt(EventExportProjection.IDX_AVAILABILITY)),
+        calendarName = calendarName,
+    )
+}
+

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

@@ -97,6 +97,86 @@ internal object EventDetailProjection {
     const val IDX_EVENT_COLOR_KEY = 17
 }
 
+/**
+ * Master/one-off Events rows for a whole-calendar backup. Unlike
+ * [EventDetailProjection] this reads `UID_2445` (to keep a row's identity across
+ * backups) and `DURATION` (recurring rows carry it instead of DTEND). Modified-
+ * occurrence and cancelled-exception rows are filtered out by the query
+ * (`ORIGINAL_ID IS NULL`), so RECURRENCE-ID overrides and EXDATEs aren't
+ * exported yet — a documented v1 limit (import skips them too).
+ */
+internal object EventExportProjection {
+    val COLUMNS: Array<String> = arrayOf(
+        CalendarContract.Events._ID,
+        CalendarContract.Events.UID_2445,
+        CalendarContract.Events.TITLE,
+        CalendarContract.Events.DTSTART,
+        CalendarContract.Events.DTEND,
+        CalendarContract.Events.DURATION,
+        CalendarContract.Events.ALL_DAY,
+        CalendarContract.Events.EVENT_TIMEZONE,
+        CalendarContract.Events.RRULE,
+        CalendarContract.Events.EVENT_LOCATION,
+        CalendarContract.Events.DESCRIPTION,
+        CalendarContract.Events.STATUS,
+        CalendarContract.Events.AVAILABILITY,
+        CalendarContract.Events.CALENDAR_ID,
+    )
+
+    const val IDX_ID = 0
+    const val IDX_UID = 1
+    const val IDX_TITLE = 2
+    const val IDX_DTSTART = 3
+    const val IDX_DTEND = 4
+    const val IDX_DURATION = 5
+    const val IDX_ALL_DAY = 6
+    const val IDX_EVENT_TIMEZONE = 7
+    const val IDX_RRULE = 8
+    const val IDX_LOCATION = 9
+    const val IDX_DESCRIPTION = 10
+    const val IDX_STATUS = 11
+    const val IDX_AVAILABILITY = 12
+    const val IDX_CALENDAR_ID = 13
+}
+
+/**
+ * Master/one-off Events rows matched by a full-text search. Like
+ * [EventExportProjection] it reads the Events table directly (so the search is
+ * unbounded in time), carrying DURATION for recurring rows that have no DTEND.
+ * Colour folds the calendar fallback like [InstanceProjection].
+ */
+internal object SearchProjection {
+    val COLUMNS: Array<String> = arrayOf(
+        CalendarContract.Events._ID,
+        CalendarContract.Events.CALENDAR_ID,
+        CalendarContract.Events.TITLE,
+        CalendarContract.Events.DTSTART,
+        CalendarContract.Events.DTEND,
+        CalendarContract.Events.DURATION,
+        CalendarContract.Events.ALL_DAY,
+        CalendarContract.Events.EVENT_COLOR,
+        CalendarContract.Events.CALENDAR_COLOR,
+        CalendarContract.Events.EVENT_LOCATION,
+        // Recurrence markers: a non-empty RRULE or RDATE means the result should
+        // display its nearest occurrence, not the series-start DTSTART.
+        CalendarContract.Events.RRULE,
+        CalendarContract.Events.RDATE,
+    )
+
+    const val IDX_ID = 0
+    const val IDX_CALENDAR_ID = 1
+    const val IDX_TITLE = 2
+    const val IDX_DTSTART = 3
+    const val IDX_DTEND = 4
+    const val IDX_DURATION = 5
+    const val IDX_ALL_DAY = 6
+    const val IDX_EVENT_COLOR = 7
+    const val IDX_CALENDAR_COLOR = 8
+    const val IDX_LOCATION = 9
+    const val IDX_RRULE = 10
+    const val IDX_RDATE = 11
+}
+
 internal object AttendeeProjection {
     val COLUMNS: Array<String> = arrayOf(
         CalendarContract.Attendees.ATTENDEE_NAME,

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

@@ -0,0 +1,40 @@
+package de.jeanlucmakiola.calendula.data.calendar
+
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
+
+/**
+ * Map an Events-table row (a search hit) to an [EventInstance]. Unlike the
+ * Instances query this reads the series master, so there is no instance id (the
+ * event id stands in as the list key) and recurring rows carry DURATION instead
+ * of DTEND — reconstruct the end the same way the `.ics` export does.
+ */
+internal fun ColumnReader.toSearchResult(): EventInstance? {
+    val dtStart = getLong(SearchProjection.IDX_DTSTART)
+    if (dtStart < 0L) return null
+    val end = when {
+        !isNull(SearchProjection.IDX_DTEND) -> getLong(SearchProjection.IDX_DTEND)
+        else -> dtStart + parseRfc2445DurationMillis(getString(SearchProjection.IDX_DURATION))
+    }.coerceAtLeast(dtStart)
+
+    val rawTitle = getString(SearchProjection.IDX_TITLE)
+    val title = if (rawTitle.isNullOrEmpty()) Fallbacks.UNTITLED_EVENT else rawTitle
+    val color = if (isNull(SearchProjection.IDX_EVENT_COLOR)) {
+        getInt(SearchProjection.IDX_CALENDAR_COLOR)
+    } else {
+        getInt(SearchProjection.IDX_EVENT_COLOR)
+    }
+    val eventId = getLong(SearchProjection.IDX_ID)
+
+    return EventInstance(
+        instanceId = eventId,
+        eventId = eventId,
+        calendarId = getLong(SearchProjection.IDX_CALENDAR_ID),
+        title = title,
+        start = dtStart.toKotlinInstantFromEpochMillis(),
+        end = end.toKotlinInstantFromEpochMillis(),
+        isAllDay = getInt(SearchProjection.IDX_ALL_DAY) != 0,
+        color = color,
+        location = getString(SearchProjection.IDX_LOCATION),
+    )
+}

app/src/main/java/de/jeanlucmakiola/calendula/data/crash/CrashReporter.kt

@@ -0,0 +1,188 @@
+package de.jeanlucmakiola.calendula.data.crash
+
+import android.content.Context
+import android.content.pm.PackageInfo
+import android.os.Build
+import androidx.core.content.pm.PackageInfoCompat
+import java.io.File
+import java.io.PrintWriter
+import java.io.StringWriter
+import java.time.Instant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+
+/**
+ * Privacy-respecting crash capture (prod-readiness item 10). On an uncaught
+ * exception it writes a self-contained report to the app's private storage and
+ * then chains to the platform's default handler, so the process still dies
+ * normally (and the OS shows its own "stopped" dialog). Nothing is uploaded —
+ * the app holds no `INTERNET` permission. The user submits the report later,
+ * by hand, as a Gitea issue (see the ui/crash surfaces).
+ *
+ * The report is built from a fixed [CrashContext] allowlist — app/Android/device
+ * version, locale, time, and the stack trace — and **nothing else**: no device
+ * identifiers, no account names, no calendar/event content, no logcat. The user
+ * is always shown the full text before it leaves the device.
+ */
+object CrashReporter {
+
+    /**
+     * Install the handler. Called first thing in `CalendulaApp.onCreate()` so it
+     * also catches crashes during startup. The handler swallows nothing — it
+     * persists, then delegates to the previously-registered handler.
+     */
+    fun install(context: Context) {
+        val appContext = context.applicationContext
+        val previous = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            // Capturing must never mask the original crash, so guard every step.
+            runCatching {
+                val now = System.currentTimeMillis()
+                writeReport(appContext, buildCrashReport(CrashContext.from(appContext), throwable, now))
+                recordCrashTime(appContext, now)
+            }
+            previous?.uncaughtException(thread, throwable)
+        }
+    }
+
+    /** The persisted report from the last crash, or null if there is none. */
+    fun pendingReport(context: Context): String? {
+        val file = reportFile(context)
+        return if (file.exists()) runCatching { file.readText() }.getOrNull()?.takeIf { it.isNotBlank() } else null
+    }
+
+    /**
+     * Whether to surface the report unprompted (on the next launch): a report
+     * exists and the user hasn't already waved this one away. Settings reaches
+     * the report via [pendingReport] regardless, so "Not now" only stops the
+     * auto-prompt — it doesn't discard the report.
+     */
+    fun shouldPrompt(context: Context): Boolean =
+        reportFile(context).exists() && !dismissedFile(context).exists()
+
+    /** Stop auto-prompting for the current report without discarding it. */
+    fun dismissPrompt(context: Context) {
+        runCatching { dismissedFile(context).apply { parentFile?.mkdirs() }.writeText("") }
+    }
+
+    /** Drop the persisted report once the user has reported it (or from Settings). */
+    fun clearReport(context: Context) {
+        runCatching { reportFile(context).delete() }
+        runCatching { dismissedFile(context).delete() }
+    }
+
+    /**
+     * Whether the app appears to be in a startup crash-loop: at least
+     * [LOOP_THRESHOLD] crashes inside [LOOP_WINDOW_MS]. In that case the main UI
+     * can't be trusted to start, so the caller routes straight to the standalone
+     * report screen instead of re-entering the crashing graph.
+     */
+    fun isCrashLoop(context: Context): Boolean {
+        val times = readCrashTimes(context)
+        if (times.size < LOOP_THRESHOLD) return false
+        val recent = times.sortedDescending()
+        return recent[0] - recent[LOOP_THRESHOLD - 1] <= LOOP_WINDOW_MS
+    }
+
+    /**
+     * Mark the app as having started successfully, resetting the loop counter so
+     * an ordinary single crash much later never trips loop detection. The
+     * pending report itself is kept — only the timing trail is cleared.
+     */
+    fun markHealthy(context: Context) {
+        runCatching { timesFile(context).delete() }
+    }
+
+    // --- persistence -------------------------------------------------------
+
+    private fun writeReport(context: Context, report: String) {
+        val file = reportFile(context).apply { parentFile?.mkdirs() }
+        file.writeText(report.take(MAX_REPORT_CHARS))
+        // A fresh crash should prompt again, even if the previous one was waved away.
+        runCatching { dismissedFile(context).delete() }
+    }
+
+    private fun recordCrashTime(context: Context, nowMillis: Long) {
+        val kept = (readCrashTimes(context) + nowMillis).takeLast(MAX_TIMES)
+        timesFile(context).apply { parentFile?.mkdirs() }
+            .writeText(kept.joinToString("\n"))
+    }
+
+    private fun readCrashTimes(context: Context): List<Long> {
+        val file = timesFile(context)
+        if (!file.exists()) return emptyList()
+        return runCatching { file.readLines().mapNotNull { it.trim().toLongOrNull() } }.getOrDefault(emptyList())
+    }
+
+    private fun crashDir(context: Context) = File(context.filesDir, CRASH_DIR)
+    private fun reportFile(context: Context) = File(crashDir(context), REPORT_FILE)
+    private fun timesFile(context: Context) = File(crashDir(context), TIMES_FILE)
+    private fun dismissedFile(context: Context) = File(crashDir(context), DISMISSED_FILE)
+
+    private const val CRASH_DIR = "crash"
+    private const val REPORT_FILE = "last_crash.txt"
+    private const val TIMES_FILE = "crash_times.txt"
+    private const val DISMISSED_FILE = "dismissed"
+    private const val MAX_TIMES = 5
+    private const val MAX_REPORT_CHARS = 64 * 1024
+    private const val LOOP_THRESHOLD = 2
+    private const val LOOP_WINDOW_MS = 10_000L
+}
+
+/**
+ * The allowlist of non-personal facts that go into a crash report. Built from
+ * [Build] and the app's own [PackageInfo]; deliberately holds no identifiers.
+ */
+data class CrashContext(
+    val appVersionName: String,
+    val appVersionCode: Long,
+    val sdkInt: Int,
+    val androidRelease: String,
+    val manufacturer: String,
+    val model: String,
+    val locale: String,
+) {
+    companion object {
+        fun from(context: Context): CrashContext {
+            val pkg = runCatching {
+                context.packageManager.getPackageInfo(context.packageName, 0)
+            }.getOrNull()
+            return CrashContext(
+                appVersionName = pkg?.versionName ?: "?",
+                appVersionCode = pkg?.let { PackageInfoCompat.getLongVersionCode(it) } ?: 0L,
+                sdkInt = Build.VERSION.SDK_INT,
+                androidRelease = Build.VERSION.RELEASE ?: "?",
+                manufacturer = Build.MANUFACTURER ?: "?",
+                model = Build.MODEL ?: "?",
+                locale = Locale.getDefault().toLanguageTag(),
+            )
+        }
+    }
+}
+
+/**
+ * Render a crash report from the [ctx] allowlist, the [throwable]'s full stack
+ * trace, and the crash [nowMillis]. Pure (no Android, no I/O) so it is unit
+ * tested. The leading marker doubles as the file's sanity check in
+ * [CrashReporter.pendingReport].
+ */
+fun buildCrashReport(ctx: CrashContext, throwable: Throwable, nowMillis: Long): String {
+    val trace = StringWriter().also { throwable.printStackTrace(PrintWriter(it)) }.toString().trim()
+    val time = runCatching {
+        Instant.ofEpochMilli(nowMillis).atZone(ZoneId.systemDefault()).format(TIME_FORMAT)
+    }.getOrDefault(nowMillis.toString())
+    return buildString {
+        appendLine("Calendula crash report")
+        appendLine("App version: ${ctx.appVersionName} (${ctx.appVersionCode})")
+        appendLine("Android: ${ctx.androidRelease} (API ${ctx.sdkInt})")
+        appendLine("Device: ${ctx.manufacturer} ${ctx.model}")
+        appendLine("Locale: ${ctx.locale}")
+        appendLine("Time: $time")
+        appendLine()
+        appendLine("Stack trace:")
+        append(trace)
+    }
+}
+
+private val TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")

app/src/main/java/de/jeanlucmakiola/calendula/data/ics/IcsExporter.kt

@@ -0,0 +1,46 @@
+package de.jeanlucmakiola.calendula.data.ics
+
+import android.content.Context
+import android.net.Uri
+import androidx.core.content.FileProvider
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.io.File
+import java.io.IOException
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * The Android IO edge of `.ics` export: writes a serialised calendar to a
+ * SAF document (whole-calendar backup) or stages it in a cache file behind a
+ * `FileProvider` content Uri (single-event share). The serialisation itself is
+ * the pure `domain.ics.IcsWriter`; this class only moves bytes.
+ */
+@Singleton
+class IcsExporter @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+
+    /** Write [content] to the SAF document at [uri] as UTF-8. Throws on failure. */
+    fun writeDocument(uri: Uri, content: String) {
+        context.contentResolver.openOutputStream(uri)?.use { out ->
+            out.write(content.toByteArray(Charsets.UTF_8))
+            // Only the scheme — the full Uri can embed the user's chosen filename.
+        } ?: throw IOException("Could not open output stream for export (scheme=${uri.scheme})")
+    }
+
+    /**
+     * Stage [content] in a private cache file and return a shareable content
+     * Uri for an `ACTION_SEND`. [fileName] is the suggested `.ics` name shown to
+     * the receiving app. The authority mirrors the manifest's `FileProvider`.
+     */
+    fun stageShareFile(fileName: String, content: String): Uri {
+        val dir = File(context.cacheDir, SHARE_DIR).apply { mkdirs() }
+        val file = File(dir, fileName)
+        file.writeText(content, Charsets.UTF_8)
+        return FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)
+    }
+
+    private companion object {
+        const val SHARE_DIR = "shared_ics"
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/data/ics/IcsImporter.kt

@@ -0,0 +1,21 @@
+package de.jeanlucmakiola.calendula.data.ics
+
+import android.content.Context
+import android.net.Uri
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Android IO edge of `.ics` import: reads the text of a received/opened
+ * document [Uri]. Parsing is the pure `domain.ics.IcsParser`; this class only
+ * pulls bytes off the ContentResolver. Returns null on any read failure.
+ */
+@Singleton
+class IcsImporter @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+    fun readText(uri: Uri): String? = runCatching {
+        context.contentResolver.openInputStream(uri)?.use { it.readBytes().toString(Charsets.UTF_8) }
+    }.getOrNull()
+}

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

@@ -4,6 +4,7 @@ import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.intPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import kotlinx.coroutines.flow.Flow
@@ -127,6 +128,111 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[REMINDER_ONBOARDING_KEY] = true }
     }
 
+    /**
+     * The default reminder lead time (minutes before start) prefilled on new
+     * **timed** events. `null` = no default reminder — the prior behaviour, kept
+     * as the factory default so existing users aren't surprised by reminders they
+     * never asked for. Stored as a string so "none" is distinct from a numeric
+     * value (and from an unset key, which is also "none"). Per-calendar overrides
+     * in [perCalendarReminderOverride] take precedence; all-day events instead use
+     * [defaultAllDayReminderMinutes]. Resolve with [resolveDefaultReminder].
+     */
+    val defaultReminderMinutes: Flow<Int?> = store.data.map { prefs ->
+        prefs[DEFAULT_REMINDER_KEY].toReminderMinutes()
+    }
+
+    suspend fun setDefaultReminderMinutes(minutes: Int?) {
+        store.edit { it[DEFAULT_REMINDER_KEY] = minutes?.toString() ?: NONE }
+    }
+
+    /**
+     * The default reminder lead time prefilled on new **all-day** events, in
+     * minutes before the start of the day. All-day events want day-scale lead
+     * times ("1 day before"), so they have their own default rather than reusing
+     * the timed one. `null` = no default. Per-calendar overrides do **not** apply
+     * to all-day events — they always use this global value.
+     */
+    val defaultAllDayReminderMinutes: Flow<Int?> = store.data.map { prefs ->
+        prefs[DEFAULT_ALLDAY_REMINDER_KEY].toReminderMinutes()
+    }
+
+    suspend fun setDefaultAllDayReminderMinutes(minutes: Int?) {
+        store.edit { it[DEFAULT_ALLDAY_REMINDER_KEY] = minutes?.toString() ?: NONE }
+    }
+
+    /**
+     * Wall-clock time, as minutes from local midnight, at which **all-day**
+     * reminders fire. All-day events live at UTC midnight, so a raw "1 day
+     * before" would fire at an off hour (02:00 local in CEST); this time is
+     * encoded into the provider offset so the reminder lands at, e.g., 09:00 the
+     * day before instead. Global for every all-day reminder; default 09:00.
+     * Stored/clamped to a valid 0..1439 minute-of-day.
+     */
+    val allDayReminderTimeMinutes: Flow<Int> = store.data.map { prefs ->
+        (prefs[ALLDAY_REMINDER_TIME_KEY] ?: DEFAULT_ALLDAY_REMINDER_TIME)
+            .coerceIn(0, MINUTES_PER_DAY - 1)
+    }
+
+    suspend fun setAllDayReminderTimeMinutes(minutesOfDay: Int) {
+        store.edit { it[ALLDAY_REMINDER_TIME_KEY] = minutesOfDay.coerceIn(0, MINUTES_PER_DAY - 1) }
+    }
+
+    /**
+     * How long the notification "Snooze" action defers a reminder, in minutes.
+     * Tapping Snooze cancels the notification and re-posts it after this delay
+     * via an exact alarm (the calendar provider won't re-fire). Default 10 min;
+     * clamped to at least 1.
+     */
+    val snoozeMinutes: Flow<Int> = store.data.map { prefs ->
+        (prefs[SNOOZE_MINUTES_KEY] ?: DEFAULT_SNOOZE_MINUTES).coerceAtLeast(1)
+    }
+
+    suspend fun setSnoozeMinutes(minutes: Int) {
+        store.edit { it[SNOOZE_MINUTES_KEY] = minutes.coerceAtLeast(1) }
+    }
+
+    /**
+     * Per-calendar overrides of [defaultReminderMinutes] for **timed** events,
+     * keyed by calendar id. A calendar **present** in the map overrides the global
+     * timed default for its new events: a `null` value means "no reminder", an int
+     * means that lead time. A calendar **absent** from the map inherits the global
+     * default. Serialised as `id=value;id=value`, with `none` for an explicit
+     * no-reminder override. (All-day events ignore this and use
+     * [defaultAllDayReminderMinutes].)
+     */
+    val perCalendarReminderOverride: Flow<Map<Long, Int?>> = store.data.map { prefs ->
+        parseReminderOverrides(prefs[CALENDAR_REMINDER_OVERRIDE_KEY])
+    }
+
+    suspend fun setCalendarReminderOverride(calendarId: Long, override: CalendarReminderOverride) {
+        store.edit { prefs ->
+            val current = parseReminderOverrides(prefs[CALENDAR_REMINDER_OVERRIDE_KEY]).toMutableMap()
+            current.applyOverride(calendarId, override)
+            prefs[CALENDAR_REMINDER_OVERRIDE_KEY] = serializeReminderOverrides(current)
+        }
+    }
+
+    /**
+     * Per-calendar overrides of [defaultAllDayReminderMinutes] for **all-day**
+     * events, with the same semantics as [perCalendarReminderOverride] (absent =
+     * inherit the global all-day default; present null = no reminder).
+     */
+    val perCalendarAllDayReminderOverride: Flow<Map<Long, Int?>> = store.data.map { prefs ->
+        parseReminderOverrides(prefs[CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY])
+    }
+
+    suspend fun setCalendarAllDayReminderOverride(
+        calendarId: Long,
+        override: CalendarReminderOverride,
+    ) {
+        store.edit { prefs ->
+            val current =
+                parseReminderOverrides(prefs[CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY]).toMutableMap()
+            current.applyOverride(calendarId, override)
+            prefs[CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY] = serializeReminderOverrides(current)
+        }
+    }
+
     private fun parseFormFields(stored: String?): Set<EventFormField> = when (stored) {
         null -> DEFAULT_FORM_FIELDS
         else -> stored.split(',')
@@ -143,10 +249,93 @@ class SettingsPrefs @Inject constructor(
         internal val REMINDER_ONBOARDING_KEY = booleanPreferencesKey("reminder_onboarding_done")
         internal val ALLOW_COLOR_UNSUPPORTED_KEY =
             booleanPreferencesKey("allow_color_unsupported_calendars")
+        internal val DEFAULT_REMINDER_KEY = stringPreferencesKey("default_reminder_minutes")
+        internal val DEFAULT_ALLDAY_REMINDER_KEY =
+            stringPreferencesKey("default_allday_reminder_minutes")
+        internal val ALLDAY_REMINDER_TIME_KEY =
+            intPreferencesKey("allday_reminder_time_minutes")
+        /** 09:00 as minutes from midnight; the default all-day reminder fire time. */
+        internal const val DEFAULT_ALLDAY_REMINDER_TIME = 540
+        private const val MINUTES_PER_DAY = 1_440
+        internal val SNOOZE_MINUTES_KEY = intPreferencesKey("snooze_minutes")
+        /** Default snooze delay for the notification "Snooze" action. */
+        const val DEFAULT_SNOOZE_MINUTES = 10
+        internal val CALENDAR_REMINDER_OVERRIDE_KEY =
+            stringPreferencesKey("per_calendar_reminder_override")
+        internal val CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY =
+            stringPreferencesKey("per_calendar_allday_reminder_override")
         internal val DEFAULT_FORM_FIELDS =
             setOf(EventFormField.Location, EventFormField.Description)
     }
 }
 
+/** A calendar's reminder-default override (see [SettingsPrefs.perCalendarReminderOverride]). */
+sealed interface CalendarReminderOverride {
+    /** No override — the calendar uses the global default. */
+    data object Inherit : CalendarReminderOverride
+    /** Explicit "no reminder" for this calendar, regardless of the global default. */
+    data object None : CalendarReminderOverride
+    /** A specific lead time in minutes before the event start. */
+    data class Minutes(val minutes: Int) : CalendarReminderOverride
+}
+
+/**
+ * The lead time to prefill on a new event: the matching per-calendar override
+ * if [calendarId] has one for this event kind, otherwise the global default for
+ * that kind. All-day events consult [allDayOverrides] / [allDayGlobal]; timed
+ * events consult [timedOverrides] / [timedGlobal]. `null` = no reminder. Pure so
+ * it can be unit-tested.
+ */
+fun resolveDefaultReminder(
+    timedGlobal: Int?,
+    allDayGlobal: Int?,
+    timedOverrides: Map<Long, Int?>,
+    allDayOverrides: Map<Long, Int?>,
+    calendarId: Long?,
+    isAllDay: Boolean,
+): Int? {
+    val overrides = if (isAllDay) allDayOverrides else timedOverrides
+    val global = if (isAllDay) allDayGlobal else timedGlobal
+    return if (calendarId != null && overrides.containsKey(calendarId)) {
+        overrides[calendarId]
+    } else {
+        global
+    }
+}
+
+/** Apply a [CalendarReminderOverride] to an override map ([Inherit] removes the key). */
+private fun MutableMap<Long, Int?>.applyOverride(
+    calendarId: Long,
+    override: CalendarReminderOverride,
+) {
+    when (override) {
+        CalendarReminderOverride.Inherit -> remove(calendarId)
+        CalendarReminderOverride.None -> put(calendarId, null)
+        is CalendarReminderOverride.Minutes -> put(calendarId, override.minutes)
+    }
+}
+
+private const val NONE = "none"
+private const val ENTRY_SEP = ";"
+private const val KEY_VALUE_SEP = "="
+
+private fun String?.toReminderMinutes(): Int? = when (this) {
+    null, "", NONE -> null
+    else -> toIntOrNull()
+}
+
+private fun parseReminderOverrides(stored: String?): Map<Long, Int?> {
+    if (stored.isNullOrBlank()) return emptyMap()
+    return stored.split(ENTRY_SEP).mapNotNull { entry ->
+        val parts = entry.split(KEY_VALUE_SEP).takeIf { it.size == 2 } ?: return@mapNotNull null
+        val id = parts[0].toLongOrNull() ?: return@mapNotNull null
+        val value = if (parts[1] == NONE) null else parts[1].toIntOrNull() ?: return@mapNotNull null
+        id to value
+    }.toMap()
+}
+
+private fun serializeReminderOverrides(map: Map<Long, Int?>): String =
+    map.entries.joinToString(ENTRY_SEP) { (id, minutes) -> "$id$KEY_VALUE_SEP${minutes ?: NONE}" }
+
 private inline fun <reified E : Enum<E>> String?.toEnum(default: E): E =
     this?.let { stored -> enumValues<E>().firstOrNull { it.name == stored } } ?: default

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

@@ -0,0 +1,124 @@
+package de.jeanlucmakiola.calendula.data.reminders
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+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
+
+/**
+ * Handles the "Snooze" and "Dismiss" actions on a reminder notification, plus
+ * the internal re-show when a snooze elapses. All three are app-internal
+ * intents (notification action buttons and our own [ReminderSnoozeScheduler]
+ * alarm), so the receiver is not exported.
+ *
+ * - **Dismiss** just cancels the notification — the `CalendarAlerts` row is
+ *   already fired, so nothing re-posts it.
+ * - **Snooze** cancels the notification and schedules an exact alarm to re-show
+ *   it after the user's snooze delay.
+ * - **Show** (the alarm) re-posts the same notification, so the user can snooze
+ *   or dismiss it again.
+ */
+@AndroidEntryPoint
+class ReminderActionReceiver : BroadcastReceiver() {
+
+    @Inject lateinit var notifier: ReminderNotifier
+    @Inject lateinit var scheduler: ReminderSnoozeScheduler
+    @Inject lateinit var settingsPrefs: SettingsPrefs
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val alert = alertFrom(intent) ?: return
+        when (intent.action) {
+            ACTION_DISMISS -> notifier.cancel(alert)
+
+            ACTION_SNOOZE -> {
+                // Cancel now so the notification doesn't linger until the alarm;
+                // the snooze delay read is the only async work.
+                notifier.cancel(alert)
+                val pendingResult = goAsync()
+                CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
+                    try {
+                        val minutes = settingsPrefs.snoozeMinutes.first()
+                        val triggerAt = System.currentTimeMillis() + minutes * 60_000L
+                        scheduler.schedule(alert, triggerAt)
+                    } finally {
+                        pendingResult.finish()
+                    }
+                }
+            }
+
+            ACTION_SHOW -> {
+                val pendingResult = goAsync()
+                CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
+                    try {
+                        if (settingsPrefs.remindersEnabled.first() && notifier.canPost()) {
+                            notifier.post(alert)
+                        }
+                    } finally {
+                        pendingResult.finish()
+                    }
+                }
+            }
+        }
+    }
+
+    companion object {
+        const val ACTION_SNOOZE = "de.jeanlucmakiola.calendula.reminders.SNOOZE"
+        const val ACTION_DISMISS = "de.jeanlucmakiola.calendula.reminders.DISMISS"
+        const val ACTION_SHOW = "de.jeanlucmakiola.calendula.reminders.SHOW"
+
+        private const val EXTRA_ALERT_ID = "alert_id"
+        private const val EXTRA_EVENT_ID = "event_id"
+        private const val EXTRA_BEGIN = "begin"
+        private const val EXTRA_END = "end"
+        private const val EXTRA_TITLE = "title"
+        private const val EXTRA_LOCATION = "location"
+        private const val EXTRA_ALL_DAY = "all_day"
+
+        /** An explicit intent to this receiver carrying [alert] as extras. */
+        fun intent(context: Context, action: String, alert: ReminderAlert): Intent =
+            Intent(context, ReminderActionReceiver::class.java).apply {
+                this.action = action
+                putExtra(EXTRA_ALERT_ID, alert.alertId)
+                putExtra(EXTRA_EVENT_ID, alert.eventId)
+                putExtra(EXTRA_BEGIN, alert.beginMillis)
+                putExtra(EXTRA_END, alert.endMillis)
+                putExtra(EXTRA_TITLE, alert.title)
+                putExtra(EXTRA_LOCATION, alert.location)
+                putExtra(EXTRA_ALL_DAY, alert.isAllDay)
+            }
+
+        /**
+         * A stable request code per (alert, action) so the three PendingIntents
+         * of one notification stay distinct and don't clobber each other.
+         */
+        fun requestCode(alert: ReminderAlert, action: String): Int {
+            val actionOffset = when (action) {
+                ACTION_SNOOZE -> 1
+                ACTION_DISMISS -> 2
+                ACTION_SHOW -> 3
+                else -> 0
+            }
+            return alert.alertId.toInt() * 8 + actionOffset
+        }
+
+        private fun alertFrom(intent: Intent): ReminderAlert? {
+            if (!intent.hasExtra(EXTRA_ALERT_ID)) return null
+            return ReminderAlert(
+                alertId = intent.getLongExtra(EXTRA_ALERT_ID, 0L),
+                eventId = intent.getLongExtra(EXTRA_EVENT_ID, 0L),
+                beginMillis = intent.getLongExtra(EXTRA_BEGIN, 0L),
+                endMillis = intent.getLongExtra(EXTRA_END, 0L),
+                title = intent.getStringExtra(EXTRA_TITLE).orEmpty(),
+                location = intent.getStringExtra(EXTRA_LOCATION),
+                isAllDay = intent.getBooleanExtra(EXTRA_ALL_DAY, false),
+            )
+        }
+    }
+}

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

@@ -61,6 +61,16 @@ class ReminderNotifier @Inject constructor(
             .setAutoCancel(true)
             .setOnlyAlertOnce(true)
             .setContentIntent(detailIntent(alert))
+            .addAction(
+                R.drawable.ic_notification_snooze,
+                context.getString(R.string.reminder_action_snooze),
+                actionIntent(alert, ReminderActionReceiver.ACTION_SNOOZE),
+            )
+            .addAction(
+                R.drawable.ic_notification_dismiss,
+                context.getString(R.string.reminder_action_dismiss),
+                actionIntent(alert, ReminderActionReceiver.ACTION_DISMISS),
+            )
             .build()
         try {
             NotificationManagerCompat.from(context)
@@ -71,6 +81,19 @@ class ReminderNotifier @Inject constructor(
         }
     }
 
+    /** Remove a posted reminder (snooze re-shows it later; dismiss is final). */
+    fun cancel(alert: ReminderAlert) {
+        NotificationManagerCompat.from(context).cancel(alert.alertId.toString(), NOTIFICATION_ID)
+    }
+
+    private fun actionIntent(alert: ReminderAlert, action: String): PendingIntent =
+        PendingIntent.getBroadcast(
+            context,
+            ReminderActionReceiver.requestCode(alert, action),
+            ReminderActionReceiver.intent(context, action, alert),
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+
     private fun detailIntent(alert: ReminderAlert): PendingIntent = PendingIntent.getActivity(
         context,
         /* requestCode = */ alert.alertId.toInt(),

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

@@ -0,0 +1,55 @@
+package de.jeanlucmakiola.calendula.data.reminders
+
+import android.app.AlarmManager
+import android.app.PendingIntent
+import android.content.Context
+import android.os.Build
+import androidx.core.content.getSystemService
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Schedules a one-off exact alarm that re-shows a snoozed reminder.
+ *
+ * The app otherwise relies entirely on the calendar provider's `EVENT_REMINDER`
+ * broadcast (the Etar model), but a snoozed reminder has no provider backing —
+ * its `CalendarAlerts` row is already fired — so we must re-fire it ourselves.
+ * A snooze that lands late is a broken snooze, hence an *exact* alarm; we fall
+ * back to an inexact allow-while-idle alarm only if the OS withholds the
+ * exact-alarm capability (API 31–32 where the user revoked it).
+ */
+@Singleton
+class ReminderSnoozeScheduler @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+
+    fun schedule(alert: ReminderAlert, triggerAtMillis: Long) {
+        val alarmManager = context.getSystemService<AlarmManager>() ?: return
+        val pendingIntent = PendingIntent.getBroadcast(
+            context,
+            ReminderActionReceiver.requestCode(alert, ReminderActionReceiver.ACTION_SHOW),
+            ReminderActionReceiver.intent(context, ReminderActionReceiver.ACTION_SHOW, alert),
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+        if (canScheduleExact(alarmManager)) {
+            alarmManager.setExactAndAllowWhileIdle(
+                AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
+            )
+        } else {
+            // Exact alarms revoked (API 31–32): an inexact wake is the honest
+            // best we can do without nagging for SCHEDULE_EXACT_ALARM.
+            alarmManager.setAndAllowWhileIdle(
+                AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
+            )
+        }
+    }
+
+    /**
+     * True on API < 31 (no restriction), and on 31+ when the exact-alarm
+     * capability is held — auto-granted via `USE_EXACT_ALARM` on API 33+
+     * (Calendula is a calendar app), user-revocable on 31–32.
+     */
+    private fun canScheduleExact(alarmManager: AlarmManager): Boolean =
+        Build.VERSION.SDK_INT < Build.VERSION_CODES.S || alarmManager.canScheduleExactAlarms()
+}

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

@@ -41,6 +41,27 @@ data class EventForm(
      */
     val colorKey: String? = null,
     val color: Int? = null,
+    /**
+     * Guests the user has added/kept on the event. Calendula only writes these
+     * `Attendees` rows — it has no INTERNET and never sends an invitation
+     * itself; whether a guest is notified is decided downstream by the
+     * calendar's backend (local: no one; CalDAV/Google: the server/account).
+     * Read-only rows the form doesn't model (the organizer, resources) are
+     * preserved by the data layer, not carried here.
+     */
+    val attendees: List<EventAttendee> = emptyList(),
+)
+
+/**
+ * One editable guest: the user controls the [email] (the identity we dedup and
+ * write on), an optional display [name], and whether they're [optional] rather
+ * than required. Response status and the organizer/resource distinction are not
+ * user-editable, so they aren't modelled here.
+ */
+data class EventAttendee(
+    val email: String,
+    val name: String = "",
+    val optional: Boolean = false,
 )
 
 /**
@@ -55,6 +76,7 @@ enum class EventFormField {
     Availability,
     Visibility,
     Color,
+    Attendees,
 }
 
 enum class EventFormProblem {
@@ -108,6 +130,24 @@ fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone):
         // calendar's colour.
         colorKey = eventColorKey,
         color = eventColor,
+        // Only editable guests ride in the form: drop the organizer and
+        // resource rows (not user-editable) and any without an email (we key
+        // edits and dedup on the address). The data layer preserves the rows we
+        // don't carry here, so they're never clobbered on save.
+        attendees = attendees
+            .filter {
+                it.relationship != AttendeeRelationship.Organizer &&
+                    it.type != AttendeeType.Resource
+            }
+            .mapNotNull { a ->
+                a.email?.takeIf { it.isNotBlank() }?.let { email ->
+                    EventAttendee(
+                        email = email,
+                        name = a.name,
+                        optional = a.type == AttendeeType.Optional,
+                    )
+                }
+            },
     )
 }
 
@@ -117,9 +157,10 @@ fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone):
  * 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
+ * event. Guests are covered (the form writes editable attendees), so an
- * write can't clobber them): attendees, status, the user's own response,
+ * external attendee change now also trips the conflict check. Still not
- * reminder methods, and a recurring event's duration.
+ * covered: status, the user's own response, reminder methods, the
+ * organizer/resource rows, and a recurring event's duration.
  */
 data class EditSnapshot(
     val form: EventForm,
@@ -148,6 +189,7 @@ fun EventForm.populatedFields(): Set<EventFormField> = buildSet {
     if (availability != Availability.Busy) add(EventFormField.Availability)
     if (accessLevel != AccessLevel.Default) add(EventFormField.Visibility)
     if (colorKey != null || color != null) add(EventFormField.Color)
+    if (attendees.isNotEmpty()) add(EventFormField.Attendees)
 }
 
 fun EventForm.problems(): Set<EventFormProblem> = buildSet {

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

@@ -0,0 +1,29 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import de.jeanlucmakiola.calendula.domain.EventDetail
+
+/**
+ * Build the [IcsEvent] for sharing a single event. We export the event the user
+ * is looking at as a **one-off** VEVENT (no RRULE): the detail screen shows one
+ * occurrence, so "share this event" should hand off exactly that instance, not
+ * a whole series anchored to a possibly-different DTSTART. Reminders are the
+ * already-decoded semantic lead times the detail screen holds.
+ */
+fun EventDetail.toShareIcsEvent(): IcsEvent {
+    val startMillis = instance.start.toEpochMilliseconds()
+    return IcsEvent(
+        uid = deriveIcsUid(existingUid = null, eventId = instance.eventId, dtStartMillis = startMillis),
+        summary = instance.title,
+        start = instance.start,
+        end = instance.end,
+        isAllDay = instance.isAllDay,
+        zoneId = eventTimezone?.takeIf { it.isNotBlank() } ?: "UTC",
+        recurrenceRule = null,
+        location = instance.location,
+        description = description,
+        reminderMinutes = reminders.map { it.minutes },
+        status = status,
+        availability = availability,
+        calendarName = null,
+    )
+}

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

@@ -0,0 +1,40 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+// Android's calendar provider (and Calendula's own writes) use the non-standard
+// single-unit forms P<n>S / P<n>D / P<n>W — seconds without the RFC-required
+// leading T. Matched first; anything else falls through to the general grammar.
+private val DURATION_SINGLE_UNIT = Regex("""([+-]?)P(\d+)([WDS])""")
+private val DURATION_GENERAL =
+    Regex("""([+-]?)P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?""")
+
+/**
+ * Milliseconds of a DURATION (`P1D`, `P3600S`, `PT1H30M`, `-PT15M`, `P1W`, …),
+ * sign-aware. Calendula writes `P<days>D` / `P<seconds>S`, but the parser also
+ * accepts the general RFC 5545 grammar so backup `DURATION` rows and foreign
+ * `VALARM` triggers round-trip. Unparseable input is treated as zero.
+ */
+fun parseRfc2445DurationMillis(duration: String?): Long {
+    if (duration.isNullOrBlank()) return 0L
+    val s = duration.trim()
+
+    DURATION_SINGLE_UNIT.matchEntire(s)?.let { m ->
+        val unitSeconds = when (m.groupValues[3]) {
+            "W" -> 7L * 24 * 60 * 60
+            "D" -> 24L * 60 * 60
+            else -> 1L // S
+        }
+        return m.signum() * m.groupValues[2].toLong() * unitSeconds * 1_000L
+    }
+
+    val m = DURATION_GENERAL.matchEntire(s) ?: return 0L
+    val weeks = m.groupValues[2].toLongOrNull() ?: 0L
+    val days = m.groupValues[3].toLongOrNull() ?: 0L
+    val hours = m.groupValues[4].toLongOrNull() ?: 0L
+    val minutes = m.groupValues[5].toLongOrNull() ?: 0L
+    val seconds = m.groupValues[6].toLongOrNull() ?: 0L
+    val totalSeconds = ((((weeks * 7 + days) * 24 + hours) * 60 + minutes) * 60 + seconds)
+    return m.signum() * totalSeconds * 1_000L
+}
+
+/** Sign carried by group 1 (`-` → -1, otherwise +1) of a duration match. */
+private fun MatchResult.signum(): Long = if (groupValues[1] == "-") -1L else 1L

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

@@ -0,0 +1,43 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import kotlin.time.Instant
+
+/**
+ * A single event ready to be serialised to a `VEVENT`, decoupled from the
+ * provider so [IcsWriter] stays pure-Kotlin and JVM-testable. [start]/[end] are
+ * absolute instants; [isAllDay] and [recurrenceRule] decide how they are
+ * rendered (see [IcsWriter]'s timezone rule).
+ */
+data class IcsEvent(
+    /** RFC 5545 UID — globally stable across exports (see [deriveIcsUid]). */
+    val uid: String,
+    val summary: String,
+    val start: Instant,
+    /** Exclusive end (for all-day: the next-day midnight, as the provider stores it). */
+    val end: Instant,
+    val isAllDay: Boolean,
+    /** IANA zone id (`Events.EVENT_TIMEZONE`); only used for recurring timed events. */
+    val zoneId: String,
+    /** Bare RRULE value (no `RRULE:` prefix), or null for a one-off event. */
+    val recurrenceRule: String? = null,
+    val location: String? = null,
+    val description: String? = null,
+    /** Reminder lead times in minutes before start (raw provider offsets). */
+    val reminderMinutes: List<Int> = emptyList(),
+    val status: EventStatus = EventStatus.Confirmed,
+    val availability: Availability = Availability.Busy,
+    /** Source calendar name, emitted as `X-CALENDULA-CALENDAR` so a combined backup can fan back out. */
+    val calendarName: String? = null,
+)
+
+/**
+ * The UID to export for a provider event. A row that already carries a UID
+ * (`Events.UID_2445`) keeps it; otherwise we synthesise a **stable** one from
+ * the event id and its DTSTART so the same legacy event yields the same UID
+ * across repeated backups — which keeps a later restore from duplicating it.
+ */
+fun deriveIcsUid(existingUid: String?, eventId: Long, dtStartMillis: Long): String =
+    existingUid?.trim()?.takeIf { it.isNotEmpty() }
+        ?: "$eventId-$dtStartMillis@calendula"

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

@@ -0,0 +1,259 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.toInstant
+import kotlin.time.Instant
+
+/**
+ * A `VEVENT` parsed from an `.ics` file — the read-side mirror of [IcsEvent],
+ * but [uid] is nullable (an incoming event may carry none; the insert layer
+ * then assigns one). Times are absolute instants; [isAllDay]/[zoneId] mirror
+ * how the writer encoded them.
+ */
+data class ParsedIcsEvent(
+    val uid: String?,
+    val summary: String,
+    val start: Instant,
+    val end: Instant,
+    val isAllDay: Boolean,
+    val zoneId: String,
+    val recurrenceRule: String? = null,
+    val location: String? = null,
+    val description: String? = null,
+    val reminderMinutes: List<Int> = emptyList(),
+    val status: EventStatus = EventStatus.Confirmed,
+    val availability: Availability = Availability.Busy,
+    val calendarName: String? = null,
+)
+
+/** Things the parser dropped rather than failing — surfaced in the import report. */
+enum class IcsParseWarning {
+    /** A `RECURRENCE-ID` override occurrence (not modelled; only masters import). */
+    ModifiedOccurrenceSkipped,
+
+    /** A `VEVENT` with no parseable `DTSTART`. */
+    EventWithoutStartSkipped,
+
+    /** `ATTENDEE` rows were present; Calendula doesn't import attendees. */
+    AttendeesIgnored,
+
+    /** A `TZID` couldn't be resolved against the device tz database (used local zone). */
+    UnknownTimezone,
+}
+
+data class IcsParseResult(
+    val events: List<ParsedIcsEvent>,
+    val warnings: Set<IcsParseWarning>,
+)
+
+/** Outcome of a bulk `.ics` import into one calendar. */
+data class IcsImportSummary(val imported: Int, val skippedDuplicate: Int)
+
+/**
+ * Hand-rolled RFC 5545 reader, the inverse of [IcsWriter]. Pure and
+ * JVM-testable. Liberal-in/strict-out: unknown properties are ignored, a single
+ * malformed `VEVENT` is skipped (not fatal), and unsupported constructs
+ * (`RECURRENCE-ID`, attendees, unresolved `TZID`) are reported as [warnings]
+ * rather than silently dropped. `VTIMEZONE` blocks are skipped — a `TZID` is
+ * resolved against the OS tz database instead ([deviceZone] is the fallback).
+ */
+class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault()) {
+
+    fun parse(text: String): IcsParseResult {
+        val lines = unfoldLines(text)
+        val events = mutableListOf<ParsedIcsEvent>()
+        val warnings = mutableSetOf<IcsParseWarning>()
+        var calendarName: String? = null
+
+        var i = 0
+        while (i < lines.size) {
+            val line = parseContentLine(lines[i])
+            if (line == null) { i++; continue }
+            when {
+                line.isBegin("VEVENT") -> {
+                    val end = indexOfEnd(lines, i + 1, "VEVENT")
+                    parseVevent(lines.subList(i + 1, end), calendarName, warnings)
+                        ?.let(events::add)
+                    i = end + 1
+                }
+                line.isBegin("VTIMEZONE") -> {
+                    // Skipped wholesale; TZIDs resolve against the OS tz database.
+                    i = indexOfEnd(lines, i + 1, "VTIMEZONE") + 1
+                }
+                line.name == "X-WR-CALNAME" -> {
+                    calendarName = unescapeText(line.value).trim().ifEmpty { null }
+                    i++
+                }
+                else -> i++
+            }
+        }
+        return IcsParseResult(events, warnings)
+    }
+
+    private fun parseVevent(
+        body: List<String>,
+        fileCalendarName: String?,
+        warnings: MutableSet<IcsParseWarning>,
+    ): ParsedIcsEvent? {
+        var uid: String? = null
+        var summary = ""
+        var dtStart: IcsDateTime? = null
+        var dtEnd: IcsDateTime? = null
+        var duration: String? = null
+        var rrule: String? = null
+        var location: String? = null
+        var description: String? = null
+        var status = EventStatus.Confirmed
+        var availability = Availability.Busy
+        var calendarName = fileCalendarName
+        val reminders = mutableListOf<Int>()
+        var skipAsOverride = false
+
+        var i = 0
+        while (i < body.size) {
+            val line = parseContentLine(body[i])
+            if (line == null) { i++; continue }
+            when (line.name) {
+                "BEGIN" -> if (line.value.trim().equals("VALARM", true)) {
+                    val end = indexOfEnd(body, i + 1, "VALARM")
+                    parseAlarmMinutes(body.subList(i + 1, end))?.let(reminders::add)
+                    i = end + 1
+                    continue
+                }
+                "UID" -> uid = line.value.trim().ifEmpty { null }
+                "SUMMARY" -> summary = unescapeText(line.value)
+                "DTSTART" -> dtStart = parseIcsDateTime(line, warnings)
+                "DTEND" -> dtEnd = parseIcsDateTime(line, warnings)
+                "DURATION" -> duration = line.value.trim()
+                "RRULE" -> rrule = line.value.trim().ifEmpty { null }
+                "LOCATION" -> location = unescapeText(line.value).ifEmpty { null }
+                "DESCRIPTION" -> description = unescapeText(line.value).ifEmpty { null }
+                "STATUS" -> status = mapIcsStatus(line.value)
+                "TRANSP" -> availability =
+                    if (line.value.trim().equals("TRANSPARENT", true)) Availability.Free
+                    else Availability.Busy
+                "RECURRENCE-ID" -> skipAsOverride = true
+                "ATTENDEE" -> warnings.add(IcsParseWarning.AttendeesIgnored)
+                "X-CALENDULA-CALENDAR" ->
+                    calendarName = unescapeText(line.value).trim().ifEmpty { calendarName }
+            }
+            i++
+        }
+
+        if (skipAsOverride) {
+            warnings.add(IcsParseWarning.ModifiedOccurrenceSkipped)
+            return null
+        }
+        val start = dtStart ?: run {
+            warnings.add(IcsParseWarning.EventWithoutStartSkipped)
+            return null
+        }
+        val end = dtEnd
+            ?: duration?.let {
+                start.copy(
+                    instant = Instant.fromEpochMilliseconds(
+                        start.instant.toEpochMilliseconds() + parseRfc2445DurationMillis(it),
+                    ),
+                )
+            }
+            ?: start
+        return ParsedIcsEvent(
+            uid = uid,
+            summary = summary,
+            start = start.instant,
+            end = end.instant,
+            isAllDay = start.isAllDay,
+            zoneId = start.zoneId,
+            recurrenceRule = rrule,
+            location = location,
+            description = description,
+            reminderMinutes = reminders.distinct(),
+            status = status,
+            availability = availability,
+            calendarName = calendarName,
+        )
+    }
+
+    /** A VALARM's lead time in minutes before start, or null if not a usable relative trigger. */
+    private fun parseAlarmMinutes(body: List<String>): Int? {
+        val trigger = body.asSequence()
+            .mapNotNull { parseContentLine(it) }
+            .firstOrNull { it.name == "TRIGGER" }
+            ?: return null
+        // Absolute (DATE-TIME) triggers can't be expressed as a lead time.
+        if (trigger.params["VALUE"].equals("DATE-TIME", true)) return null
+        val millis = parseRfc2445DurationMillis(trigger.value)
+        // Negative = before start (the normal case) → positive lead minutes.
+        return (-millis / 60_000L).toInt().coerceAtLeast(0)
+    }
+
+    private fun parseIcsDateTime(line: IcsContentLine, warnings: MutableSet<IcsParseWarning>): IcsDateTime? {
+        val raw = line.value.trim()
+        val isDate = line.params["VALUE"].equals("DATE", true) ||
+            (raw.length == 8 && !raw.contains('T'))
+        if (isDate) {
+            val date = parseBasicDate(raw) ?: return null
+            return IcsDateTime(date.atStartOfDayIn(TimeZone.UTC), isAllDay = true, zoneId = "UTC")
+        }
+        val isUtc = raw.endsWith("Z")
+        val ldt = parseBasicDateTime(raw.removeSuffix("Z")) ?: return null
+        if (isUtc) return IcsDateTime(ldt.toInstant(TimeZone.UTC), isAllDay = false, zoneId = "UTC")
+
+        val tzid = line.params["TZID"]
+        val resolved = tzid?.let { id -> runCatching { TimeZone.of(id) }.getOrNull()?.let { id to it } }
+        if (tzid != null && resolved == null) warnings.add(IcsParseWarning.UnknownTimezone)
+        val (zoneId, zone) = resolved ?: (deviceZone.id to deviceZone)
+        return IcsDateTime(ldt.toInstant(zone), isAllDay = false, zoneId = zoneId)
+    }
+
+    private data class IcsDateTime(val instant: Instant, val isAllDay: Boolean, val zoneId: String)
+
+    private companion object {
+        fun IcsContentLine.isBegin(component: String) =
+            name == "BEGIN" && value.trim().equals(component, true)
+
+        /** Index of the matching `END:<component>` at/after [from], or list end. */
+        fun indexOfEnd(lines: List<String>, from: Int, component: String): Int {
+            var i = from
+            while (i < lines.size) {
+                val line = parseContentLine(lines[i])
+                if (line != null && line.name == "END" &&
+                    line.value.trim().equals(component, true)
+                ) {
+                    return i
+                }
+                i++
+            }
+            return lines.size
+        }
+
+        fun mapIcsStatus(value: String): EventStatus = when (value.trim().uppercase()) {
+            "TENTATIVE" -> EventStatus.Tentative
+            "CANCELLED" -> EventStatus.Cancelled
+            else -> EventStatus.Confirmed
+        }
+
+        fun parseBasicDate(s: String): LocalDate? = runCatching {
+            LocalDate(s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt())
+        }.getOrNull()
+
+        fun parseBasicDateTime(s: String): LocalDateTime? = runCatching {
+            val date = LocalDate(
+                s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt(),
+            )
+            // Format is YYYYMMDD 'T' HHMMSS; seconds optional.
+            val time = LocalTime(
+                s.substring(9, 11).toInt(),
+                s.substring(11, 13).toInt(),
+                if (s.length >= 15) s.substring(13, 15).toInt() else 0,
+            )
+            LocalDateTime(date, time)
+        }.getOrNull()
+    }
+}

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

@@ -0,0 +1,155 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+/**
+ * Low-level RFC 5545 text mechanics, kept separate from [IcsWriter] so the
+ * escaping and folding rules can be tested in isolation. Pure Kotlin — no
+ * Android, no time handling.
+ */
+
+/** iCalendar mandates CRLF line breaks, not the platform separator. */
+const val ICS_CRLF: String = "\r\n"
+
+/** RFC 5545 §3.1: content lines SHOULD be folded at 75 octets (excluding the break). */
+private const val MAX_OCTETS = 75
+
+/**
+ * Escape a TEXT value (SUMMARY, DESCRIPTION, LOCATION, …) per RFC 5545 §3.3.11:
+ * backslash, semicolon and comma are escaped, newlines become the literal `\n`.
+ * Backslash is handled first so it doesn't double-escape the others' markers.
+ */
+fun escapeText(value: String): String = buildString(value.length) {
+    for (ch in value) {
+        when (ch) {
+            '\\' -> append("\\\\")
+            ';' -> append("\\;")
+            ',' -> append("\\,")
+            '\n' -> append("\\n")
+            '\r' -> Unit // CR is dropped; a lone CRLF in source text folds to one \n
+            else -> append(ch)
+        }
+    }
+}
+
+/**
+ * Fold a single content line to ≤75 octets per physical line, inserting
+ * `CRLF + space` between segments (the space is part of the 75-octet budget of
+ * the continuation line, so its content caps at 74). Folding counts UTF-8
+ * octets, never splitting a multi-byte character across a boundary.
+ */
+fun foldLine(line: String): String {
+    if (line.toByteArray(Charsets.UTF_8).size <= MAX_OCTETS) return line
+    val out = StringBuilder()
+    var octetsThisLine = 0
+    var first = true
+    var i = 0
+    while (i < line.length) {
+        val cp = line.codePointAt(i)
+        val width = Character.charCount(cp)
+        val piece = line.substring(i, i + width)
+        val pieceOctets = piece.toByteArray(Charsets.UTF_8).size
+        // Continuation lines spend one octet on the leading space.
+        val budget = if (first) MAX_OCTETS else MAX_OCTETS - 1
+        if (octetsThisLine + pieceOctets > budget) {
+            out.append(ICS_CRLF).append(' ')
+            octetsThisLine = 0
+            first = false
+        }
+        out.append(piece)
+        octetsThisLine += pieceOctets
+        i += width
+    }
+    return out.toString()
+}
+
+/**
+ * Reverse of [escapeText]: turn `\n`/`\N` into newlines and unescape `\\`, `\;`,
+ * `\,`. A backslash before any other character is dropped, keeping the
+ * character (lenient — foreign files escape liberally).
+ */
+fun unescapeText(value: String): String = buildString(value.length) {
+    var i = 0
+    while (i < value.length) {
+        val c = value[i]
+        if (c == '\\' && i + 1 < value.length) {
+            when (val next = value[i + 1]) {
+                'n', 'N' -> append('\n')
+                else -> append(next) // \\, \;, \, and any other escaped char
+            }
+            i += 2
+        } else {
+            append(c)
+            i++
+        }
+    }
+}
+
+/**
+ * Reverse of [foldLine] across a whole document: split into physical lines on
+ * CRLF/LF/CR, then re-join any line that begins with a single space or tab onto
+ * the previous one (RFC 5545 unfolding). Returns the logical content lines.
+ */
+fun unfoldLines(text: String): List<String> {
+    val out = mutableListOf<String>()
+    for (physical in text.split("\r\n", "\n", "\r")) {
+        if (physical.isEmpty()) continue
+        val isContinuation = physical[0] == ' ' || physical[0] == '\t'
+        if (isContinuation && out.isNotEmpty()) {
+            out[out.lastIndex] = out.last() + physical.substring(1)
+        } else {
+            out.add(physical)
+        }
+    }
+    return out
+}
+
+/**
+ * One unfolded content line split into its property name, parameters and value:
+ * `SUMMARY;LANGUAGE=en:Lunch` → name `SUMMARY`, params `{LANGUAGE=en}`, value
+ * `Lunch`. The value is everything after the first colon that isn't inside a
+ * quoted parameter; param keys are upper-cased, quoted param values unquoted.
+ * Returns null for a line with no colon.
+ */
+data class IcsContentLine(val name: String, val params: Map<String, String>, val value: String)
+
+fun parseContentLine(line: String): IcsContentLine? {
+    var inQuote = false
+    var colon = -1
+    for (i in line.indices) {
+        when (line[i]) {
+            '"' -> inQuote = !inQuote
+            ':' -> if (!inQuote) { colon = i; break }
+        }
+    }
+    if (colon < 0) return null
+    val head = splitUnquoted(line.substring(0, colon), ';')
+    val name = head.firstOrNull()?.trim()?.uppercase().orEmpty()
+    if (name.isEmpty()) return null
+    val params = buildMap {
+        for (part in head.drop(1)) {
+            val eq = part.indexOf('=')
+            if (eq > 0) {
+                put(
+                    part.substring(0, eq).trim().uppercase(),
+                    part.substring(eq + 1).trim().removeSurrounding("\""),
+                )
+            }
+        }
+    }
+    return IcsContentLine(name, params, line.substring(colon + 1))
+}
+
+/** Split on [delimiter] except where it falls inside a double-quoted run. */
+private fun splitUnquoted(text: String, delimiter: Char): List<String> {
+    val parts = mutableListOf<String>()
+    val current = StringBuilder()
+    var inQuote = false
+    for (c in text) {
+        when {
+            c == '"' -> { inQuote = !inQuote; current.append(c) }
+            c == delimiter && !inQuote -> { parts.add(current.toString()); current.clear() }
+            else -> current.append(c)
+        }
+    }
+    parts.add(current.toString())
+    return parts
+}

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

@@ -0,0 +1,124 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.number
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
+
+/** Default `PRODID` advertising the writer that produced the file. */
+const val ICS_PROD_ID: String = "-//Jean-Luc Makiola//Calendula//EN"
+
+/**
+ * Hand-rolled RFC 5545 serialiser for the subset Calendula models. No iCal
+ * library: we stay on `kotlinx-datetime` and own the output, exactly as
+ * `domain/Recurrence.kt` owns RRULE. Pure and JVM-testable — the caller
+ * supplies [dtStamp] (the export moment) so the writer never reads a clock.
+ *
+ * Timezone rule (see plan 05, decision 1):
+ *  - all-day      → `VALUE=DATE`, no zone;
+ *  - timed one-off → UTC instant with a `Z` suffix (an instant is an instant);
+ *  - timed recurring → `TZID`-labelled local wall time, so the series stays
+ *    anchored to wall-clock across DST. No `VTIMEZONE` block is emitted; import
+ *    resolves the `TZID` against the OS tz database.
+ */
+class IcsWriter(private val prodId: String = ICS_PROD_ID) {
+
+    fun writeCalendar(events: List<IcsEvent>, dtStamp: Instant): String {
+        val lines = buildList {
+            add("BEGIN:VCALENDAR")
+            add("VERSION:2.0")
+            add("PRODID:$prodId")
+            add("CALSCALE:GREGORIAN")
+            events.forEach { appendEvent(it, dtStamp) }
+            add("END:VCALENDAR")
+        }
+        return lines.joinToString(ICS_CRLF, postfix = ICS_CRLF) { foldLine(it) }
+    }
+
+    private fun MutableList<String>.appendEvent(event: IcsEvent, dtStamp: Instant) {
+        add("BEGIN:VEVENT")
+        add("UID:${event.uid}")
+        add("DTSTAMP:${utcStamp(dtStamp)}")
+        add("SUMMARY:${escapeText(event.summary)}")
+        appendTimes(event)
+        event.recurrenceRule?.takeIf { it.isNotBlank() }
+            ?.let { add("RRULE:${it.removePrefix("RRULE:")}") }
+        event.location?.takeIf { it.isNotBlank() }
+            ?.let { add("LOCATION:${escapeText(it)}") }
+        event.description?.takeIf { it.isNotBlank() }
+            ?.let { add("DESCRIPTION:${escapeText(it)}") }
+        add("STATUS:${statusValue(event.status)}")
+        add("TRANSP:${transpValue(event.availability)}")
+        event.calendarName?.takeIf { it.isNotBlank() }
+            ?.let { add("X-CALENDULA-CALENDAR:${escapeText(it)}") }
+        event.reminderMinutes.filter { it >= 0 }.distinct().forEach { minutes ->
+            appendAlarm(minutes, event.summary)
+        }
+        add("END:VEVENT")
+    }
+
+    private fun MutableList<String>.appendTimes(event: IcsEvent) = when {
+        event.isAllDay -> {
+            add("DTSTART;VALUE=DATE:${utcDate(event.start)}")
+            add("DTEND;VALUE=DATE:${utcDate(event.end)}")
+        }
+        // Recurring: anchor to wall-clock in the event's own zone.
+        event.recurrenceRule?.isNotBlank() == true -> {
+            val zone = runCatching { TimeZone.of(event.zoneId) }.getOrNull()
+            if (zone != null) {
+                add("DTSTART;TZID=${event.zoneId}:${localStamp(event.start, zone)}")
+                add("DTEND;TZID=${event.zoneId}:${localStamp(event.end, zone)}")
+            } else {
+                // Unknown zone id → fall back to plain UTC instants.
+                add("DTSTART:${utcStamp(event.start)}")
+                add("DTEND:${utcStamp(event.end)}")
+            }
+        }
+        else -> {
+            add("DTSTART:${utcStamp(event.start)}")
+            add("DTEND:${utcStamp(event.end)}")
+        }
+    }
+
+    private fun MutableList<String>.appendAlarm(minutes: Int, summary: String) {
+        add("BEGIN:VALARM")
+        add("ACTION:DISPLAY")
+        add("DESCRIPTION:${escapeText(summary.ifBlank { "Reminder" })}")
+        add("TRIGGER:${triggerValue(minutes)}")
+        add("END:VALARM")
+    }
+
+    private companion object {
+        fun statusValue(status: EventStatus): String = when (status) {
+            EventStatus.Confirmed -> "CONFIRMED"
+            EventStatus.Tentative -> "TENTATIVE"
+            EventStatus.Cancelled -> "CANCELLED"
+        }
+
+        // iCal TRANSP is binary; only an explicitly free event is TRANSPARENT.
+        fun transpValue(availability: Availability): String =
+            if (availability == Availability.Free) "TRANSPARENT" else "OPAQUE"
+
+        // A lead time of 0 fires at start (PT0M); anything positive is "before".
+        fun triggerValue(minutes: Int): String =
+            if (minutes <= 0) "PT0M" else "-PT${minutes}M"
+
+        fun utcStamp(instant: Instant): String =
+            basic(instant.toLocalDateTime(TimeZone.UTC)) + "Z"
+
+        fun localStamp(instant: Instant, zone: TimeZone): String =
+            basic(instant.toLocalDateTime(zone))
+
+        fun utcDate(instant: Instant): String {
+            val dt = instant.toLocalDateTime(TimeZone.UTC)
+            return "%04d%02d%02d".format(dt.year, dt.month.number, dt.day)
+        }
+
+        fun basic(dt: LocalDateTime): String = "%04d%02d%02dT%02d%02d%02d".format(
+            dt.year, dt.month.number, dt.day, dt.hour, dt.minute, dt.second,
+        )
+    }
+}

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

@@ -0,0 +1,38 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import de.jeanlucmakiola.calendula.domain.EventForm
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+
+/**
+ * Prefill the create form from a single parsed `.ics` event (the "open one
+ * event" path). [calendarId] is left null so the form preselects the last-used
+ * calendar, exactly like a fresh create — the user confirms the target and
+ * reviews everything before saving. Mirrors `EventDetail.toEditForm`'s all-day
+ * handling (provider all-day times are UTC midnights with an exclusive end).
+ */
+fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
+    val (start, end) = if (isAllDay) {
+        val startDate = this.start.toLocalDateTime(TimeZone.UTC).date
+        val endExclusive = this.end.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 {
+        this.start.toLocalDateTime(zone) to this.end.toLocalDateTime(zone)
+    }
+    return EventForm(
+        calendarId = null,
+        title = summary,
+        isAllDay = isAllDay,
+        start = start,
+        end = end,
+        location = location.orEmpty(),
+        description = description.orEmpty(),
+        reminders = reminderMinutes.distinct().sorted(),
+        availability = availability,
+        rrule = recurrenceRule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
+    )
+}

app/src/main/java/de/jeanlucmakiola/calendula/qs/NewEventTileService.kt

@@ -0,0 +1,43 @@
+package de.jeanlucmakiola.calendula.qs
+
+import android.app.PendingIntent
+import android.os.Build
+import android.service.quicksettings.TileService
+import de.jeanlucmakiola.calendula.MainActivity
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+
+/**
+ * Quick Settings tile: tapping it opens the create-event form on today — the
+ * same action as the launcher "New event" shortcut and the agenda widget's "+".
+ * A stateless action tile, so there is no on/off state to keep in sync.
+ */
+class NewEventTileService : TileService() {
+
+    // The pre-34 branch intentionally uses the deprecated Intent overload: it is
+    // the only form available below UpsideDownCake, and is reached only there.
+    @Suppress("DEPRECATION", "StartActivityAndCollapseDeprecated")
+    override fun onClick() {
+        super.onClick()
+        val today = Clock.System.now()
+            .toLocalDateTime(TimeZone.currentSystemDefault()).date
+        val intent = MainActivity.openCreateIntent(this, today)
+        // Launch only once the device is unlocked: creating an event behind the
+        // keyguard makes no sense, and the shade can't start an activity over a
+        // locked screen anyway.
+        unlockAndRun {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                val pending = PendingIntent.getActivity(
+                    this,
+                    0,
+                    intent,
+                    PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
+                )
+                startActivityAndCollapse(pending)
+            } else {
+                startActivityAndCollapse(intent)
+            }
+        }
+    }
+}

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

@@ -15,6 +15,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
+import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaScreen
 import de.jeanlucmakiola.calendula.ui.calendars.CalendarsScreen
@@ -23,7 +24,9 @@ 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.imports.ImportScreen
 import de.jeanlucmakiola.calendula.ui.month.MonthScreen
+import de.jeanlucmakiola.calendula.ui.search.SearchScreen
 import de.jeanlucmakiola.calendula.ui.settings.SettingsScreen
 import de.jeanlucmakiola.calendula.ui.week.WeekScreen
 import kotlinx.datetime.LocalDate
@@ -48,6 +51,8 @@ fun CalendarHost(
     onDetailKeyConsumed: () -> Unit = {},
     widgetNavRequest: WidgetNavRequest? = null,
     onWidgetNavConsumed: () -> Unit = {},
+    requestedImportUri: android.net.Uri? = null,
+    onImportConsumed: () -> Unit = {},
 ) {
     var view by rememberSaveable { mutableStateOf(CalendarView.Week) }
     val onSelectView: (CalendarView) -> Unit = { view = it }
@@ -93,6 +98,12 @@ fun CalendarHost(
     var showSettings by rememberSaveable { mutableStateOf(false) }
     val onOpenSettings = { showSettings = true }
 
+    // Full-text search — its own overlay, opened from each calendar screen's
+    // top bar. Sits below the detail/edit overlays so tapping a result reveals
+    // the detail on top and backing out returns to the results.
+    var showSearch by rememberSaveable { mutableStateOf(false) }
+    val onOpenSearch = { showSearch = true }
+
     // Calendar manager (reached from Settings) — its own overlay so it slides
     // over Settings and survives view switches.
     var showCalendars by rememberSaveable { mutableStateOf(false) }
@@ -121,16 +132,49 @@ fun CalendarHost(
     var editKey by rememberSaveable { mutableStateOf<LongArray?>(null) }
     var heldEditKey by remember { mutableStateOf<LongArray?>(null) }
 
+    // An opened/received .ics file. [ImportScreen] parses it and either opens
+    // the prefilled create form (one event → [importForm]) or its own bulk
+    // picker (many). A plain conditional overlay (no slide) — it's transient.
+    var importUri by remember { mutableStateOf<android.net.Uri?>(null) }
+    var importForm by remember { mutableStateOf<EventForm?>(null) }
+    LaunchedEffect(requestedImportUri) {
+        if (requestedImportUri != null) {
+            importUri = requestedImportUri
+            onImportConsumed()
+        }
+    }
+
+    // Close every overlay that can sit over the calendar, so an externally
+    // requested destination (a widget/shortcut/QS-tile launch) is revealed on
+    // top instead of underneath whatever the user had open.
+    fun dismissCoveringOverlays() {
+        showSettings = false
+        showCalendars = false
+        detailKey = null
+        editKey = null
+        importUri = null
+        importForm = null
+    }
+
     // A home-screen widget launch asks to open a date (→ day view) or start a
     // create. Handled once and cleared, mirroring [requestedDetailKey].
     LaunchedEffect(widgetNavRequest) {
         when (val req = widgetNavRequest) {
             is WidgetNavRequest.OpenDate -> {
+                // Reveal the day view: drop any overlay that would cover it, so
+                // an external date-open doesn't land under an open Settings/form.
+                dismissCoveringOverlays()
+                createDateIso = null
                 pendingDayIso = req.dateIso
                 view = CalendarView.Day
                 onWidgetNavConsumed()
             }
             is WidgetNavRequest.Create -> {
+                // External "new event" entries (QS tile / launcher shortcut /
+                // widget) must land on top of whatever is open — the form overlay
+                // sits below Settings/calendars in the Box, so without this it
+                // would open hidden underneath them.
+                dismissCoveringOverlays()
                 val iso = req.dateIso ?: Clock.System.now()
                     .toLocalDateTime(TimeZone.currentSystemDefault()).date.toString()
                 heldCreateIso = iso
@@ -152,6 +196,7 @@ fun CalendarHost(
                 onSelectView = onSelectView,
                 onEventClick = onEventClick,
                 onOpenSettings = onOpenSettings,
+                onOpenSearch = onOpenSearch,
                 onCreateEvent = onCreateEvent,
             )
             CalendarView.Day -> DayScreen(
@@ -159,6 +204,7 @@ fun CalendarHost(
                 onSelectView = onSelectView,
                 onEventClick = onEventClick,
                 onOpenSettings = onOpenSettings,
+                onOpenSearch = onOpenSearch,
                 onCreateEvent = onCreateEvent,
                 initialDateIso = pendingDayIso,
             )
@@ -167,6 +213,7 @@ fun CalendarHost(
                 onSelectView = onSelectView,
                 onOpenDay = onOpenDay,
                 onOpenSettings = onOpenSettings,
+                onOpenSearch = onOpenSearch,
                 onCreateEvent = onCreateEvent,
             )
             CalendarView.Agenda -> AgendaScreen(
@@ -174,10 +221,24 @@ fun CalendarHost(
                 onSelectView = onSelectView,
                 onEventClick = onEventClick,
                 onOpenSettings = onOpenSettings,
+                onOpenSearch = onOpenSearch,
                 onCreateEvent = onCreateEvent,
             )
         }
 
+        // Search overlay — below detail/edit in the Box so a tapped result's
+        // detail screen draws on top, and closing it returns to the results.
+        AnimatedVisibility(
+            visible = showSearch,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
+        ) {
+            SearchScreen(
+                onBack = { showSearch = false },
+                onEventClick = onEventClick,
+            )
+        }
+
         // Prefer the live key; fall back to the held one only while sliding out.
         val activeKey = detailKey ?: heldKey
         AnimatedVisibility(
@@ -254,5 +315,26 @@ fun CalendarHost(
         ) {
             CalendarsScreen(onBack = { showCalendars = false })
         }
+
+        // Import flow for an opened/received .ics file. A single event routes
+        // into the create form (prefilled, for review); many open the picker.
+        importUri?.let { uri ->
+            ImportScreen(
+                uri = uri,
+                onClose = { importUri = null },
+                onOpenSingle = { form ->
+                    importUri = null
+                    importForm = form
+                },
+            )
+        }
+        importForm?.let { form ->
+            EventEditScreen(
+                initialDateIso = null,
+                initialForm = form,
+                onClose = { importForm = null },
+                onSaved = { importForm = null },
+            )
+        }
     }
 }

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

@@ -27,6 +27,8 @@ fun RootScreen(
     onDetailKeyConsumed: () -> Unit = {},
     widgetNavRequest: WidgetNavRequest? = null,
     onWidgetNavConsumed: () -> Unit = {},
+    requestedImportUri: android.net.Uri? = null,
+    onImportConsumed: () -> Unit = {},
 ) {
     val context = LocalContext.current
     var hasPermission by remember {
@@ -62,6 +64,8 @@ fun RootScreen(
                 onDetailKeyConsumed = onDetailKeyConsumed,
                 widgetNavRequest = widgetNavRequest,
                 onWidgetNavConsumed = onWidgetNavConsumed,
+                requestedImportUri = requestedImportUri,
+                onImportConsumed = onImportConsumed,
             )
             false -> ReminderOnboardingScreen(
                 onFinished = reminderOnboarding::finish,

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

@@ -19,6 +19,7 @@ import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.EventAvailable
 import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material.icons.filled.Search
 import androidx.compose.material3.DrawerValue
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
@@ -75,6 +76,7 @@ fun AgendaScreen(
     onSelectView: (CalendarView) -> Unit,
     onEventClick: (EventInstance) -> Unit,
     onOpenSettings: () -> Unit,
+    onOpenSearch: () -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
     modifier: Modifier = Modifier,
     viewModel: AgendaViewModel = hiltViewModel(),
@@ -119,6 +121,7 @@ fun AgendaScreen(
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next()) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
+                    onOpenSearch = onOpenSearch,
                     scrollBehavior = scrollBehavior,
                 )
             },
@@ -274,6 +277,7 @@ private fun AgendaTopBar(
     selectedView: CalendarView,
     onCycleView: () -> Unit,
     onOpenDrawer: () -> Unit,
+    onOpenSearch: () -> Unit,
     scrollBehavior: TopAppBarScrollBehavior,
 ) {
     TopAppBar(
@@ -292,6 +296,12 @@ private fun AgendaTopBar(
             }
         },
         actions = {
+            IconButton(onClick = onOpenSearch) {
+                Icon(
+                    imageVector = Icons.Default.Search,
+                    contentDescription = stringResource(R.string.search_action),
+                )
+            }
             ViewSwitcherPill(
                 current = selectedView,
                 onCycle = onCycleView,

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

@@ -5,6 +5,8 @@ import android.content.Context
 import android.content.Intent
 import android.provider.Settings
 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.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
@@ -30,6 +32,7 @@ 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.FileDownload
 import androidx.compose.material.icons.filled.OpenInNew
 import androidx.compose.material.icons.filled.Palette
 import androidx.compose.material3.AlertDialog
@@ -77,6 +80,7 @@ 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
+import java.time.LocalDate
 
 /** Sentinel [editorId] meaning "the editor is composing a new calendar". */
 private const val NEW_CALENDAR_ID = Long.MIN_VALUE
@@ -95,6 +99,7 @@ fun CalendarsScreen(
 ) {
     val calendars by viewModel.calendars.collectAsStateWithLifecycle()
     val error by viewModel.error.collectAsStateWithLifecycle()
+    val backupResult by viewModel.backupResult.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
@@ -131,6 +136,9 @@ fun CalendarsScreen(
             synced = calendars.filterNot { it.isLocal },
             error = error,
             onConsumeError = viewModel::consumeError,
+            backupResult = backupResult,
+            onExportBackup = viewModel::exportBackup,
+            onConsumeBackupResult = viewModel::consumeBackupResult,
             onBack = onBack,
             onAdd = { editorSession++; editorId = NEW_CALENDAR_ID },
             onEdit = { calendar -> editorSession++; editorId = calendar.id },
@@ -144,6 +152,9 @@ private fun CalendarsList(
     synced: List<CalendarSource>,
     error: Boolean,
     onConsumeError: () -> Unit,
+    backupResult: BackupResult?,
+    onExportBackup: (android.net.Uri) -> Unit,
+    onConsumeBackupResult: () -> Unit,
     onBack: () -> Unit,
     onAdd: () -> Unit,
     onEdit: (CalendarSource) -> Unit,
@@ -159,6 +170,31 @@ private fun CalendarsList(
         }
     }
 
+    // SAF "create document" target for the backup file. The picked Uri is handed
+    // to the VM to stream the .ics into.
+    val createBackup = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.CreateDocument("text/calendar"),
+    ) { uri -> uri?.let(onExportBackup) }
+
+    val backupFailedText = stringResource(R.string.calendars_backup_failed)
+    LaunchedEffect(backupResult) {
+        when (val r = backupResult) {
+            is BackupResult.Success -> {
+                snackbarHostState.showSnackbar(
+                    context.resources.getQuantityString(
+                        R.plurals.calendars_backup_done, r.eventCount, r.eventCount,
+                    ),
+                )
+                onConsumeBackupResult()
+            }
+            BackupResult.Failure -> {
+                snackbarHostState.showSnackbar(backupFailedText)
+                onConsumeBackupResult()
+            }
+            null -> Unit
+        }
+    }
+
     CollapsingScaffold(
         title = stringResource(R.string.calendars_title),
         onBack = onBack,
@@ -195,6 +231,22 @@ private fun CalendarsList(
             onClick = onAdd,
         )
 
+        // Backup — local calendars have no sync, so a .ics export is their only
+        // safety net. Offered only when there is something to back up.
+        if (local.isNotEmpty()) {
+            Spacer(Modifier.height(16.dp))
+            SectionHeader(stringResource(R.string.calendars_backup_header))
+            HintText(stringResource(R.string.calendars_backup_hint))
+            GroupedRow(
+                title = stringResource(R.string.calendars_backup_action),
+                position = Position.Alone,
+                leading = { LeadingAvatar(Icons.Default.FileDownload) },
+                onClick = {
+                    runCatching { createBackup.launch("calendula-backup-${LocalDate.now()}.ics") }
+                },
+            )
+        }
+
         Spacer(Modifier.height(16.dp))
 
         // Synced calendars — read-only, grouped by account, each with a
@@ -429,6 +481,25 @@ private fun AccountHeader(account: String, accountType: String) {
     }
 }
 
+/** Neutral circular chip carrying an arbitrary icon — matches [AddAvatar]'s shape. */
+@Composable
+private fun LeadingAvatar(icon: ImageVector) {
+    Box(
+        modifier = Modifier
+            .size(40.dp)
+            .clip(CircleShape)
+            .background(MaterialTheme.colorScheme.surfaceContainerHighest),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            icon,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.size(22.dp),
+        )
+    }
+}
+
 /** Neutral circular chip with a "+" — the leading icon for add-actions. */
 @Composable
 private fun AddAvatar() {

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

@@ -1,11 +1,14 @@
 package de.jeanlucmakiola.calendula.ui.calendars
 
+import android.net.Uri
 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.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
@@ -15,7 +18,9 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import kotlin.coroutines.cancellation.CancellationException
+import kotlin.time.Clock
 import javax.inject.Inject
 
 /**
@@ -27,6 +32,7 @@ import javax.inject.Inject
 @HiltViewModel
 class CalendarsViewModel @Inject constructor(
     private val repository: CalendarRepository,
+    private val icsExporter: IcsExporter,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
@@ -45,6 +51,36 @@ class CalendarsViewModel @Inject constructor(
 
     fun consumeError() { _error.value = false }
 
+    private val _backupResult = MutableStateFlow<BackupResult?>(null)
+    val backupResult: StateFlow<BackupResult?> = _backupResult.asStateFlow()
+
+    fun consumeBackupResult() { _backupResult.value = null }
+
+    /**
+     * Serialise every event of the writable local calendars into the chosen SAF
+     * document [uri] as one `VCALENDAR`. Result (event count, or failure) lands
+     * in [backupResult] for a one-shot message.
+     */
+    fun exportBackup(uri: Uri) {
+        viewModelScope.launch {
+            _backupResult.value = try {
+                val count = withContext(io) {
+                    val events = repository.exportEvents()
+                    icsExporter.writeDocument(
+                        uri = uri,
+                        content = IcsWriter().writeCalendar(events, Clock.System.now()),
+                    )
+                    events.size
+                }
+                BackupResult.Success(count)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                BackupResult.Failure
+            }
+        }
+    }
+
     fun createCalendar(displayName: String, color: Int, description: String?) = write {
         repository.createLocalCalendar(displayName, color, description)
     }
@@ -69,3 +105,9 @@ class CalendarsViewModel @Inject constructor(
         }
     }
 }
+
+/** Outcome of a whole-calendar backup, surfaced once to the screen. */
+sealed interface BackupResult {
+    data class Success(val eventCount: Int) : BackupResult
+    data object Failure : BackupResult
+}

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

@@ -0,0 +1,94 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ArrowDropDown
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+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.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.dp
+
+/**
+ * Tonal 3-digit number input shared by the custom reminder/recurrence steps and
+ * the reminder pickers — the app's [InlineTextField] over a tonal surface, so it
+ * matches the card/grouped-row design language (not Material's outlined field).
+ */
+@Composable
+fun DialogAmountField(
+    value: String,
+    onValueChange: (String) -> Unit,
+    placeholder: String,
+) {
+    // surfaceContainerHighest — the picker/dialog sits on surfaceContainerHigh,
+    // so anything lower vanishes.
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHighest,
+        shape = RoundedCornerShape(12.dp),
+    ) {
+        InlineTextField(
+            value = value,
+            onValueChange = { text ->
+                if (text.length <= 3 && text.all(Char::isDigit)) onValueChange(text)
+            },
+            placeholder = placeholder,
+            textStyle = MaterialTheme.typography.titleMedium,
+            keyboardType = KeyboardType.Number,
+            modifier = Modifier
+                .width(72.dp)
+                .padding(horizontal = 14.dp, vertical = 12.dp),
+        )
+    }
+}
+
+/** Tonal dropdown trigger + menu shared by the custom reminder/recurrence steps and pickers. */
+@Composable
+fun DialogUnitDropdown(
+    label: String,
+    entries: List<String>,
+    onPick: (Int) -> Unit,
+) {
+    var open by remember { mutableStateOf(false) }
+    Box {
+        Surface(
+            color = MaterialTheme.colorScheme.surfaceContainerHighest,
+            shape = RoundedCornerShape(12.dp),
+            onClick = { open = true },
+        ) {
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.padding(start = 14.dp, end = 8.dp, top = 12.dp, bottom = 12.dp),
+            ) {
+                Text(text = label, style = MaterialTheme.typography.titleMedium)
+                Spacer(Modifier.width(4.dp))
+                Icon(imageVector = Icons.Default.ArrowDropDown, contentDescription = null)
+            }
+        }
+        DropdownMenu(expanded = open, onDismissRequest = { open = false }) {
+            entries.forEachIndexed { index, entry ->
+                DropdownMenuItem(
+                    text = { Text(entry) },
+                    onClick = {
+                        onPick(index)
+                        open = false
+                    },
+                )
+            }
+        }
+    }
+}

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

@@ -10,7 +10,9 @@ 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.consumeWindowInsets
 import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -102,7 +104,19 @@ fun CollapsingScaffold(
         Column(
             modifier = Modifier
                 .padding(innerPadding)
+                // Mark the scaffold's system-bar insets as consumed so the
+                // imePadding below adds only the keyboard height beyond them
+                // (max, not sum) — otherwise the nav-bar inset double-counts and
+                // leaves an empty strip above the keyboard.
+                .consumeWindowInsets(innerPadding)
                 .fillMaxSize()
+                // Paint the surface across the full area before imePadding carves
+                // into it, so any sliver above the keyboard reads as surface — not
+                // the dialog window's black — during the IME animation.
+                .background(MaterialTheme.colorScheme.surface)
+                // Shrink the scroll viewport by the keyboard inset so a focused
+                // field (e.g. the custom-reminder amount) can scroll into view.
+                .imePadding()
                 .verticalScroll(rememberScrollState())
                 .padding(top = 8.dp, bottom = 24.dp),
             content = content,

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

@@ -4,6 +4,7 @@ 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.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -12,6 +13,7 @@ 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.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.unit.dp
@@ -36,6 +38,9 @@ fun InlineTextField(
     minLines: Int = 1,
     keyboardType: KeyboardType = KeyboardType.Text,
     capitalization: KeyboardCapitalization = KeyboardCapitalization.None,
+    imeAction: ImeAction = ImeAction.Default,
+    /** Invoked when the IME action key (e.g. Done) is pressed. */
+    onImeAction: (() -> Unit)? = null,
 ) {
     val resolvedStyle = textStyle.copy(
         color = if (textStyle.color.isSpecified) {
@@ -53,7 +58,11 @@ fun InlineTextField(
         keyboardOptions = KeyboardOptions(
             keyboardType = keyboardType,
             capitalization = capitalization,
+            imeAction = imeAction,
         ),
+        keyboardActions = onImeAction?.let { action ->
+            KeyboardActions(onAny = { action() })
+        } ?: KeyboardActions.Default,
         cursorBrush = SolidColor(MaterialTheme.colorScheme.primary),
         decorationBox = { innerTextField ->
             Box {

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

@@ -0,0 +1,90 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.State
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.delay
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
+import kotlin.time.Instant
+
+private val DotSize = 8.dp
+private val LineThickness = 2.dp
+
+/**
+ * Current wall-clock instant that updates once a minute, re-aligning to each
+ * minute boundary (rather than ticking a fixed 60 s) so it never drifts toward
+ * the middle of a minute. Drives the "now" line in the day/week grids.
+ */
+@Composable
+private fun rememberCurrentMinute(): State<Instant> {
+    val instant = remember { mutableStateOf(Clock.System.now()) }
+    LaunchedEffect(Unit) {
+        while (true) {
+            val now = Clock.System.now()
+            instant.value = now
+            delay(60_000L - now.toEpochMilliseconds() % 60_000L)
+        }
+    }
+    return instant
+}
+
+/**
+ * A thin "current time" indicator — a leading dot plus a line — drawn across a
+ * day column. Positioned on the same [hourHeight] scale the event blocks use so
+ * it lines up with the grid, and refreshed each minute. Renders nothing unless
+ * the wall clock is on [date]; callers mount it only for the column showing
+ * today, so the per-minute tick runs on a single column.
+ */
+@Composable
+fun NowLine(
+    date: LocalDate,
+    hourHeight: Dp,
+    modifier: Modifier = Modifier,
+) {
+    val now by rememberCurrentMinute()
+    val local = now.toLocalDateTime(TimeZone.currentSystemDefault())
+    if (local.date != date) return
+
+    val minutes = local.hour * 60 + local.minute
+    val top = hourHeight * (minutes / 60f)
+    val color = MaterialTheme.colorScheme.primary
+    Box(
+        modifier = modifier
+            .fillMaxWidth()
+            .height(DotSize)
+            .offset(y = top - DotSize / 2),
+        contentAlignment = Alignment.CenterStart,
+    ) {
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(LineThickness)
+                .background(color),
+        )
+        // The dot anchors the line to the gutter edge, mirroring the standard
+        // calendar "now" marker; drawn after the line so it sits on top.
+        Box(
+            modifier = Modifier
+                .size(DotSize)
+                .background(color, CircleShape),
+        )
+    }
+}

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

@@ -0,0 +1,282 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.layout.Arrangement
+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.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.SegmentedButton
+import androidx.compose.material3.SegmentedButtonDefaults
+import androidx.compose.material3.SingleChoiceSegmentedButtonRow
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import android.view.WindowManager
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+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.platform.LocalView
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
+import androidx.compose.ui.window.DialogWindowProvider
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
+
+/**
+ * Shared full-screen scaffold for selection pickers: a full-bleed [Dialog] that
+ * reuses the app's [CollapsingScaffold] (collapsing title + back button), so a
+ * picker is visually identical to a Settings sub-page and uses the full width.
+ * [content] places the connected grouped rows; selecting one calls [onDismiss].
+ */
+@Composable
+fun FullScreenPicker(
+    title: String,
+    onDismiss: () -> Unit,
+    content: @Composable ColumnScope.() -> Unit,
+) {
+    Dialog(
+        onDismissRequest = onDismiss,
+        properties = DialogProperties(
+            usePlatformDefaultWidth = false,
+            decorFitsSystemWindows = false,
+        ),
+    ) {
+        // The dialog window pans by default when the keyboard opens, which —
+        // combined with the content's own imePadding — leaves a fixed black gap
+        // above the keyboard. Switch it to ADJUST_NOTHING so the window stays
+        // full-screen and imePadding alone lifts the focused field.
+        val view = LocalView.current
+        SideEffect {
+            (view.parent as? DialogWindowProvider)?.window
+                ?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
+        }
+        CollapsingScaffold(title = title, onBack = onDismiss, content = content)
+    }
+}
+
+/**
+ * General single-select picker, full-screen: each option is a connected grouped
+ * row and the current one carries a check. Drop-in for the former dialog
+ * (theme, week start, language, …).
+ */
+@Composable
+fun <T> OptionPicker(
+    title: String,
+    options: List<T>,
+    selected: T,
+    label: @Composable (T) -> String,
+    onSelect: (T) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    FullScreenPicker(title = title, onDismiss = onDismiss) {
+        options.forEachIndexed { index, option ->
+            val isSelected = option == selected
+            GroupedRow(
+                title = label(option),
+                position = positionOf(index, options.size),
+                selected = isSelected,
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
+                onClick = {
+                    onSelect(option)
+                    onDismiss()
+                },
+            )
+        }
+    }
+}
+
+/**
+ * Reminder-default picker, full-screen: the grouped list (with an optional "Use
+ * default reminder" row and a "None" row), the [presets] as lead-time rows, and
+ * a "Custom" row that expands an inline number field plus a segmented unit
+ * selector. Returns the choice as a [CalendarReminderOverride].
+ */
+@Composable
+fun ReminderDefaultPicker(
+    title: String,
+    presets: List<Int>,
+    selected: CalendarReminderOverride,
+    allowInherit: Boolean,
+    onSelect: (CalendarReminderOverride) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val selectedMinutes = (selected as? CalendarReminderOverride.Minutes)?.minutes
+    val customSelected = selectedMinutes != null && selectedMinutes !in presets
+    val seed = decomposeReminder(selectedMinutes?.takeIf { customSelected })
+
+    var customExpanded by rememberSaveable { mutableStateOf(false) }
+    var amountText by rememberSaveable { mutableStateOf(seed.first) }
+    var unit by rememberSaveable { mutableStateOf(seed.second) }
+
+    val options = buildList {
+        if (allowInherit) add(CalendarReminderOverride.Inherit)
+        add(CalendarReminderOverride.None)
+        presets.forEach { add(CalendarReminderOverride.Minutes(it)) }
+    }
+    val rowCount = options.size + 1 // + the custom row
+
+    FullScreenPicker(title = title, onDismiss = onDismiss) {
+        options.forEachIndexed { index, option ->
+            val isSelected = option == selected
+            GroupedRow(
+                title = reminderOverrideLabel(option),
+                position = positionOf(index, rowCount),
+                selected = isSelected,
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
+                onClick = {
+                    onSelect(option)
+                    onDismiss()
+                },
+            )
+        }
+        // When expanded, the Custom row connects downward into the editor card
+        // so the two read as one grouped container (the per-calendar pattern).
+        GroupedRow(
+            title = if (customSelected) {
+                stringResource(
+                    R.string.reminder_custom_with_value,
+                    reminderLeadTimeLabel(selectedMinutes!!),
+                )
+            } else {
+                stringResource(R.string.event_edit_reminder_custom)
+            },
+            position = if (customExpanded) Position.Top else positionOf(options.size, rowCount),
+            selected = customSelected,
+            trailing = if (customSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
+            onClick = { customExpanded = !customExpanded },
+        )
+        AnimatedVisibility(visible = customExpanded) {
+            CustomReminderEditor(
+                amountText = amountText,
+                onAmountChange = { amountText = it },
+                unit = unit,
+                onUnitChange = { unit = it },
+                onConfirm = { minutes ->
+                    onSelect(CalendarReminderOverride.Minutes(minutes))
+                    onDismiss()
+                },
+            )
+        }
+    }
+}
+
+/**
+ * The expanded "Custom" lead-time editor: a tonal card connected to the Custom
+ * row above it (matching the grouped-row system, so the two read as one
+ * container). An amount field with a live preview of the resulting lead time, a
+ * single-choice unit toggle, and a tonal confirm enabled only for a valid
+ * 1–999 amount. [onConfirm] receives the final lead time in minutes.
+ */
+@Composable
+private fun CustomReminderEditor(
+    amountText: String,
+    onAmountChange: (String) -> Unit,
+    unit: ReminderUnit,
+    onUnitChange: (ReminderUnit) -> Unit,
+    onConfirm: (Int) -> Unit,
+) {
+    val amount = amountText.toIntOrNull()?.takeIf { it in 1..999 }
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        // A Position.Bottom shape: tight top corners meeting the row, full bottom.
+        shape = RoundedCornerShape(topStart = 6.dp, topEnd = 6.dp, bottomStart = 22.dp, bottomEnd = 22.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp),
+    ) {
+        Column(
+            modifier = Modifier.padding(16.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            // Unit toggle first so it stays visible above the keyboard once the
+            // amount field (the bottom row) is focused and scrolled into view.
+            SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth()) {
+                ReminderUnit.entries.forEachIndexed { index, entry ->
+                    SegmentedButton(
+                        selected = unit == entry,
+                        onClick = { onUnitChange(entry) },
+                        shape = SegmentedButtonDefaults.itemShape(index, ReminderUnit.entries.size),
+                        label = { Text(stringResource(reminderUnitLabel(entry))) },
+                    )
+                }
+            }
+            // Amount, a live preview of the lead time it resolves to, and Set —
+            // all on one row, sitting just above the keyboard.
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                DialogAmountField(
+                    value = amountText,
+                    onValueChange = onAmountChange,
+                    placeholder = "10",
+                )
+                Spacer(Modifier.width(16.dp))
+                Text(
+                    text = amount?.let { reminderLeadTimeLabel(it * unit.minutesFactor) }
+                        ?: stringResource(R.string.reminder_custom_amount),
+                    style = MaterialTheme.typography.bodyLarge,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.weight(1f),
+                )
+                Spacer(Modifier.width(16.dp))
+                FilledTonalButton(
+                    onClick = { amount?.let { onConfirm(it * unit.minutesFactor) } },
+                    enabled = amount != null,
+                ) {
+                    Text(stringResource(R.string.reminder_custom_set))
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun SelectedCheck() {
+    Icon(
+        imageVector = Icons.Default.Check,
+        contentDescription = null,
+        tint = MaterialTheme.colorScheme.primary,
+    )
+}
+
+@Composable
+private fun reminderOverrideLabel(override: CalendarReminderOverride): String = when (override) {
+    CalendarReminderOverride.Inherit -> stringResource(R.string.reminder_use_default)
+    CalendarReminderOverride.None -> stringResource(R.string.reminder_none)
+    is CalendarReminderOverride.Minutes -> reminderLeadTimeLabel(override.minutes)
+}
+
+/** Seed the custom editor: the largest exact unit for [minutes] (null → empty). */
+private fun decomposeReminder(minutes: Int?): Pair<String, ReminderUnit> = when {
+    minutes == null -> "" to ReminderUnit.Minutes
+    minutes % 10_080 == 0 -> (minutes / 10_080).toString() to ReminderUnit.Weeks
+    minutes % 1_440 == 0 -> (minutes / 1_440).toString() to ReminderUnit.Days
+    minutes % 60 == 0 -> (minutes / 60).toString() to ReminderUnit.Hours
+    else -> minutes.toString() to ReminderUnit.Minutes
+}

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

@@ -0,0 +1,46 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.annotation.StringRes
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import de.jeanlucmakiola.calendula.R
+
+/** Common reminder lead times offered as quick picks in the form and settings. */
+val REMINDER_PRESETS = listOf(0, 10, 30, 60, 1_440)
+
+/** The unit of a custom reminder lead time; [minutesFactor] converts to minutes. */
+enum class ReminderUnit(val minutesFactor: Int) {
+    Minutes(1),
+    Hours(60),
+    Days(1_440),
+    Weeks(10_080),
+}
+
+@StringRes
+fun reminderUnitLabel(unit: ReminderUnit): Int = when (unit) {
+    ReminderUnit.Minutes -> R.string.reminder_unit_minutes
+    ReminderUnit.Hours -> R.string.reminder_unit_hours
+    ReminderUnit.Days -> R.string.reminder_unit_days
+    ReminderUnit.Weeks -> R.string.reminder_unit_weeks
+}
+
+/**
+ * Humanise a reminder lead time (minutes before the event start) into one
+ * line: "Default reminder" (negative = the provider default), "At time of
+ * event" (0), "10 minutes before", "1 hour before", … Shared by the detail
+ * screen, the event form and the default-reminder settings so the wording
+ * never drifts.
+ */
+@Composable
+fun reminderLeadTimeLabel(minutes: Int): String = when {
+    minutes < 0 -> stringResource(R.string.reminder_default)
+    minutes == 0 -> stringResource(R.string.reminder_at_time)
+    minutes % 10_080 == 0 ->
+        pluralStringResource(R.plurals.reminder_weeks, minutes / 10_080, minutes / 10_080)
+    minutes % 1_440 == 0 ->
+        pluralStringResource(R.plurals.reminder_days, minutes / 1_440, minutes / 1_440)
+    minutes % 60 == 0 ->
+        pluralStringResource(R.plurals.reminder_hours, minutes / 60, minutes / 60)
+    else -> pluralStringResource(R.plurals.reminder_minutes, minutes, minutes)
+}

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

@@ -0,0 +1,68 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import android.content.Context
+import android.content.res.Resources
+import android.provider.Settings
+import android.text.format.DateFormat
+import androidx.compose.material3.TimePicker
+import androidx.compose.material3.rememberTimePickerState
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import de.jeanlucmakiola.calendula.R
+import kotlinx.datetime.LocalTime
+
+/**
+ * M3 time picker in an alert dialog, seeded with [initial]. Shared by the event
+ * form (start/end times) and Settings (the all-day reminder fire time).
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun TimePickerAlert(
+    initial: LocalTime,
+    onConfirm: (LocalTime) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val state = rememberTimePickerState(
+        initialHour = initial.hour,
+        initialMinute = initial.minute,
+        is24Hour = deviceUses24HourClock(LocalContext.current),
+    )
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        confirmButton = {
+            TextButton(onClick = { onConfirm(LocalTime(state.hour, state.minute)) }) {
+                Text(stringResource(R.string.dialog_ok))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
+        },
+        text = { TimePicker(state = state) },
+    )
+}
+
+/**
+ * Whether the clock should read 24-hour, matching the rest of the device.
+ *
+ * [DateFormat.is24HourFormat] resolves a "locale default" system setting against
+ * the *app's* context locale — and this app applies a per-app language
+ * (AppCompatDelegate), so an English UI on a German-region phone would wrongly
+ * read 12-hour while the system clock shows 24-hour. So we honour an explicit
+ * system 12/24 override, and otherwise fall back to the **device** locale
+ * (Resources.getSystem), not the app's.
+ */
+private fun deviceUses24HourClock(context: Context): Boolean =
+    when (Settings.System.getString(context.contentResolver, Settings.System.TIME_12_24)) {
+        "24" -> true
+        "12" -> false
+        // 'a' is the AM/PM marker; a best-fit pattern without it is 24-hour.
+        else -> {
+            val deviceLocale = Resources.getSystem().configuration.locales[0]
+            !DateFormat.getBestDateTimePattern(deviceLocale, "jm").contains('a')
+        }
+    }

app/src/main/java/de/jeanlucmakiola/calendula/ui/crash/CrashReportActivity.kt

@@ -0,0 +1,59 @@
+package de.jeanlucmakiola.calendula.ui.crash
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.ui.Modifier
+import de.jeanlucmakiola.calendula.data.crash.CrashReporter
+import de.jeanlucmakiola.calendula.ui.theme.CalendulaTheme
+
+/**
+ * A deliberately minimal, standalone surface for a captured crash report.
+ * `MainActivity` routes here when it detects a startup crash-loop (see
+ * [CrashReporter.isCrashLoop]): the main UI can't be trusted to start, so this
+ * screen stays clear of the app's Hilt graph, DataStore-backed theme and
+ * Compose content — it only reads the report file and shows the report dialog.
+ * Plain [CalendulaTheme] defaults (follow-system, dynamic colour) avoid touching
+ * anything that might be the cause of the crash.
+ */
+class CrashReportActivity : ComponentActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val report = CrashReporter.pendingReport(this)
+        if (report == null) {
+            finish()
+            return
+        }
+        enableEdgeToEdge()
+        setContent {
+            CalendulaTheme {
+                // Opaque backdrop so the dialog doesn't float over a bare task.
+                Surface(Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.surface) {}
+                CrashReportDialog(
+                    report = report,
+                    onSend = {
+                        submitCrashReport(this, report)
+                        CrashReporter.clearReport(this)
+                        finish()
+                    },
+                    onDismiss = {
+                        CrashReporter.clearReport(this)
+                        finish()
+                    },
+                )
+            }
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        // Reaching this screen breaks the loop; reset the timing trail so a
+        // later ordinary crash isn't mistaken for a loop.
+        CrashReporter.markHealthy(this)
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/crash/CrashReportDialog.kt

@@ -0,0 +1,75 @@
+package de.jeanlucmakiola.calendula.ui.crash
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+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.filled.BugReport
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+
+/**
+ * Asks the user to send a captured crash report as an issue. The full report is
+ * shown verbatim in a scrollable panel — the user sees exactly what will leave
+ * the device before choosing to share it (the privacy backstop). [onSend] hands
+ * off to [submitCrashReport]; [onDismiss] declines.
+ */
+@Composable
+fun CrashReportDialog(
+    report: String,
+    onSend: () -> Unit,
+    onDismiss: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        icon = { Icon(Icons.Default.BugReport, contentDescription = null) },
+        title = { Text(stringResource(R.string.crash_dialog_title)) },
+        text = {
+            Column {
+                Text(
+                    text = stringResource(R.string.crash_dialog_message),
+                    style = MaterialTheme.typography.bodyMedium,
+                )
+                Spacer(Modifier.height(12.dp))
+                Surface(
+                    color = MaterialTheme.colorScheme.surfaceContainerHighest,
+                    shape = RoundedCornerShape(12.dp),
+                    modifier = Modifier.fillMaxWidth(),
+                ) {
+                    Text(
+                        text = report,
+                        style = MaterialTheme.typography.bodySmall,
+                        fontFamily = FontFamily.Monospace,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier
+                            .heightIn(max = 220.dp)
+                            .verticalScroll(rememberScrollState())
+                            .padding(12.dp),
+                    )
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onSend) { Text(stringResource(R.string.crash_dialog_report)) }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.crash_dialog_dismiss)) }
+        },
+    )
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/crash/CrashReportSubmit.kt

@@ -0,0 +1,61 @@
+package de.jeanlucmakiola.calendula.ui.crash
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.content.Intent
+import android.widget.Toast
+import androidx.core.net.toUri
+import de.jeanlucmakiola.calendula.R
+
+/**
+ * Hand the captured crash report off to the user's chosen channel: the report
+ * is copied to the clipboard (the reliable path for a full stack trace) and the
+ * project's Gitea "new issue" page is opened with the body prefilled. Nothing is
+ * sent automatically — the app has no network access; the user reviews and
+ * submits the issue themselves.
+ */
+fun submitCrashReport(context: Context, report: String) {
+    copyReportToClipboard(context, report)
+    val opened = runCatching {
+        context.startActivity(Intent(Intent.ACTION_VIEW, buildIssueUri(context, report)))
+    }.isSuccess
+    val message = if (opened) R.string.crash_report_copied else R.string.crash_report_open_failed
+    Toast.makeText(context, message, Toast.LENGTH_LONG).show()
+}
+
+/** Open the issue tracker's template chooser for a manual (non-crash) report. */
+fun openIssueTracker(context: Context) {
+    val uri = context.getString(R.string.report_issue_choose_url).toUri()
+    runCatching { context.startActivity(Intent(Intent.ACTION_VIEW, uri)) }
+}
+
+private fun copyReportToClipboard(context: Context, report: String) {
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return
+    val label = context.getString(R.string.crash_report_clip_label)
+    clipboard.setPrimaryClip(ClipData.newPlainText(label, report))
+}
+
+/**
+ * The Gitea `issues/new` URL with `title` and `body` prefilled. A full report
+ * can blow past URL-length limits, so an over-long one is left out of the link
+ * (with a "paste from clipboard" placeholder) — the clipboard copy is the
+ * source of truth in that case.
+ */
+private fun buildIssueUri(context: Context, report: String) =
+    context.getString(R.string.report_issue_url).toUri().buildUpon()
+        .appendQueryParameter("title", context.getString(R.string.crash_report_issue_title))
+        .appendQueryParameter("body", buildIssueBody(context, report))
+        .build()
+
+private fun buildIssueBody(context: Context, report: String): String {
+    val block = if (report.length > MAX_URL_REPORT_CHARS) {
+        context.getString(R.string.crash_report_body_paste)
+    } else {
+        "```\n$report\n```"
+    }
+    return context.getString(R.string.crash_report_body_template, block)
+}
+
+/** Keep the prefilled body comfortably under common URL-length ceilings. */
+private const val MAX_URL_REPORT_CHARS = 6_000

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

@@ -26,6 +26,7 @@ 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.Search
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.DrawerValue
@@ -71,6 +72,7 @@ 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.NowLine
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.next
@@ -105,6 +107,7 @@ fun DayScreen(
     onSelectView: (CalendarView) -> Unit,
     onEventClick: (EventInstance) -> Unit,
     onOpenSettings: () -> Unit,
+    onOpenSearch: () -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
     modifier: Modifier = Modifier,
     initialDateIso: String? = null,
@@ -188,6 +191,7 @@ fun DayScreen(
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next()) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
+                    onOpenSearch = onOpenSearch,
                     scrollBehavior = scrollBehavior,
                 )
             },
@@ -340,6 +344,7 @@ private fun DayTopBar(
     selectedView: CalendarView,
     onCycleView: () -> Unit,
     onOpenDrawer: () -> Unit,
+    onOpenSearch: () -> Unit,
     scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
     TopAppBar(
@@ -358,6 +363,12 @@ private fun DayTopBar(
             }
         },
         actions = {
+            IconButton(onClick = onOpenSearch) {
+                Icon(
+                    imageVector = Icons.Default.Search,
+                    contentDescription = stringResource(R.string.search_action),
+                )
+            }
             ViewSwitcherPill(
                 current = selectedView,
                 onCycle = onCycleView,
@@ -496,6 +507,7 @@ private fun Timeline(
                     blocks = state.timed,
                     dark = dark,
                     date = state.date,
+                    today = state.today,
                     onEventClick = onEventClick,
                     onCreateAt = onCreateAt,
                     modifier = Modifier
@@ -512,6 +524,7 @@ private fun DayColumnCard(
     blocks: List<TimedBlock>,
     dark: Boolean,
     date: LocalDate,
+    today: LocalDate,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     modifier: Modifier = Modifier,
@@ -556,6 +569,10 @@ private fun DayColumnCard(
                         .padding(horizontal = 1.dp),
                 )
             }
+            // Current-time line, on top of the events, only on today's column.
+            if (date == today) {
+                NowLine(date = date, hourHeight = HOUR_HEIGHT)
+            }
         }
     }
 }

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

@@ -41,6 +41,7 @@ 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.material.icons.filled.Share
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
@@ -59,6 +60,7 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -67,7 +69,6 @@ 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
 import androidx.compose.ui.text.LinkAnnotation
@@ -96,6 +97,8 @@ 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 de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
+import kotlinx.coroutines.launch
 import kotlinx.datetime.TimeZone
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
@@ -132,9 +135,30 @@ fun EventDetailScreen(
     BackHandler(onBack = onBack)
 
     val context = LocalContext.current
+    val scope = rememberCoroutineScope()
     val snackbarHostState = remember { SnackbarHostState() }
     var showDeleteDialog by rememberSaveable { mutableStateOf(false) }
 
+    // Sharing is read-only, so it needs no WRITE_CALENDAR upgrade. The VM stages
+    // an .ics in the cache and hands back a content Uri for the chooser.
+    val shareFailedMessage = stringResource(R.string.event_share_failed)
+    val shareChooserTitle = stringResource(R.string.event_share_chooser_title)
+    val onShareClick = {
+        scope.launch {
+            val uri = viewModel.shareUri()
+            val sent = uri != null && runCatching {
+                val send = Intent(Intent.ACTION_SEND).apply {
+                    type = "text/calendar"
+                    putExtra(Intent.EXTRA_STREAM, uri)
+                    addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                }
+                context.startActivity(Intent.createChooser(send, shareChooserTitle))
+            }.isSuccess
+            if (!sent) snackbarHostState.showSnackbar(shareFailedMessage)
+        }
+        Unit
+    }
+
     // 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) }
@@ -203,9 +227,18 @@ fun EventDetailScreen(
                     }
                 },
                 actions = {
-                    // Only writable calendars get actions — WebCal subscriptions,
-                    // birthday calendars etc. are read-only at the provider level.
                     val s = state
+                    // Share works for any loaded event — it only reads the event.
+                    if (s is EventDetailUiState.Success) {
+                        IconButton(onClick = onShareClick) {
+                            Icon(
+                                imageVector = Icons.Default.Share,
+                                contentDescription = stringResource(R.string.event_detail_share),
+                            )
+                        }
+                    }
+                    // Edit/delete need a writable calendar — WebCal subscriptions,
+                    // birthday calendars etc. are read-only at the provider level.
                     if (s is EventDetailUiState.Success && s.canModify) {
                         IconButton(
                             onClick = onEditClick,
@@ -557,10 +590,22 @@ private fun AttendeeRow(attendee: Attendee) {
         verticalAlignment = Alignment.CenterVertically,
     ) {
         Column(modifier = Modifier.weight(1f)) {
+            val hasName = attendee.name.isNotBlank()
             Text(
-                text = attendee.name.ifBlank { attendee.email.orEmpty() },
+                text = if (hasName) attendee.name else attendee.email.orEmpty(),
                 style = MaterialTheme.typography.bodyMedium,
             )
+            // Email as supporting text — only when the name is the headline, so we
+            // don't repeat it on rows that already fall back to the email above.
+            if (hasName) {
+                attendee.email?.takeIf { it.isNotBlank() }?.let { email ->
+                    Text(
+                        text = email,
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+            }
             attendeeRoleLabel(attendee)?.let { roleRes ->
                 Text(
                     text = stringResource(roleRes),
@@ -684,26 +729,7 @@ private fun attendeeRoleLabel(attendee: Attendee): Int? = when {
 
 /** Humanise a reminder's lead time, e.g. "10 minutes before" / "At time of event". */
 @Composable
-private fun reminderLeadText(reminder: Reminder): String {
+private fun reminderLeadText(reminder: Reminder): String = reminderLeadTimeLabel(reminder.minutes)
-    val minutes = reminder.minutes
-    return when {
-        minutes < 0 -> stringResource(R.string.reminder_default)
-        minutes == 0 -> stringResource(R.string.reminder_at_time)
-        minutes % 10_080 == 0 -> {
-            val weeks = minutes / 10_080
-            pluralStringResource(R.plurals.reminder_weeks, weeks, weeks)
-        }
-        minutes % 1_440 == 0 -> {
-            val days = minutes / 1_440
-            pluralStringResource(R.plurals.reminder_days, days, days)
-        }
-        minutes % 60 == 0 -> {
-            val hours = minutes / 60
-            pluralStringResource(R.plurals.reminder_hours, hours, hours)
-        }
-        else -> pluralStringResource(R.plurals.reminder_minutes, minutes, minutes)
-    }
-}
 
 /**
  * A localized label for [tz] (e.g. "Central European Time (Europe/Berlin)"),
@@ -762,14 +788,19 @@ private fun formatWhen(
     val allDayLabel = stringResource(R.string.event_detail_all_day)
 
     if (instance.isAllDay) {
-        // All-day end is the exclusive next midnight; step back to the last
+        // All-day events live at UTC midnights with an exclusive end. Resolve
-        // covered day so a one-day event reads as a single date.
+        // the covered dates in UTC — not the device zone, which would shift the
-        val lastLdt = (instance.end - 1.seconds).toJavaLocalDateTime(zid)
+        // midnight boundaries off the intended date (east of UTC pushes the
-        return if (startLdt.toLocalDate() == lastLdt.toLocalDate()) {
+        // end past the last day; west of UTC pulls the start back) — and step
-            allDayLabel to dateFull.format(startLdt.toLocalDate())
+        // the end back to the last covered day so a one-day event reads as a
+        // single date.
+        val utc = ZoneId.of("UTC")
+        val startDate = instance.start.toJavaLocalDateTime(utc).toLocalDate()
+        val lastDate = (instance.end - 1.seconds).toJavaLocalDateTime(utc).toLocalDate()
+        return if (startDate == lastDate) {
+            allDayLabel to dateFull.format(startDate)
         } else {
-            allDayLabel to
+            allDayLabel to "${dateMedium.format(startDate)} – ${dateMedium.format(lastDate)}"
-                "${dateMedium.format(startLdt.toLocalDate())} – ${dateMedium.format(lastLdt.toLocalDate())}"
         }
     }
 

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

@@ -1,14 +1,20 @@
 package de.jeanlucmakiola.calendula.ui.detail
 
+import android.net.Uri
 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.ics.IcsExporter
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
+import de.jeanlucmakiola.calendula.domain.ics.toShareIcsEvent
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
+import kotlin.time.Clock
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
@@ -34,6 +40,7 @@ import javax.inject.Inject
 @HiltViewModel
 class EventDetailViewModel @Inject constructor(
     private val repository: CalendarRepository,
+    private val icsExporter: IcsExporter,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
@@ -113,6 +120,24 @@ class EventDetailViewModel @Inject constructor(
         _deleteState.value = DeleteUiState.Idle
     }
 
+    /**
+     * Serialise the open event to a `.ics` cache file and return a shareable
+     * content Uri (for an ACTION_SEND), or null when nothing is loaded or the
+     * write fails. The event is exported as a one-off (see [toShareIcsEvent]).
+     */
+    suspend fun shareUri(): Uri? {
+        val detail = (state.value as? EventDetailUiState.Success)?.detail ?: return null
+        return runCatching {
+            withContext(io) {
+                val ics = IcsWriter().writeCalendar(
+                    events = listOf(detail.toShareIcsEvent()),
+                    dtStamp = Clock.System.now(),
+                )
+                icsExporter.stageShareFile(shareFileName(detail.instance.title), ics)
+            }
+        }.getOrNull()
+    }
+
     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
@@ -143,3 +168,13 @@ class EventDetailViewModel @Inject constructor(
     /** A tapped occurrence: the series [eventId] plus this occurrence's own times. */
     private data class Target(val eventId: Long, val beginMillis: Long, val endMillis: Long)
 }
+
+/** A filesystem-safe `.ics` file name from an event title (or a fallback). */
+private fun shareFileName(title: String): String {
+    val base = title.trim()
+        .replace(Regex("""[^\p{L}\p{Nd} _-]"""), "")
+        .replace(' ', '_')
+        .take(40)
+        .ifBlank { "event" }
+    return "$base.ics"
+}

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

@@ -1,7 +1,13 @@
 package de.jeanlucmakiola.calendula.ui.edit
 
 import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
 import android.content.pm.PackageManager
+import android.net.Uri
+import android.provider.ContactsContract
+import android.util.Patterns
 import androidx.activity.compose.BackHandler
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
@@ -30,7 +36,6 @@ import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.BasicTextField
-import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.Notes
@@ -38,10 +43,14 @@ import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.ArrowDropDown
 import androidx.compose.material.icons.filled.CalendarMonth
 import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Contacts
 import androidx.compose.material.icons.filled.EventAvailable
 import androidx.compose.material.icons.filled.Lock
 import androidx.compose.material.icons.filled.Notifications
 import androidx.compose.material.icons.filled.Palette
+import androidx.compose.material.icons.filled.People
+import androidx.compose.material.icons.filled.Person
+import androidx.compose.material.icons.filled.PersonAdd
 import androidx.compose.material.icons.filled.Place
 import androidx.compose.material.icons.filled.Public
 import androidx.compose.material.icons.filled.Repeat
@@ -49,11 +58,11 @@ import androidx.compose.material.icons.filled.Schedule
 import androidx.compose.material.icons.filled.Tune
 import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.AssistChip
 import androidx.compose.material3.Button
 import androidx.compose.material3.DropdownMenu
 import androidx.compose.material3.DropdownMenuItem
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.FilterChip
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
@@ -68,10 +77,8 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
-import androidx.compose.material3.TimePicker
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
-import androidx.compose.material3.rememberTimePickerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -84,14 +91,17 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.SolidColor
 import androidx.compose.ui.graphics.isSpecified
+import androidx.compose.ui.graphics.Shape
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import androidx.core.content.ContextCompat
 import androidx.hilt.navigation.compose.hiltViewModel
@@ -100,7 +110,9 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventAttendee
 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.RecurrenceEnd
@@ -112,10 +124,19 @@ import de.jeanlucmakiola.calendula.domain.toRRule
 import de.jeanlucmakiola.calendula.ui.common.CALENDAR_COLOR_PALETTE
 import de.jeanlucmakiola.calendula.ui.common.CalendarDatePickerDialog
 import de.jeanlucmakiola.calendula.ui.common.ColorSwatchRow
+import de.jeanlucmakiola.calendula.ui.common.DialogAmountField
+import de.jeanlucmakiola.calendula.ui.common.DialogUnitDropdown
 import de.jeanlucmakiola.calendula.ui.common.MILLIS_PER_DAY
 import de.jeanlucmakiola.calendula.ui.common.InlineTextField
 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.REMINDER_PRESETS
+import de.jeanlucmakiola.calendula.ui.common.ReminderUnit
+import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
+import de.jeanlucmakiola.calendula.ui.common.reminderUnitLabel
 import de.jeanlucmakiola.calendula.ui.common.pastelize
 import de.jeanlucmakiola.calendula.ui.common.recurrenceText
 import kotlinx.datetime.DayOfWeek
@@ -152,21 +173,25 @@ fun EventEditScreen(
     onSaved: () -> Unit,
     editKey: LongArray? = null,
     initialStartMinutes: Int? = null,
+    initialForm: EventForm? = null,
     viewModel: EventEditViewModel = hiltViewModel(),
 ) {
-    LaunchedEffect(initialDateIso, editKey) {
+    LaunchedEffect(initialDateIso, editKey, initialForm) {
-        if (editKey != null) {
+        when {
-            viewModel.openForEdit(
+            // Single-event .ics open: the form arrives prefilled for review.
+            initialForm != null -> viewModel.openImported(initialForm)
+            editKey != null -> viewModel.openForEdit(
                 eventId = editKey[0],
                 beginMillis = editKey[1],
                 endMillis = editKey[2],
             )
-        } else {
+            else -> {
                 val date = initialDateIso?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
                     ?: Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date
                 viewModel.openNew(date, initialStartMinutes)
             }
         }
+    }
     val state by viewModel.state.collectAsStateWithLifecycle()
     val loadFailed by viewModel.loadFailed.collectAsStateWithLifecycle()
 
@@ -420,6 +445,37 @@ private fun EventEditContent(
     var showColorPicker by rememberSaveable { mutableStateOf(false) }
     var showFieldPicker by rememberSaveable { mutableStateOf(false) }
 
+    // Pick a guest from contacts: a one-shot system picker returning the chosen
+    // email row (email + display name). No READ_CONTACTS — the result Intent
+    // grants temporary read access, so Calendula stays no-network/no-permission.
+    val context = LocalContext.current
+    val pickContact = rememberLauncherForActivityResult(
+        ActivityResultContracts.StartActivityForResult(),
+    ) { result ->
+        if (result.resultCode == Activity.RESULT_OK) {
+            result.data?.data?.let { uri ->
+                readContactEmail(context, uri)?.let { (email, name) ->
+                    viewModel.addAttendee(email, name)
+                }
+            }
+        }
+    }
+
+    // Pick a postal address from contacts: the same one-shot picker, scoped to
+    // address rows, dropping the chosen contact's formatted address into the
+    // location field. Same no-permission guarantee as the guest picker above.
+    val pickContactAddress = rememberLauncherForActivityResult(
+        ActivityResultContracts.StartActivityForResult(),
+    ) { result ->
+        if (result.resultCode == Activity.RESULT_OK) {
+            result.data?.data?.let { uri ->
+                readContactAddress(context, uri)?.let { address ->
+                    viewModel.setLocation(address)
+                }
+            }
+        }
+    }
+
     val selectedCalendar = state.calendars.firstOrNull { it.id == form.calendarId }
     // The accent ties the form to the detail screen's design language: the
     // bar under the title takes the target calendar's colour.
@@ -551,11 +607,39 @@ private fun EventEditContent(
                 icon = Icons.Default.Place,
                 iconContentDescription = stringResource(R.string.event_detail_location),
             ) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
                     InlineField(
                         value = form.location,
                         onValueChange = viewModel::setLocation,
                         placeholder = stringResource(R.string.event_detail_location),
+                        modifier = Modifier
+                            .weight(1f)
+                            .padding(vertical = 4.dp),
                     )
+                    IconButton(
+                        onClick = {
+                            runCatching {
+                                pickContactAddress.launch(
+                                    Intent(
+                                        Intent.ACTION_PICK,
+                                        ContactsContract.CommonDataKinds.StructuredPostal
+                                            .CONTENT_URI,
+                                    ),
+                                )
+                            }
+                        },
+                        modifier = Modifier.size(40.dp),
+                    ) {
+                        Icon(
+                            imageVector = Icons.Default.Contacts,
+                            contentDescription = stringResource(
+                                R.string.event_edit_location_from_contacts,
+                            ),
+                            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                            modifier = Modifier.size(22.dp),
+                        )
+                    }
+                }
             }
         }
 
@@ -578,33 +662,24 @@ private fun EventEditContent(
 
         OptionalFormSection(visible = EventFormField.Reminders in state.visibleFields) {
             Spacer(Modifier.height(gap))
-            // Reminders stack one per row (remove on the right edge); the
+            // A grouped list like guests: each reminder is its own tonal card
-            // add chip closes the card at the bottom. The card icon centres
+            // with connected corners, the last row being "Add reminder".
-            // on the first row, whatever that is.
+            val reminders = form.reminders
-            EditCard(
+            val rows = reminders.size + 1
+            reminders.forEachIndexed { index, minutes ->
+                GroupedItemCard(
+                    position = positionOf(index, rows),
                     icon = Icons.Default.Notifications,
-                iconContentDescription = stringResource(R.string.event_detail_reminders),
+                    title = reminderLabel(minutes),
-                header = {
+                    removeContentDescription = stringResource(R.string.event_edit_remove_reminder),
-                    when (val first = form.reminders.firstOrNull()) {
-                        null -> AddReminderChip(onClick = { showReminderPicker = true })
-                        else -> ReminderRow(
-                            label = reminderLabel(first),
-                            onRemove = { viewModel.removeReminder(first) },
-                        )
-                    }
-                },
-            ) {
-                form.reminders.drop(1).forEach { minutes ->
-                    ReminderRow(
-                        label = reminderLabel(minutes),
                     onRemove = { viewModel.removeReminder(minutes) },
                 )
             }
-                if (form.reminders.isNotEmpty()) {
+            AddActionCard(
-                    Spacer(Modifier.height(4.dp))
+                label = stringResource(R.string.event_edit_add_reminder),
-                    AddReminderChip(onClick = { showReminderPicker = true })
+                position = positionOf(reminders.size, rows),
-                }
+                onClick = { showReminderPicker = true },
-            }
+            )
         }
 
         OptionalFormSection(visible = EventFormField.Recurrence in state.visibleFields) {
@@ -767,6 +842,52 @@ private fun EventEditContent(
             }
         }
 
+        OptionalFormSection(visible = EventFormField.Attendees in state.visibleFields) {
+            Spacer(Modifier.height(gap))
+            // Guests are an inline grouped list: each is a tonal card with a
+            // role toggle + remove, and the trailing card is an inline email
+            // field — type an address, press Done, it commits. Below sits an
+            // honest note — Calendula never sends invitations, so whether a
+            // guest is notified is the calendar backend's call.
+            val guests = form.attendees
+            val rows = guests.size + 1
+            guests.forEachIndexed { index, attendee ->
+                GuestCard(
+                    attendee = attendee,
+                    position = positionOf(index, rows),
+                    onToggleOptional = { viewModel.setAttendeeOptional(attendee, it) },
+                    onRemove = { viewModel.removeAttendee(attendee) },
+                )
+            }
+            AddGuestInlineCard(
+                position = positionOf(guests.size, rows),
+                onAdd = { viewModel.addAttendee(it) },
+                onPickContact = {
+                    runCatching {
+                        pickContact.launch(
+                            Intent(
+                                Intent.ACTION_PICK,
+                                ContactsContract.CommonDataKinds.Email.CONTENT_URI,
+                            ),
+                        )
+                    }
+                },
+            )
+            Spacer(Modifier.height(8.dp))
+            Text(
+                text = stringResource(
+                    if (isLocalCalendar) {
+                        R.string.event_edit_attendees_note_local
+                    } else {
+                        R.string.event_edit_attendees_note_synced
+                    },
+                ),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(horizontal = 4.dp),
+            )
+        }
+
         OptionalFormSection(visible = state.hiddenFields.isNotEmpty()) {
             Spacer(Modifier.height(20.dp))
             TextButton(
@@ -831,6 +952,7 @@ private fun EventEditContent(
         )
     }
 
+
     if (showRecurrencePicker) {
         RecurrencePickerDialog(
             current = form.rrule,
@@ -916,14 +1038,7 @@ private fun FieldPickerDialog(
 }
 
 /** Quick-pick lead times offered as chips in the reminder dialog. */
-private val REMINDER_QUICK_PICKS = listOf(0, 10, 30, 60, 1_440)
+private val REMINDER_QUICK_PICKS = REMINDER_PRESETS
-
-private enum class ReminderUnit(val minutesFactor: Int) {
-    Minutes(1),
-    Hours(60),
-    Days(1_440),
-    Weeks(10_080),
-}
 
 /**
  * Reminder picker, two steps: the common lead times as a tappable list
@@ -1245,84 +1360,6 @@ private fun Set<DayOfWeek>.toMask(): Int = fold(0) { acc, day -> acc or day.toMa
 private fun Int.toDaySet(): Set<DayOfWeek> =
     DayOfWeek.entries.filter { this and it.toMaskBit() != 0 }.toSet()
 
-/** Tonal 3-digit number input shared by the custom reminder/recurrence steps. */
-@Composable
-private fun DialogAmountField(
-    value: String,
-    onValueChange: (String) -> Unit,
-    placeholder: String,
-) {
-    // surfaceContainerHighest — the dialog itself sits on
-    // surfaceContainerHigh, so anything lower vanishes.
-    Surface(
-        color = MaterialTheme.colorScheme.surfaceContainerHighest,
-        shape = RoundedCornerShape(12.dp),
-    ) {
-        InlineField(
-            value = value,
-            onValueChange = { text ->
-                if (text.length <= 3 && text.all(Char::isDigit)) {
-                    onValueChange(text)
-                }
-            },
-            placeholder = placeholder,
-            textStyle = MaterialTheme.typography.titleMedium,
-            keyboardType = KeyboardType.Number,
-            modifier = Modifier
-                .width(72.dp)
-                .padding(horizontal = 14.dp, vertical = 12.dp),
-        )
-    }
-}
-
-/** Tonal dropdown trigger + menu shared by the custom reminder/recurrence steps. */
-@Composable
-private fun DialogUnitDropdown(
-    label: String,
-    entries: List<String>,
-    onPick: (Int) -> Unit,
-) {
-    var open by remember { mutableStateOf(false) }
-    Box {
-        Surface(
-            color = MaterialTheme.colorScheme.surfaceContainerHighest,
-            shape = RoundedCornerShape(12.dp),
-            onClick = { open = true },
-        ) {
-            Row(
-                verticalAlignment = Alignment.CenterVertically,
-                modifier = Modifier.padding(
-                    start = 14.dp,
-                    end = 8.dp,
-                    top = 12.dp,
-                    bottom = 12.dp,
-                ),
-            ) {
-                Text(
-                    text = label,
-                    style = MaterialTheme.typography.titleMedium,
-                )
-                Spacer(Modifier.width(4.dp))
-                Icon(
-                    imageVector = Icons.Default.ArrowDropDown,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                )
-            }
-        }
-        DropdownMenu(expanded = open, onDismissRequest = { open = false }) {
-            entries.forEachIndexed { index, entry ->
-                DropdownMenuItem(
-                    text = { Text(entry) },
-                    onClick = {
-                        onPick(index)
-                        open = false
-                    },
-                )
-            }
-        }
-    }
-}
 
 private fun recurrencePresetLabel(freq: RecurrenceFreq): Int = when (freq) {
     RecurrenceFreq.Daily -> R.string.recurrence_daily
@@ -1338,51 +1375,273 @@ private fun recurrenceUnitLabel(freq: RecurrenceFreq): Int = when (freq) {
     RecurrenceFreq.Yearly -> R.string.recurrence_unit_years
 }
 
-/** One chosen reminder: humanised lead time, remove pinned to the right edge. */
+/** Corner shape for a card at [position] in a grouped run (mirrors GroupedRow). */
+private fun groupedShape(position: Position, full: Dp = 20.dp, small: Dp = 6.dp): 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,
+        )
+    }
+
+/** The 2dp gap that visually separates grouped cards (none after the last). */
+private fun groupedGap(position: Position): Modifier = when (position) {
+    Position.Top, Position.Middle -> Modifier.padding(bottom = 2.dp)
+    Position.Bottom, Position.Alone -> Modifier
+}
+
+/**
+ * One entry in a grouped form list (a guest, a reminder): a leading [icon],
+ * a [title] with optional [supporting] line, and a remove button — all on a
+ * tonal card whose corners come from its [position] in the run.
+ */
 @Composable
-private fun ReminderRow(label: String, onRemove: () -> Unit) {
+private fun GroupedItemCard(
+    position: Position,
+    icon: ImageVector,
+    title: String,
+    removeContentDescription: String,
+    onRemove: () -> Unit,
+    supporting: String? = null,
+    titleMaxLines: Int = Int.MAX_VALUE,
+    trailing: @Composable (() -> Unit)? = null,
+) {
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        shape = groupedShape(position),
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(groupedGap(position)),
+    ) {
         Row(
             verticalAlignment = Alignment.CenterVertically,
-        modifier = Modifier.fillMaxWidth(),
+            modifier = Modifier.padding(start = 16.dp, end = 8.dp, top = 8.dp, bottom = 8.dp),
         ) {
-        Text(
+            Icon(
-            text = label,
+                imageVector = icon,
-            style = MaterialTheme.typography.titleMedium,
+                contentDescription = null,
-            modifier = Modifier.weight(1f),
+                tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.size(24.dp),
             )
-        IconButton(onClick = onRemove, modifier = Modifier.size(32.dp)) {
+            Spacer(Modifier.width(16.dp))
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleMedium,
+                    maxLines = titleMaxLines,
+                    overflow = TextOverflow.Ellipsis,
+                )
+                if (supporting != null) {
+                    Text(
+                        text = supporting,
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+            }
+            if (trailing != null) {
+                Spacer(Modifier.width(8.dp))
+                trailing()
+            }
+            IconButton(onClick = onRemove, modifier = Modifier.size(40.dp)) {
                 Icon(
                     imageVector = Icons.Default.Close,
-                contentDescription = stringResource(R.string.event_edit_remove_reminder),
+                    contentDescription = removeContentDescription,
-                modifier = Modifier.size(18.dp),
+                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.size(20.dp),
                 )
             }
         }
     }
+}
 
+/**
+ * One guest as a grouped-list card: avatar glyph, name/email, a tappable
+ * Required/Optional role chip, and remove. The email shows as the supporting
+ * line when a name is present, otherwise as the title.
+ */
 @Composable
-private fun AddReminderChip(onClick: () -> Unit) {
+private fun GuestCard(
-    AssistChip(
+    attendee: EventAttendee,
+    position: Position,
+    onToggleOptional: (Boolean) -> Unit,
+    onRemove: () -> Unit,
+) {
+    val hasName = attendee.name.isNotBlank()
+    GroupedItemCard(
+        position = position,
+        icon = Icons.Default.Person,
+        title = if (hasName) attendee.name else attendee.email,
+        supporting = attendee.email.takeIf { hasName },
+        titleMaxLines = 1,
+        removeContentDescription = stringResource(R.string.event_edit_remove_guest),
+        onRemove = onRemove,
+        trailing = {
+            FilterChip(
+                selected = attendee.optional,
+                onClick = { onToggleOptional(!attendee.optional) },
+                label = {
+                    Text(
+                        stringResource(
+                            if (attendee.optional) {
+                                R.string.event_edit_attendee_optional
+                            } else {
+                                R.string.event_edit_attendee_required
+                            },
+                        ),
+                    )
+                },
+            )
+        },
+    )
+}
+
+/** The trailing "Add …" action card of a grouped form list (opens a picker). */
+@Composable
+private fun AddActionCard(label: String, position: Position, onClick: () -> Unit) {
+    Surface(
         onClick = onClick,
-        label = { Text(stringResource(R.string.event_edit_add)) },
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
-        leadingIcon = {
+        shape = groupedShape(position),
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(groupedGap(position)),
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier.padding(horizontal = 16.dp, vertical = 14.dp),
+        ) {
             Icon(
                 imageVector = Icons.Default.Add,
                 contentDescription = null,
-                modifier = Modifier.size(16.dp),
+                tint = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.size(24.dp),
             )
-        },
+            Spacer(Modifier.width(16.dp))
-        border = null,
+            Text(
-        modifier = Modifier.fillMaxWidth(),
+                text = label,
+                style = MaterialTheme.typography.titleMedium,
+                color = MaterialTheme.colorScheme.primary,
             )
         }
+    }
+}
 
-private fun reminderUnitLabel(unit: ReminderUnit): Int = when (unit) {
+/**
-    ReminderUnit.Minutes -> R.string.reminder_unit_minutes
+ * The trailing card of the guests list: an inline email field plus a "from
-    ReminderUnit.Hours -> R.string.reminder_unit_hours
+ * contacts" button. Type an address and press Done (or tap +) to commit a guest;
-    ReminderUnit.Days -> R.string.reminder_unit_days
+ * or pick from contacts to fill email + name at once. The field clears after,
-    ReminderUnit.Weeks -> R.string.reminder_unit_weeks
+ * ready for the next. Matches the form's inline-field input style — no dialog.
+ */
+@Composable
+private fun AddGuestInlineCard(
+    position: Position,
+    onAdd: (String) -> Unit,
+    onPickContact: () -> Unit,
+) {
+    var text by rememberSaveable { mutableStateOf("") }
+    val valid = remember(text) { Patterns.EMAIL_ADDRESS.matcher(text.trim()).matches() }
+    fun commit() {
+        if (valid) {
+            onAdd(text.trim())
+            text = ""
         }
+    }
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        shape = groupedShape(position),
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(groupedGap(position)),
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier.padding(start = 16.dp, end = 8.dp, top = 8.dp, bottom = 8.dp),
+        ) {
+            Icon(
+                imageVector = Icons.Default.PersonAdd,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.size(24.dp),
+            )
+            Spacer(Modifier.width(16.dp))
+            InlineTextField(
+                value = text,
+                onValueChange = { text = it },
+                placeholder = stringResource(R.string.event_edit_add_guest_hint),
+                keyboardType = KeyboardType.Email,
+                imeAction = ImeAction.Done,
+                onImeAction = { commit() },
+                modifier = Modifier
+                    .weight(1f)
+                    .padding(vertical = 8.dp),
+            )
+            if (valid) {
+                IconButton(onClick = { commit() }, modifier = Modifier.size(40.dp)) {
+                    Icon(
+                        imageVector = Icons.Default.Add,
+                        contentDescription = stringResource(R.string.event_edit_add_guest),
+                        tint = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.size(22.dp),
+                    )
+                }
+            }
+            IconButton(onClick = onPickContact, modifier = Modifier.size(40.dp)) {
+                Icon(
+                    imageVector = Icons.Default.Contacts,
+                    contentDescription = stringResource(R.string.event_edit_add_guest_from_contacts),
+                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.size(22.dp),
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Read the email + display name from a contact-pick result URI. No
+ * READ_CONTACTS needed: ACTION_PICK grants this URI temporary read access.
+ */
+private fun readContactEmail(context: Context, uri: Uri): Pair<String, String>? =
+    context.contentResolver.query(
+        uri,
+        arrayOf(
+            ContactsContract.CommonDataKinds.Email.ADDRESS,
+            ContactsContract.Contacts.DISPLAY_NAME,
+        ),
+        null, null, null,
+    )?.use { cursor ->
+        if (!cursor.moveToFirst()) return@use null
+        val email = cursor.getString(0).orEmpty().trim()
+        val name = cursor.getString(1).orEmpty().trim()
+        email.takeIf { it.isNotEmpty() }?.let { it to name }
+    }
+
+/**
+ * Read the formatted postal address from a contact-pick result URI. No
+ * READ_CONTACTS needed: ACTION_PICK grants this URI temporary read access.
+ * The provider's formatted address is multi-line; collapse it to one line so
+ * it sits cleanly in the single-line location field.
+ */
+private fun readContactAddress(context: Context, uri: Uri): String? =
+    context.contentResolver.query(
+        uri,
+        arrayOf(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS),
+        null, null, null,
+    )?.use { cursor ->
+        if (!cursor.moveToFirst()) return@use null
+        cursor.getString(0).orEmpty()
+            .lines()
+            .map { it.trim() }
+            .filter { it.isNotEmpty() }
+            .joinToString(", ")
+            .takeIf { it.isNotEmpty() }
+    }
+
 
 private fun fieldLabel(field: EventFormField): Int = when (field) {
     EventFormField.Location -> R.string.event_detail_location
@@ -1392,6 +1651,7 @@ private fun fieldLabel(field: EventFormField): Int = when (field) {
     EventFormField.Availability -> R.string.event_edit_availability
     EventFormField.Visibility -> R.string.event_edit_visibility
     EventFormField.Color -> R.string.event_edit_color
+    EventFormField.Attendees -> R.string.event_edit_attendees
 }
 
 private fun fieldIcon(field: EventFormField): ImageVector = when (field) {
@@ -1402,6 +1662,7 @@ private fun fieldIcon(field: EventFormField): ImageVector = when (field) {
     EventFormField.Availability -> Icons.Default.EventAvailable
     EventFormField.Visibility -> Icons.Default.Lock
     EventFormField.Color -> Icons.Default.Palette
+    EventFormField.Attendees -> Icons.Default.People
 }
 
 /**
@@ -1517,16 +1778,7 @@ private fun accessLevelLabel(level: AccessLevel): Int = when (level) {
 
 /** Humanise a reminder lead time, mirroring the detail screen's rendering. */
 @Composable
-private fun reminderLabel(minutes: Int): String = when {
+private fun reminderLabel(minutes: Int): String = reminderLeadTimeLabel(minutes)
-    minutes <= 0 -> stringResource(R.string.reminder_at_time)
-    minutes % 10_080 == 0 ->
-        pluralStringResource(R.plurals.reminder_weeks, minutes / 10_080, minutes / 10_080)
-    minutes % 1_440 == 0 ->
-        pluralStringResource(R.plurals.reminder_days, minutes / 1_440, minutes / 1_440)
-    minutes % 60 == 0 ->
-        pluralStringResource(R.plurals.reminder_hours, minutes / 60, minutes / 60)
-    else -> pluralStringResource(R.plurals.reminder_minutes, minutes, minutes)
-}
 
 /**
  * One info card mirroring the detail screen's DetailCard: tonal container,
@@ -1687,31 +1939,6 @@ private fun ScheduleRow(
     }
 }
 
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-private fun TimePickerAlert(
-    initial: LocalTime,
-    onConfirm: (LocalTime) -> Unit,
-    onDismiss: () -> Unit,
-) {
-    val state = rememberTimePickerState(
-        initialHour = initial.hour,
-        initialMinute = initial.minute,
-    )
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        confirmButton = {
-            TextButton(onClick = { onConfirm(LocalTime(state.hour, state.minute)) }) {
-                Text(stringResource(R.string.dialog_ok))
-            }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismiss) { Text(stringResource(R.string.dialog_cancel)) }
-        },
-        text = { TimePicker(state = state) },
-    )
-}
-
 @Composable
 private fun CalendarPickerDialog(
     calendars: List<CalendarSource>,

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

@@ -8,10 +8,12 @@ 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.data.prefs.resolveDefaultReminder
 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.EventAttendee
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventFormField
@@ -29,6 +31,7 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOn
@@ -71,6 +74,10 @@ class EventEditViewModel @Inject constructor(
     // 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 once the user has hand-edited the reminders on a new event, which
+    // freezes the auto-applied default: switching calendars no longer overwrites
+    // their choice. Reset with the form.
+    private val _remindersTouched = MutableStateFlow(false)
 
     /** True when the event to edit couldn't be loaded; the screen closes itself. */
     val loadFailed: StateFlow<Boolean> = _loadFailed.asStateFlow()
@@ -100,6 +107,13 @@ class EventEditViewModel @Inject constructor(
         val editTarget: EditTarget?,
     )
 
+    private data class ReminderDefaults(
+        val timed: Int?,
+        val allDay: Int?,
+        val timedOverrides: Map<Long, Int?>,
+        val allDayOverrides: Map<Long, Int?>,
+    )
+
     private data class ExternalInputs(
         val writable: List<CalendarSource>,
         val lastUsed: Long?,
@@ -194,6 +208,63 @@ class EventEditViewModel @Inject constructor(
         }
         val end = (start.toInstant(zone) + 1.hours).toLocalDateTime(zone)
         _form.value = EventForm(calendarId = null, start = start, end = end)
+        applyDefaultReminder()
+    }
+
+    /**
+     * Seed a fresh event from a parsed `.ics` file (the single-event "open into
+     * the create form" path). [form] already carries the file's fields; its
+     * [EventForm.calendarId] is null so the calendar still resolves to the
+     * last-used/first-writable one, and reminders are frozen as touched so the
+     * settings default never overwrites what the file specified. No-op when a
+     * form is already open, so the prefill survives configuration changes.
+     */
+    fun openImported(form: EventForm) {
+        if (_form.value != null || _editTarget.value != null) return
+        _remindersTouched.value = true
+        _revealed.value = form.populatedFields()
+        _form.value = form
+    }
+
+    /**
+     * Prefill a new event's reminders from the settings default — the all-day
+     * default for all-day events, otherwise the resolved calendar's per-calendar
+     * override or the global timed default. No-op while editing an existing event
+     * or once the user has hand-edited the reminders, so the auto-default never
+     * clobbers a manual choice. [calendarId] short-circuits the resolution after a
+     * calendar switch; null resolves it as the form does.
+     */
+    private fun applyDefaultReminder(calendarId: Long? = null) {
+        if (_editTarget.value != null || _remindersTouched.value) return
+        viewModelScope.launch {
+            val defaults = combine(
+                settingsPrefs.defaultReminderMinutes,
+                settingsPrefs.defaultAllDayReminderMinutes,
+                settingsPrefs.perCalendarReminderOverride,
+                settingsPrefs.perCalendarAllDayReminderOverride,
+            ) { timed, allDay, timedOv, allDayOv ->
+                ReminderDefaults(timed, allDay, timedOv, allDayOv)
+            }.first()
+            val targetId = calendarId ?: resolvedCalendarId.first()
+            // Re-check after suspending: bail if the form closed or the user edited.
+            val form = _form.value ?: return@launch
+            if (_editTarget.value != null || _remindersTouched.value) return@launch
+            val default = resolveDefaultReminder(
+                timedGlobal = defaults.timed,
+                allDayGlobal = defaults.allDay,
+                timedOverrides = defaults.timedOverrides,
+                allDayOverrides = defaults.allDayOverrides,
+                calendarId = targetId,
+                isAllDay = form.isAllDay,
+            )
+            val reminders = listOfNotNull(default)
+            _form.value = form.copy(reminders = reminders)
+            // Surface the section so an auto-applied default is visible and
+            // removable, even when Reminders isn't a default-shown field.
+            if (reminders.isNotEmpty()) {
+                _revealed.value = _revealed.value + EventFormField.Reminders
+            }
+        }
     }
 
     /**
@@ -229,6 +300,7 @@ class EventEditViewModel @Inject constructor(
         _revealed.value = emptySet()
         _editTarget.value = null
         _loadFailed.value = false
+        _remindersTouched.value = false
     }
 
     /** Unfold one optional field, picked in the "more fields" dialog. */
@@ -239,14 +311,24 @@ class EventEditViewModel @Inject constructor(
     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) }
+    fun setAllDay(value: Boolean) {
+        update { it.copy(isAllDay = value) }
+        // The default reminder differs for all-day vs timed; re-apply the
+        // type-appropriate default unless the user has hand-edited it (guarded).
+        applyDefaultReminder()
+    }
 
     /**
      * 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 setCalendar(id: Long) {
+        update { it.copy(calendarId = id, colorKey = null, color = null) }
+        // A fresh event re-inherits the new calendar's default reminder unless
+        // the user has already hand-edited it (guarded inside).
+        applyDefaultReminder(id)
+    }
     fun setAvailability(value: Availability) = update { it.copy(availability = value) }
     fun setAccessLevel(value: AccessLevel) = update { it.copy(accessLevel = value) }
 
@@ -262,12 +344,41 @@ class EventEditViewModel @Inject constructor(
     /** 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 {
+    fun addReminder(minutes: Int) {
-        it.copy(reminders = (it.reminders + minutes).distinct().sorted())
+        _remindersTouched.value = true
+        update { it.copy(reminders = (it.reminders + minutes).distinct().sorted()) }
     }
 
-    fun removeReminder(minutes: Int) = update {
+    fun removeReminder(minutes: Int) {
-        it.copy(reminders = it.reminders - minutes)
+        _remindersTouched.value = true
+        update { it.copy(reminders = it.reminders - minutes) }
+    }
+
+    /**
+     * Add a guest, keyed on a trimmed lower-cased email so re-adding the same
+     * address just refreshes it (no duplicate row). A blank email is ignored —
+     * the email is what we write and dedup on.
+     */
+    fun addAttendee(email: String, name: String = "", optional: Boolean = false) {
+        val trimmed = email.trim()
+        if (trimmed.isEmpty()) return
+        update { form ->
+            val attendee = EventAttendee(email = trimmed, name = name.trim(), optional = optional)
+            val rest = form.attendees.filterNot { it.email.equals(trimmed, ignoreCase = true) }
+            form.copy(attendees = rest + attendee)
+        }
+    }
+
+    fun removeAttendee(attendee: EventAttendee) =
+        update { it.copy(attendees = it.attendees.filterNot { a -> a.email.equals(attendee.email, ignoreCase = true) }) }
+
+    /** Flip a guest between required and optional (the per-row role toggle). */
+    fun setAttendeeOptional(attendee: EventAttendee, optional: Boolean) = update { form ->
+        form.copy(
+            attendees = form.attendees.map { a ->
+                if (a.email.equals(attendee.email, ignoreCase = true)) a.copy(optional = optional) else a
+            },
+        )
     }
 
     /** Moving the start drags the end along, preserving the duration. */

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

@@ -0,0 +1,207 @@
+package de.jeanlucmakiola.calendula.ui.imports
+
+import android.net.Uri
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+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.Text
+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.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+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.EventForm
+import de.jeanlucmakiola.calendula.domain.ics.IcsParseWarning
+import de.jeanlucmakiola.calendula.ui.common.OptionCard
+
+/**
+ * Handles an opened/received `.ics` file. A single event is handed straight to
+ * the prefilled create form via [onOpenSingle]; several events show a target-
+ * calendar picker and import in bulk (dedup by UID), then a result summary.
+ * Empty/failed files show a short message and close.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun ImportScreen(
+    uri: Uri,
+    onClose: () -> Unit,
+    onOpenSingle: (EventForm) -> Unit,
+    viewModel: ImportViewModel = hiltViewModel(),
+) {
+    LaunchedEffect(uri) { viewModel.load(uri) }
+    val state by viewModel.state.collectAsStateWithLifecycle()
+    BackHandler(onBack = onClose)
+
+    // A single event isn't shown here — it opens the create form for review.
+    LaunchedEffect(state) {
+        (state as? ImportUiState.Single)?.let { onOpenSingle(it.form); onClose() }
+    }
+
+    Scaffold(
+        modifier = Modifier.fillMaxSize(),
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(R.string.import_title)) },
+                navigationIcon = {
+                    IconButton(onClick = onClose) {
+                        Icon(Icons.Default.Close, contentDescription = stringResource(R.string.event_edit_close))
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.surface,
+                ),
+            )
+        },
+    ) { padding ->
+        Box(Modifier.fillMaxSize().padding(padding)) {
+            when (val s = state) {
+                ImportUiState.Loading,
+                ImportUiState.Importing,
+                is ImportUiState.Single,
+                -> CircularProgressIndicator(Modifier.align(Alignment.Center))
+
+                ImportUiState.Empty -> CenteredMessage(stringResource(R.string.import_empty), onClose)
+                ImportUiState.Failed -> CenteredMessage(stringResource(R.string.import_failed), onClose)
+                is ImportUiState.Many -> ManyContent(s, onImport = viewModel::import)
+                is ImportUiState.Done -> DoneContent(s, onClose)
+            }
+        }
+    }
+}
+
+@Composable
+private fun ManyContent(state: ImportUiState.Many, onImport: (Long) -> Unit) {
+    // No writable calendar to import into — tell the user honestly.
+    if (state.calendars.isEmpty()) {
+        CenteredMessage(stringResource(R.string.import_no_calendar), onClose = null)
+        return
+    }
+    var selected by rememberSaveable { mutableStateOf(state.calendars.first().id) }
+
+    Column(
+        Modifier.fillMaxSize().verticalScroll(rememberScrollState())
+            .padding(horizontal = 16.dp, vertical = 8.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        Text(
+            pluralStringResource(R.plurals.import_event_count, state.events.size, state.events.size),
+            style = MaterialTheme.typography.bodyLarge,
+            modifier = Modifier.padding(vertical = 8.dp),
+        )
+        Text(
+            stringResource(R.string.import_target_header),
+            style = MaterialTheme.typography.labelLarge,
+            color = MaterialTheme.colorScheme.primary,
+        )
+        state.calendars.forEach { calendar ->
+            OptionCard(
+                label = calendar.displayName,
+                onClick = { selected = calendar.id },
+                selected = calendar.id == selected,
+                icon = null,
+            )
+        }
+        state.warnings.forEach { WarningText(it) }
+        Button(
+            onClick = { onImport(selected) },
+            modifier = Modifier.fillMaxWidth().padding(top = 8.dp),
+        ) {
+            Text(pluralStringResource(R.plurals.import_action, state.events.size, state.events.size))
+        }
+    }
+}
+
+@Composable
+private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
+    Column(
+        Modifier.fillMaxSize().padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Text(
+            stringResource(R.string.import_done_title),
+            style = MaterialTheme.typography.headlineSmall,
+            modifier = Modifier.padding(top = 24.dp),
+        )
+        Text(
+            pluralStringResource(
+                R.plurals.import_done_imported,
+                state.summary.imported,
+                state.summary.imported,
+            ),
+            style = MaterialTheme.typography.bodyLarge,
+        )
+        if (state.summary.skippedDuplicate > 0) {
+            Text(
+                pluralStringResource(
+                    R.plurals.import_done_skipped,
+                    state.summary.skippedDuplicate,
+                    state.summary.skippedDuplicate,
+                ),
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+        Button(onClick = onClose, modifier = Modifier.padding(top = 12.dp)) {
+            Text(stringResource(R.string.import_close))
+        }
+    }
+}
+
+@Composable
+private fun WarningText(warning: IcsParseWarning) {
+    val text = when (warning) {
+        IcsParseWarning.ModifiedOccurrenceSkipped -> stringResource(R.string.import_warning_recurrence)
+        IcsParseWarning.EventWithoutStartSkipped -> stringResource(R.string.import_warning_no_start)
+        IcsParseWarning.AttendeesIgnored -> stringResource(R.string.import_warning_attendees)
+        IcsParseWarning.UnknownTimezone -> stringResource(R.string.import_warning_timezone)
+    }
+    Text(
+        text = text,
+        style = MaterialTheme.typography.bodySmall,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+    )
+}
+
+@Composable
+private fun CenteredMessage(message: String, onClose: (() -> Unit)?) {
+    Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+        Column(
+            Modifier.padding(24.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Text(message, style = MaterialTheme.typography.bodyLarge)
+            if (onClose != null) {
+                Button(onClick = onClose) { Text(stringResource(R.string.import_close)) }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,105 @@
+package de.jeanlucmakiola.calendula.ui.imports
+
+import android.net.Uri
+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.data.ics.IcsImporter
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
+import de.jeanlucmakiola.calendula.domain.ics.IcsParseWarning
+import de.jeanlucmakiola.calendula.domain.ics.IcsParser
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
+import de.jeanlucmakiola.calendula.domain.ics.toEventForm
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.datetime.TimeZone
+import kotlin.coroutines.cancellation.CancellationException
+import javax.inject.Inject
+
+/** What an opened/received `.ics` resolved to. */
+sealed interface ImportUiState {
+    data object Loading : ImportUiState
+    data object Importing : ImportUiState
+
+    /** The file held no importable event (or couldn't be read/parsed as one). */
+    data object Empty : ImportUiState
+    data object Failed : ImportUiState
+
+    /** Exactly one event → review it in the prefilled create form. */
+    data class Single(val form: EventForm, val warnings: Set<IcsParseWarning>) : ImportUiState
+
+    /** Several events → pick a target calendar and bulk-import. */
+    data class Many(
+        val events: List<ParsedIcsEvent>,
+        val warnings: Set<IcsParseWarning>,
+        val calendars: List<CalendarSource>,
+    ) : ImportUiState
+
+    data class Done(val summary: IcsImportSummary) : ImportUiState
+}
+
+/**
+ * Reads an `.ics` [Uri], parses it (pure [IcsParser]) and routes by event count:
+ * one event opens the create form for review, many open the bulk-import picker.
+ * The bulk import dedups by UID in the repository.
+ */
+@HiltViewModel
+class ImportViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    private val importer: IcsImporter,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    private val parser = IcsParser()
+    private val _state = MutableStateFlow<ImportUiState>(ImportUiState.Loading)
+    val state: StateFlow<ImportUiState> = _state.asStateFlow()
+    private var started = false
+
+    /** Read + parse [uri] once; subsequent calls (recomposition) are ignored. */
+    fun load(uri: Uri) {
+        if (started) return
+        started = true
+        viewModelScope.launch {
+            val parsed = withContext(io) {
+                importer.readText(uri)?.let(parser::parse)
+            }
+            _state.value = when {
+                parsed == null -> ImportUiState.Failed
+                parsed.events.isEmpty() -> ImportUiState.Empty
+                parsed.events.size == 1 -> ImportUiState.Single(
+                    form = parsed.events.single().toEventForm(TimeZone.currentSystemDefault()),
+                    warnings = parsed.warnings,
+                )
+                else -> ImportUiState.Many(
+                    events = parsed.events,
+                    warnings = parsed.warnings,
+                    calendars = repository.calendars().first().filter { it.canModifyContents },
+                )
+            }
+        }
+    }
+
+    /** Bulk-import the parsed events into [targetCalendarId]; result → [ImportUiState.Done]. */
+    fun import(targetCalendarId: Long) {
+        val many = _state.value as? ImportUiState.Many ?: return
+        viewModelScope.launch {
+            _state.value = ImportUiState.Importing
+            _state.value = try {
+                ImportUiState.Done(repository.importEvents(targetCalendarId, many.events))
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                ImportUiState.Failed
+            }
+        }
+    }
+}

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

@@ -23,6 +23,7 @@ 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.Search
 import androidx.compose.material3.DrawerValue
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
@@ -86,6 +87,7 @@ fun MonthScreen(
     onSelectView: (CalendarView) -> Unit,
     onOpenDay: (LocalDate) -> Unit,
     onOpenSettings: () -> Unit,
+    onOpenSearch: () -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
     modifier: Modifier = Modifier,
     viewModel: MonthViewModel = hiltViewModel(),
@@ -161,6 +163,7 @@ fun MonthScreen(
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next()) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
+                    onOpenSearch = onOpenSearch,
                     scrollBehavior = scrollBehavior,
                 )
             },
@@ -261,6 +264,7 @@ private fun MonthTopBar(
     selectedView: CalendarView,
     onCycleView: () -> Unit,
     onOpenDrawer: () -> Unit,
+    onOpenSearch: () -> Unit,
     scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
     TopAppBar(
@@ -279,6 +283,12 @@ private fun MonthTopBar(
             }
         },
         actions = {
+            IconButton(onClick = onOpenSearch) {
+                Icon(
+                    imageVector = Icons.Default.Search,
+                    contentDescription = stringResource(R.string.search_action),
+                )
+            }
             ViewSwitcherPill(
                 current = selectedView,
                 onCycle = onCycleView,

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

@@ -0,0 +1,257 @@
+package de.jeanlucmakiola.calendula.ui.search
+
+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.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.SearchOff
+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.Surface
+import androidx.compose.material3.Text
+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.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.style.TextAlign
+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.EventInstance
+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.currentLocale
+import de.jeanlucmakiola.calendula.ui.common.pastelize
+import de.jeanlucmakiola.calendula.ui.common.positionOf
+import java.time.Instant as JavaInstant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.time.format.FormatStyle
+
+/**
+ * Full-text event search (top-bar entry). Type a query → matching events
+ * (title / location / description) across the whole calendar, newest-relevant
+ * first; tap a result to open its detail. A full-screen overlay hosted by
+ * [de.jeanlucmakiola.calendula.ui.CalendarHost].
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun SearchScreen(
+    onBack: () -> Unit,
+    onEventClick: (EventInstance) -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: SearchViewModel = hiltViewModel(),
+) {
+    val query by viewModel.query.collectAsStateWithLifecycle()
+    val state by viewModel.state.collectAsStateWithLifecycle()
+    val focusRequester = remember { FocusRequester() }
+    val keyboard = LocalSoftwareKeyboardController.current
+
+    // Each fresh open starts blank and straight into typing. The ViewModel is
+    // activity-scoped so it outlives the overlay; clearing on (re)enter is what
+    // resets a previous search. Peeking a result doesn't re-run this (the screen
+    // stays composed under the detail), so backing out keeps the query.
+    LaunchedEffect(Unit) {
+        viewModel.setQuery("")
+        focusRequester.requestFocus()
+        keyboard?.show()
+    }
+    BackHandler(onBack = onBack)
+
+    Scaffold(
+        modifier = modifier,
+        containerColor = MaterialTheme.colorScheme.surface,
+        topBar = {
+            TopAppBar(
+                title = {
+                    InlineTextField(
+                        value = query,
+                        onValueChange = viewModel::setQuery,
+                        placeholder = stringResource(R.string.search_hint),
+                        imeAction = ImeAction.Search,
+                        onImeAction = { keyboard?.hide() },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .focusRequester(focusRequester),
+                    )
+                },
+                navigationIcon = {
+                    IconButton(onClick = onBack) {
+                        Icon(
+                            imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                            contentDescription = stringResource(R.string.search_back),
+                        )
+                    }
+                },
+                actions = {
+                    if (query.isNotEmpty()) {
+                        IconButton(onClick = { viewModel.setQuery("") }) {
+                            Icon(
+                                imageVector = Icons.Default.Close,
+                                contentDescription = stringResource(R.string.search_clear),
+                            )
+                        }
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.surface,
+                ),
+            )
+        },
+    ) { padding ->
+        // imePadding shrinks the content by the keyboard, so the centered
+        // idle/empty message re-centres in the space above it (and the results
+        // list lifts clear of the keyboard too).
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(padding)
+                .imePadding(),
+        ) {
+            when (val s = state) {
+                SearchUiState.Idle -> SearchMessage(
+                    icon = null,
+                    text = stringResource(R.string.search_idle_hint),
+                )
+                is SearchUiState.Empty -> SearchMessage(
+                    icon = Icons.Default.SearchOff,
+                    text = stringResource(R.string.search_empty, s.query),
+                )
+                is SearchUiState.Results -> SearchResults(
+                    events = s.events,
+                    onEventClick = onEventClick,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun SearchResults(
+    events: List<EventInstance>,
+    onEventClick: (EventInstance) -> Unit,
+) {
+    LazyColumn(
+        modifier = Modifier.fillMaxSize(),
+        contentPadding = PaddingValues(start = 16.dp, end = 16.dp, top = 8.dp, bottom = 96.dp),
+    ) {
+        itemsIndexed(
+            items = events,
+            key = { _, event -> event.eventId },
+        ) { index, event ->
+            SearchResultRow(
+                event = event,
+                position = positionOf(index, events.size),
+                onClick = { onEventClick(event) },
+            )
+        }
+    }
+}
+
+@Composable
+private fun SearchResultRow(
+    event: EventInstance,
+    position: Position,
+    onClick: () -> Unit,
+) {
+    val dark = isSystemInDarkTheme()
+    GroupedRow(
+        title = event.title,
+        summary = searchSummary(event),
+        position = position,
+        minHeight = 64.dp,
+        leading = {
+            Box(
+                modifier = Modifier
+                    .size(width = 6.dp, height = 36.dp)
+                    .clip(RoundedCornerShape(3.dp))
+                    .background(pastelize(event.color, dark)),
+            )
+        },
+        onClick = onClick,
+    )
+}
+
+/** "Wed, 17 Jun 2026 · 09:00 · Office" — date, then time (or All day), then location. */
+@Composable
+private fun searchSummary(event: EventInstance): String {
+    val locale = currentLocale()
+    val zone = remember { ZoneId.systemDefault() }
+    val start = remember(event.start, zone) {
+        JavaInstant.ofEpochMilli(event.start.toEpochMilliseconds()).atZone(zone)
+    }
+    val dateText = remember(locale) {
+        DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
+    }.format(start)
+    val timeText = if (event.isAllDay) {
+        stringResource(R.string.event_detail_all_day)
+    } else {
+        remember(locale) {
+            DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale)
+        }.format(start)
+    }
+    val base = "$dateText · $timeText"
+    return event.location?.takeIf { it.isNotBlank() }?.let { "$base · $it" } ?: base
+}
+
+@Composable
+private fun SearchMessage(
+    icon: ImageVector?,
+    text: String,
+) {
+    Surface(color = MaterialTheme.colorScheme.surface, modifier = Modifier.fillMaxSize()) {
+        Column(
+            modifier = Modifier.fillMaxSize().padding(32.dp),
+            verticalArrangement = Arrangement.Center,
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            if (icon != null) {
+                Icon(
+                    imageVector = icon,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.size(48.dp),
+                )
+                Spacer(Modifier.height(16.dp))
+            }
+            Text(
+                text = text,
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                textAlign = TextAlign.Center,
+            )
+        }
+    }
+}

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

@@ -0,0 +1,77 @@
+package de.jeanlucmakiola.calendula.ui.search
+
+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.EventInstance
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.FlowPreview
+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.debounce
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapLatest
+import kotlinx.coroutines.flow.stateIn
+import kotlin.time.Clock
+import javax.inject.Inject
+
+/** Shortest query that triggers a search; one character matches almost everything. */
+private const val MIN_QUERY_LENGTH = 2
+
+sealed interface SearchUiState {
+    /** No query yet, or one too short to search — show the prompt. */
+    data object Idle : SearchUiState
+
+    /** A query ran but matched nothing. */
+    data class Empty(val query: String) : SearchUiState
+
+    /** Matches, ordered nearest-to-today first (upcoming ascending, then past descending). */
+    data class Results(val events: List<EventInstance>) : SearchUiState
+}
+
+@OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
+@HiltViewModel
+class SearchViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    private val _query = MutableStateFlow("")
+    val query: StateFlow<String> = _query.asStateFlow()
+
+    val state: StateFlow<SearchUiState> = _query
+        .debounce(250L)
+        .map { it.trim() }
+        .distinctUntilChanged()
+        .mapLatest { q ->
+            if (q.length < MIN_QUERY_LENGTH) {
+                SearchUiState.Idle
+            } else {
+                val results = repository.searchEvents(q)
+                if (results.isEmpty()) SearchUiState.Empty(q)
+                else SearchUiState.Results(sortNearestFirst(results))
+            }
+        }
+        .catch { emit(SearchUiState.Idle) }
+        .flowOn(io)
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000L), SearchUiState.Idle)
+
+    fun setQuery(value: String) {
+        _query.value = value
+    }
+
+    /** Soonest upcoming (and ongoing) first, then the most recent past. */
+    private fun sortNearestFirst(events: List<EventInstance>): List<EventInstance> {
+        val now = Clock.System.now()
+        val (upcoming, past) = events.partition { it.end >= now }
+        return upcoming.sortedBy { it.start } + past.sortedByDescending { it.start }
+    }
+}

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

@@ -1,36 +1,78 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
+import android.content.Context
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.core.os.LocaleListCompat
+import de.jeanlucmakiola.calendula.R
+import org.xmlpull.v1.XmlPullParser
+import java.util.Locale
 
-/** UI-facing language choice. AUTO follows the system languages. */
+private const val ANDROID_NS = "http://schemas.android.com/apk/res/android"
-enum class LanguagePref { AUTO, GERMAN, ENGLISH }
 
 /**
- * Per-app language via AppCompatDelegate. On API 33+ this delegates to the
+ * Per-app language via AppCompatDelegate, driven by res/xml/locales_config.xml.
- * platform per-app-languages API; below that the appcompat backport persists
+ *
- * the choice itself (manifest `autoStoreLocales` service), so we don't mirror
+ * That file is the single source of truth for which languages we ship: dropping
- * it in DataStore. Setting a locale recreates the activity, which re-reads the
+ * in a values-<tag> translation and adding a matching `<locale>` entry makes the
- * current value for the dropdown.
+ * language show up here and in the system per-app-language settings, with no
+ * other code change. The system-default choice is represented as `null`.
+ *
+ * On API 33+ this delegates to the platform per-app-languages API; below that
+ * the appcompat backport persists the choice itself (manifest `autoStoreLocales`
+ * service), so we don't mirror it in DataStore. Setting a locale recreates the
+ * activity, which re-reads the current value for the picker.
  */
 object AppLanguage {
 
-    fun current(): LanguagePref {
+    /**
-        val locales = AppCompatDelegate.getApplicationLocales()
+     * The BCP-47 tags the app ships translations for, in declaration order, as
-        if (locales.isEmpty) return LanguagePref.AUTO
+     * listed in locales_config.xml. Returns whatever could be parsed; a missing
-        return when (locales[0]?.language) {
+     * or malformed config yields an empty list (the picker then offers only the
-            "de" -> LanguagePref.GERMAN
+     * system-default entry rather than crashing).
-            "en" -> LanguagePref.ENGLISH
+     */
-            else -> LanguagePref.AUTO
+    fun supportedTags(context: Context): List<String> {
+        val tags = mutableListOf<String>()
+        val parser = context.resources.getXml(R.xml.locales_config)
+        try {
+            var event = parser.eventType
+            while (event != XmlPullParser.END_DOCUMENT) {
+                if (event == XmlPullParser.START_TAG && parser.name == "locale") {
+                    parser.getAttributeValue(ANDROID_NS, "name")?.let(tags::add)
                 }
+                event = parser.next()
+            }
+        } catch (_: Exception) {
+            // Fall back to whatever was parsed before the failure.
+        } finally {
+            parser.close()
+        }
+        return tags
     }
 
-    fun apply(pref: LanguagePref) {
+    /** The applied app language as a BCP-47 tag, or `null` when following the system. */
-        val locales = when (pref) {
+    fun currentTag(): String? {
-            LanguagePref.AUTO -> LocaleListCompat.getEmptyLocaleList()
+        val locales = AppCompatDelegate.getApplicationLocales()
-            LanguagePref.GERMAN -> LocaleListCompat.forLanguageTags("de")
+        return if (locales.isEmpty) null else locales[0]?.toLanguageTag()
-            LanguagePref.ENGLISH -> LocaleListCompat.forLanguageTags("en")
+    }
+
+    /** Apply a BCP-47 tag, or `null` to follow the system languages. */
+    fun apply(tag: String?) {
+        val locales = if (tag == null) {
+            LocaleListCompat.getEmptyLocaleList()
+        } else {
+            LocaleListCompat.forLanguageTags(tag)
         }
         AppCompatDelegate.setApplicationLocales(locales)
     }
+
+    /**
+     * The autonym for a tag — the language's own name in its own script, e.g.
+     * "Deutsch", "English", "Français" — so users find their language regardless
+     * of the current UI language. Capitalised per the language's own rules.
+     */
+    fun displayName(tag: String): String {
+        val locale = Locale.forLanguageTag(tag)
+        return locale.getDisplayName(locale)
+            .replaceFirstChar { if (it.isLowerCase()) it.titlecase(locale) else it.toString() }
+    }
 }

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

@@ -1,10 +1,17 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
 import android.Manifest
+import android.app.StatusBarManager
+import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
+import android.graphics.drawable.Icon
 import android.os.Build
+import android.os.PowerManager
+import android.provider.Settings
+import androidx.annotation.RequiresApi
+import android.text.format.DateFormat
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.animation.AnimatedVisibility
@@ -30,21 +37,24 @@ 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.BugReport
 import androidx.compose.material.icons.filled.CalendarMonth
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.ExpandLess
+import androidx.compose.material.icons.filled.ExpandMore
 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.MaterialTheme
 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.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -57,23 +67,40 @@ 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.pluralStringResource
 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.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.crash.CrashReporter
+import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
 import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.domain.EventFormField
+import de.jeanlucmakiola.calendula.qs.NewEventTileService
+import de.jeanlucmakiola.calendula.ui.crash.CrashReportDialog
+import de.jeanlucmakiola.calendula.ui.crash.openIssueTracker
+import de.jeanlucmakiola.calendula.ui.crash.submitCrashReport
 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.CalendarColorChip
+import de.jeanlucmakiola.calendula.ui.common.OptionPicker
 import de.jeanlucmakiola.calendula.ui.common.Position
+import de.jeanlucmakiola.calendula.ui.common.REMINDER_PRESETS
+import de.jeanlucmakiola.calendula.ui.common.ReminderDefaultPicker
+import de.jeanlucmakiola.calendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.calendula.ui.common.positionOf
+import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
+import kotlinx.datetime.LocalTime
+import java.util.Calendar
 
 /** The settings sub-screens reached from the hub's category rows. */
 private enum class SettingsSection { Appearance, EventForm, Notifications }
@@ -180,19 +207,59 @@ private fun SettingsHub(
             leading = { CategoryIcon(Icons.Default.CalendarMonth, ChipAccent.Tertiary) },
             onClick = onManageCalendars,
         )
-        LanguageRow(position = Position.Bottom)
+        LanguageRow(position = Position.Middle)
+        ReportProblemRow(position = Position.Bottom)
 
         AppVersionText()
     }
 }
 
+/**
+ * Opens the project's issue tracker to report a problem. If a crash report was
+ * captured (and not yet sent), it surfaces that report first via the same
+ * dialog the next-launch prompt uses; otherwise it opens the issue template
+ * chooser. No data leaves the device until the user submits the issue.
+ */
+@Composable
+private fun ReportProblemRow(position: Position) {
+    val context = LocalContext.current
+    var report by remember { mutableStateOf<String?>(null) }
+
+    GroupedRow(
+        title = stringResource(R.string.settings_report_problem),
+        summary = stringResource(R.string.settings_report_problem_hint),
+        position = position,
+        leading = { CategoryIcon(Icons.Default.BugReport, ChipAccent.Neutral) },
+        onClick = {
+            val pending = CrashReporter.pendingReport(context)
+            if (pending != null) report = pending else openIssueTracker(context)
+        },
+    )
+
+    report?.let { pending ->
+        CrashReportDialog(
+            report = pending,
+            onSend = {
+                submitCrashReport(context, pending)
+                CrashReporter.clearReport(context)
+                report = null
+            },
+            onDismiss = { report = null },
+        )
+    }
+}
+
 @Composable
 private fun LanguageRow(position: Position) {
+    val context = LocalContext.current
     // Setting a locale recreates the activity; mirror the choice locally so the
     // row updates instantly even before the recreation lands.
-    var current by remember { mutableStateOf(AppLanguage.current()) }
+    var current by remember { mutableStateOf(AppLanguage.currentTag()) }
     var showDialog by remember { mutableStateOf(false) }
 
+    // null = follow the system; the rest are BCP-47 tags from locales_config.xml.
+    val options = remember { listOf<String?>(null) + AppLanguage.supportedTags(context) }
+
     GroupedRow(
         title = stringResource(R.string.settings_language),
         summary = languageLabel(current),
@@ -202,9 +269,9 @@ private fun LanguageRow(position: Position) {
     )
 
     if (showDialog) {
-        OptionPickerDialog(
+        OptionPicker(
             title = stringResource(R.string.settings_language),
-            options = LanguagePref.entries,
+            options = options,
             selected = current,
             label = { languageLabel(it) },
             onSelect = {
@@ -378,7 +445,7 @@ private fun AppearanceScreen(
     }
 
     if (showTheme) {
-        OptionPickerDialog(
+        OptionPicker(
             title = stringResource(R.string.settings_theme),
             options = ThemeMode.entries,
             selected = state.themeMode,
@@ -388,7 +455,7 @@ private fun AppearanceScreen(
         )
     }
     if (showWeekStart) {
-        OptionPickerDialog(
+        OptionPicker(
             title = stringResource(R.string.settings_week_start),
             options = WeekStartPref.entries,
             selected = state.weekStart,
@@ -452,8 +519,38 @@ private fun EventFormScreen(
                 )
             },
         )
+
+        // One-tap add of the "New event" Quick Settings tile. The system prompt
+        // is API 33+; on older versions the tile is still addable manually from
+        // the QS editor, so the row simply doesn't appear there.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            Spacer(Modifier.height(24.dp))
+            val context = LocalContext.current
+            GroupedRow(
+                title = stringResource(R.string.settings_qs_tile),
+                summary = stringResource(R.string.settings_qs_tile_hint),
+                position = Position.Alone,
+                onClick = { requestAddQsTile(context) },
+            )
         }
     }
+}
+
+/**
+ * Ask the system to add the "New event" Quick Settings tile (API 33+). The OS
+ * shows its own confirmation dialog and handles the already-added case, so no
+ * result handling is needed here.
+ */
+@RequiresApi(Build.VERSION_CODES.TIRAMISU)
+private fun requestAddQsTile(context: Context) {
+    val statusBar = context.getSystemService(StatusBarManager::class.java) ?: return
+    statusBar.requestAddTileService(
+        ComponentName(context, NewEventTileService::class.java),
+        context.getString(R.string.qs_tile_new_event_label),
+        Icon.createWithResource(context, R.drawable.ic_qs_new_event),
+        context.mainExecutor,
+    ) { /* result code unused — the system surfaces its own feedback */ }
+}
 
 /**
  * Reminder-notifications toggle (v1.4), mirroring the onboarding step.
@@ -482,6 +579,13 @@ private fun NotificationsScreen(
         }
     }
 
+    var showDefaultReminder by remember { mutableStateOf(false) }
+    var showAllDayReminder by remember { mutableStateOf(false) }
+    var showAllDayReminderTime by remember { mutableStateOf(false) }
+    var showSnooze by remember { mutableStateOf(false) }
+    var overrideDialog by remember { mutableStateOf<OverrideTarget?>(null) }
+    var expandedCalendars by remember { mutableStateOf(emptySet<Long>()) }
+
     CollapsingScaffold(
         title = stringResource(R.string.settings_section_notifications),
         onBack = onBack,
@@ -489,13 +593,304 @@ private fun NotificationsScreen(
         GroupedRow(
             title = stringResource(R.string.settings_reminders),
             summary = stringResource(R.string.settings_reminders_hint),
-            position = Position.Alone,
+            position = Position.Top,
             trailing = {
                 Switch(checked = state.remindersEnabled, onCheckedChange = toggleReminders)
             },
             onClick = { toggleReminders(!state.remindersEnabled) },
         )
+        GroupedRow(
+            title = stringResource(R.string.settings_default_reminder),
+            summary = reminderChoiceLabel(state.defaultReminderMinutes),
+            position = Position.Middle,
+            onClick = { showDefaultReminder = true },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_default_reminder_allday),
+            summary = reminderChoiceLabel(state.defaultAllDayReminderMinutes),
+            position = Position.Middle,
+            onClick = { showAllDayReminder = true },
+        )
+        GroupedRow(
+            title = stringResource(R.string.settings_allday_reminder_time),
+            summary = stringResource(
+                R.string.settings_allday_reminder_time_hint,
+                formatTimeOfDay(context, state.allDayReminderTimeMinutes),
+            ),
+            position = Position.Bottom,
+            onClick = { showAllDayReminderTime = true },
+        )
+
+        // Per-calendar overrides: each writable calendar may keep, drop, or
+        // replace the global default — separately for timed and all-day events.
+        if (state.writableCalendars.isNotEmpty()) {
+            Spacer(Modifier.height(24.dp))
+            Text(
+                text = stringResource(R.string.settings_calendar_reminders_hint),
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp),
+            )
+            state.writableCalendars.forEach { calendar ->
+                Spacer(Modifier.height(16.dp))
+                val expanded = calendar.id in expandedCalendars
+                // Calendar card; tapping expands it into a grouped list of three
+                // (the card + the timed and all-day override rows).
+                GroupedRow(
+                    title = calendar.displayName,
+                    position = if (expanded) Position.Top else Position.Alone,
+                    leading = { CalendarColorChip(calendar.color) },
+                    trailing = {
+                        Icon(
+                            imageVector = if (expanded) Icons.Default.ExpandLess else Icons.Default.ExpandMore,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    },
+                    onClick = {
+                        expandedCalendars = if (expanded) {
+                            expandedCalendars - calendar.id
+                        } else {
+                            expandedCalendars + calendar.id
                         }
+                    },
+                )
+                AnimatedVisibility(visible = expanded) {
+                    Column {
+                        val timed = state.perCalendarReminderOverride.choiceFor(calendar.id)
+                        GroupedRow(
+                            title = stringResource(R.string.settings_default_reminder),
+                            summary = calendarOverrideSummary(timed, state.defaultReminderMinutes),
+                            position = Position.Middle,
+                            onClick = { overrideDialog = OverrideTarget(calendar.id, isAllDay = false) },
+                        )
+                        val allDay = state.perCalendarAllDayReminderOverride.choiceFor(calendar.id)
+                        GroupedRow(
+                            title = stringResource(R.string.settings_default_reminder_allday),
+                            summary = calendarOverrideSummary(allDay, state.defaultAllDayReminderMinutes),
+                            position = Position.Bottom,
+                            onClick = { overrideDialog = OverrideTarget(calendar.id, isAllDay = true) },
+                        )
+                    }
+                }
+            }
+        }
+
+        // Delivery reliability: Android's battery optimisation can delay or drop
+        // the calendar provider's reminder broadcast. A soft, optional exemption
+        // (system-settings deep-link, no special permission) improves on-time
+        // delivery; shown as live status, reversible by the user at any time.
+        Spacer(Modifier.height(24.dp))
+        val batteryExempt = rememberBatteryOptimizationExempt()
+        GroupedRow(
+            title = stringResource(R.string.settings_reliable_delivery),
+            summary = if (batteryExempt) {
+                stringResource(R.string.settings_reliable_delivery_exempt)
+            } else {
+                stringResource(R.string.settings_reliable_delivery_hint)
+            },
+            position = Position.Alone,
+            trailing = if (batteryExempt) {
+                {
+                    Icon(
+                        imageVector = Icons.Default.Check,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.primary,
+                    )
+                }
+            } else {
+                null
+            },
+            onClick = { openBatteryOptimizationSettings(context) },
+        )
+
+        // Snooze: how long the notification's "Snooze" action defers a reminder.
+        Spacer(Modifier.height(24.dp))
+        GroupedRow(
+            title = stringResource(R.string.settings_snooze_duration),
+            summary = snoozeDurationLabel(state.snoozeMinutes),
+            position = Position.Alone,
+            onClick = { showSnooze = true },
+        )
+    }
+
+    if (showSnooze) {
+        OptionPicker(
+            title = stringResource(R.string.settings_snooze_duration),
+            options = SNOOZE_PRESETS,
+            selected = state.snoozeMinutes,
+            label = { snoozeDurationLabel(it) },
+            onSelect = { viewModel.setSnoozeMinutes(it) },
+            onDismiss = { showSnooze = false },
+        )
+    }
+    if (showDefaultReminder) {
+        ReminderDefaultPicker(
+            title = stringResource(R.string.settings_default_reminder),
+            presets = REMINDER_PRESETS,
+            selected = state.defaultReminderMinutes.toReminderChoice(),
+            allowInherit = false,
+            onSelect = { viewModel.setDefaultReminderMinutes(it.toMinutesOrNull()) },
+            onDismiss = { showDefaultReminder = false },
+        )
+    }
+    if (showAllDayReminder) {
+        ReminderDefaultPicker(
+            title = stringResource(R.string.settings_default_reminder_allday),
+            presets = ALLDAY_REMINDER_PRESETS,
+            selected = state.defaultAllDayReminderMinutes.toReminderChoice(),
+            allowInherit = false,
+            onSelect = { viewModel.setDefaultAllDayReminderMinutes(it.toMinutesOrNull()) },
+            onDismiss = { showAllDayReminder = false },
+        )
+    }
+    if (showAllDayReminderTime) {
+        TimePickerAlert(
+            initial = LocalTime(
+                state.allDayReminderTimeMinutes / 60,
+                state.allDayReminderTimeMinutes % 60,
+            ),
+            onConfirm = {
+                viewModel.setAllDayReminderTimeMinutes(it.hour * 60 + it.minute)
+                showAllDayReminderTime = false
+            },
+            onDismiss = { showAllDayReminderTime = false },
+        )
+    }
+    overrideDialog?.let { target ->
+        val map = if (target.isAllDay) {
+            state.perCalendarAllDayReminderOverride
+        } else {
+            state.perCalendarReminderOverride
+        }
+        ReminderDefaultPicker(
+            title = stringResource(
+                if (target.isAllDay) {
+                    R.string.settings_default_reminder_allday
+                } else {
+                    R.string.settings_default_reminder
+                },
+            ),
+            presets = if (target.isAllDay) ALLDAY_REMINDER_PRESETS else REMINDER_PRESETS,
+            selected = map.choiceFor(target.calendarId),
+            allowInherit = true,
+            onSelect = {
+                if (target.isAllDay) {
+                    viewModel.setCalendarAllDayReminderOverride(target.calendarId, it)
+                } else {
+                    viewModel.setCalendarReminderOverride(target.calendarId, it)
+                }
+            },
+            onDismiss = { overrideDialog = null },
+        )
+    }
+}
+
+/** Which calendar + event kind a per-calendar reminder-override dialog targets. */
+private data class OverrideTarget(val calendarId: Long, val isAllDay: Boolean)
+
+/** A global default (null = none) as a picker choice for selection highlighting. */
+private fun Int?.toReminderChoice(): CalendarReminderOverride =
+    if (this == null) CalendarReminderOverride.None else CalendarReminderOverride.Minutes(this)
+
+/** A picked choice as global-default minutes (Inherit isn't offered for globals). */
+private fun CalendarReminderOverride.toMinutesOrNull(): Int? =
+    (this as? CalendarReminderOverride.Minutes)?.minutes
+
+/**
+ * Whether Calendula is exempt from battery optimisation, re-read on every
+ * `ON_RESUME` so the row reflects a change the user just made in system
+ * settings without needing to leave and re-enter the screen.
+ */
+@Composable
+private fun rememberBatteryOptimizationExempt(): Boolean {
+    val context = LocalContext.current
+    var exempt by remember { mutableStateOf(isIgnoringBatteryOptimizations(context)) }
+    val lifecycleOwner = LocalLifecycleOwner.current
+    DisposableEffect(lifecycleOwner) {
+        val observer = LifecycleEventObserver { _, event ->
+            if (event == Lifecycle.Event.ON_RESUME) {
+                exempt = isIgnoringBatteryOptimizations(context)
+            }
+        }
+        lifecycleOwner.lifecycle.addObserver(observer)
+        onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
+    }
+    return exempt
+}
+
+private fun isIgnoringBatteryOptimizations(context: Context): Boolean {
+    val power = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+    return power.isIgnoringBatteryOptimizations(context.packageName)
+}
+
+/**
+ * Take the user straight to Calendula's exemption: the direct
+ * `REQUEST_IGNORE_BATTERY_OPTIMIZATIONS` dialog ("Allow Calendula to ignore
+ * battery optimisation?") rather than the full app list they'd have to scroll.
+ * Falls back to the optimisation list if the OS refuses the direct intent.
+ */
+private fun openBatteryOptimizationSettings(context: Context) {
+    val direct = Intent(
+        Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS,
+        "package:${context.packageName}".toUri(),
+    )
+    if (runCatching { context.startActivity(direct) }.isFailure) {
+        runCatching {
+            context.startActivity(Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS))
+        }
+    }
+}
+
+/**
+ * Lead times offered for the all-day default — day-scale, since a "minutes
+ * before midnight" reminder on an all-day event is rarely what's wanted.
+ */
+private val ALLDAY_REMINDER_PRESETS = listOf(0, 1_440, 2_880, 10_080)
+
+/** Snooze delays offered for the notification "Snooze" action, in minutes. */
+private val SNOOZE_PRESETS = listOf(5, 10, 15, 30, 60)
+
+/** A snooze delay as a plain duration ("10 minutes", "1 hour") — no "before". */
+@Composable
+private fun snoozeDurationLabel(minutes: Int): String =
+    if (minutes % 60 == 0) {
+        pluralStringResource(R.plurals.duration_hours, minutes / 60, minutes / 60)
+    } else {
+        pluralStringResource(R.plurals.duration_minutes, minutes, minutes)
+    }
+
+/** A minute-of-day formatted in the device's 12/24-hour convention (e.g. "09:00"). */
+private fun formatTimeOfDay(context: Context, minutesOfDay: Int): String {
+    val time = Calendar.getInstance().apply {
+        set(Calendar.HOUR_OF_DAY, minutesOfDay / 60)
+        set(Calendar.MINUTE, minutesOfDay % 60)
+    }.time
+    return DateFormat.getTimeFormat(context).format(time)
+}
+
+/** The stored override for [calendarId], as a picker choice (absent → inherit). */
+private fun Map<Long, Int?>.choiceFor(calendarId: Long): CalendarReminderOverride = when {
+    !containsKey(calendarId) -> CalendarReminderOverride.Inherit
+    this[calendarId] == null -> CalendarReminderOverride.None
+    else -> CalendarReminderOverride.Minutes(this.getValue(calendarId)!!)
+}
+
+/** Label for a global-default choice: null → "None", else the lead time. */
+@Composable
+private fun reminderChoiceLabel(minutes: Int?): String =
+    if (minutes == null) stringResource(R.string.reminder_none) else reminderLeadTimeLabel(minutes)
+
+/** Row summary for a calendar: its override, or the inherited global default. */
+@Composable
+private fun calendarOverrideSummary(
+    choice: CalendarReminderOverride,
+    globalDefault: Int?,
+): String = when (choice) {
+    CalendarReminderOverride.Inherit ->
+        stringResource(R.string.settings_calendar_reminder_inherits, reminderChoiceLabel(globalDefault))
+    CalendarReminderOverride.None -> stringResource(R.string.reminder_none)
+    is CalendarReminderOverride.Minutes -> reminderLeadTimeLabel(choice.minutes)
 }
 
 // ---------------------------------------------------------------------------
@@ -531,38 +926,6 @@ private fun CategoryIcon(icon: ImageVector, accent: ChipAccent) {
     }
 }
 
-/** 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())
@@ -577,6 +940,7 @@ private fun formFieldLabel(field: EventFormField): Int = when (field) {
     EventFormField.Availability -> R.string.event_edit_availability
     EventFormField.Visibility -> R.string.event_edit_visibility
     EventFormField.Color -> R.string.event_edit_color
+    EventFormField.Attendees -> R.string.event_edit_attendees
 }
 
 @Composable
@@ -598,10 +962,5 @@ private fun weekStartLabel(pref: WeekStartPref): String = stringResource(
 )
 
 @Composable
-private fun languageLabel(pref: LanguagePref): String = stringResource(
+private fun languageLabel(tag: String?): String =
-    when (pref) {
+    if (tag == null) stringResource(R.string.settings_language_auto) else AppLanguage.displayName(tag)
-        LanguagePref.AUTO -> R.string.settings_language_auto
-        LanguagePref.GERMAN -> R.string.settings_language_german
-        LanguagePref.ENGLISH -> R.string.settings_language_english
-    },
-)

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

@@ -3,6 +3,7 @@ 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.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
 
 /**
@@ -20,6 +21,27 @@ data class SettingsUiState(
     val defaultFormFields: Set<EventFormField> = SettingsPrefs.DEFAULT_FORM_FIELDS,
     /** Whether Calendula posts reminder notifications (v1.4). */
     val remindersEnabled: Boolean = true,
+    /**
+     * The default reminder lead time (minutes) prefilled on new timed events;
+     * null = no default reminder. Per-calendar overrides take precedence.
+     */
+    val defaultReminderMinutes: Int? = null,
+    /** The default reminder lead time prefilled on new all-day events; null = none. */
+    val defaultAllDayReminderMinutes: Int? = null,
+    /** Wall-clock time (minutes from midnight) all-day reminders fire at; default 09:00. */
+    val allDayReminderTimeMinutes: Int = SettingsPrefs.DEFAULT_ALLDAY_REMINDER_TIME,
+    /** How long the notification "Snooze" action defers a reminder; default 10 min. */
+    val snoozeMinutes: Int = SettingsPrefs.DEFAULT_SNOOZE_MINUTES,
+    /**
+     * Per-calendar overrides of [defaultReminderMinutes] for timed events: a
+     * calendar present in the map overrides the global default (null value = no
+     * reminder); absent = inherit the global default.
+     */
+    val perCalendarReminderOverride: Map<Long, Int?> = emptyMap(),
+    /** Per-calendar overrides of [defaultAllDayReminderMinutes] for all-day events. */
+    val perCalendarAllDayReminderOverride: Map<Long, Int?> = emptyMap(),
+    /** Writable calendars, shown as per-calendar reminder-override rows. */
+    val writableCalendars: List<CalendarSource> = emptyList(),
     /**
      * Whether the event-colour picker is offered on calendars that publish no
      * colour palette (the colour may then not survive their next sync).

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

@@ -4,13 +4,19 @@ import android.os.Build
 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.prefs.CalendarReminderOverride
 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.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import javax.inject.Inject
@@ -18,14 +24,20 @@ import javax.inject.Inject
 @HiltViewModel
 class SettingsViewModel @Inject constructor(
     private val prefs: SettingsPrefs,
+    repository: CalendarRepository,
 ) : ViewModel() {
 
     private val dynamicColorAvailable = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
 
+    /** Writable calendars — the only ones that take a per-calendar reminder override. */
+    private val writableCalendars: Flow<List<CalendarSource>> = repository.calendars()
+        .map { calendars -> calendars.filter { it.canModifyContents } }
+        .catch { emit(emptyList()) }
+
     val state: StateFlow<SettingsUiState> =
         combine(
-            // combine() only types up to five flows, so the sixth pref folds
+            // combine() types up to five flows, so the prefs split into two
-            // into the assembled state in an outer combine.
+            // groups that fold together in the outer combine.
             combine(
                 prefs.themeMode,
                 prefs.dynamicColor,
@@ -42,15 +54,55 @@ class SettingsViewModel @Inject constructor(
                     remindersEnabled = reminders,
                 )
             },
+            combine(
                 prefs.allowColorOnUnsupportedCalendars,
-        ) { base, allowColor ->
+                prefs.defaultReminderMinutes,
-            base.copy(allowColorOnUnsupportedCalendars = allowColor)
+                prefs.defaultAllDayReminderMinutes,
+                prefs.allDayReminderTimeMinutes,
+                prefs.snoozeMinutes,
+            ) { allowColor, defaultReminder, allDayReminder, allDayReminderTime, snooze ->
+                ReminderDefaults(
+                    allowColor, defaultReminder, allDayReminder, allDayReminderTime, snooze,
+                )
+            },
+            combine(
+                prefs.perCalendarReminderOverride,
+                prefs.perCalendarAllDayReminderOverride,
+                writableCalendars,
+            ) { overrides, allDayOverrides, calendars ->
+                ReminderOverrides(overrides, allDayOverrides, calendars)
+            },
+        ) { base, defaults, overrides ->
+            base.copy(
+                allowColorOnUnsupportedCalendars = defaults.allowColor,
+                defaultReminderMinutes = defaults.defaultReminder,
+                defaultAllDayReminderMinutes = defaults.allDayReminder,
+                allDayReminderTimeMinutes = defaults.allDayReminderTime,
+                snoozeMinutes = defaults.snoozeMinutes,
+                perCalendarReminderOverride = overrides.timed,
+                perCalendarAllDayReminderOverride = overrides.allDay,
+                writableCalendars = overrides.calendars,
+            )
         }.stateIn(
             scope = viewModelScope,
             started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = SettingsUiState(dynamicColorAvailable = dynamicColorAvailable),
         )
 
+    private data class ReminderDefaults(
+        val allowColor: Boolean,
+        val defaultReminder: Int?,
+        val allDayReminder: Int?,
+        val allDayReminderTime: Int,
+        val snoozeMinutes: Int,
+    )
+
+    private data class ReminderOverrides(
+        val timed: Map<Long, Int?>,
+        val allDay: Map<Long, Int?>,
+        val calendars: List<CalendarSource>,
+    )
+
     fun setThemeMode(mode: ThemeMode) {
         viewModelScope.launch { prefs.setThemeMode(mode) }
     }
@@ -71,6 +123,30 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setRemindersEnabled(enabled) }
     }
 
+    fun setDefaultReminderMinutes(minutes: Int?) {
+        viewModelScope.launch { prefs.setDefaultReminderMinutes(minutes) }
+    }
+
+    fun setDefaultAllDayReminderMinutes(minutes: Int?) {
+        viewModelScope.launch { prefs.setDefaultAllDayReminderMinutes(minutes) }
+    }
+
+    fun setAllDayReminderTimeMinutes(minutesOfDay: Int) {
+        viewModelScope.launch { prefs.setAllDayReminderTimeMinutes(minutesOfDay) }
+    }
+
+    fun setSnoozeMinutes(minutes: Int) {
+        viewModelScope.launch { prefs.setSnoozeMinutes(minutes) }
+    }
+
+    fun setCalendarReminderOverride(calendarId: Long, override: CalendarReminderOverride) {
+        viewModelScope.launch { prefs.setCalendarReminderOverride(calendarId, override) }
+    }
+
+    fun setCalendarAllDayReminderOverride(calendarId: Long, override: CalendarReminderOverride) {
+        viewModelScope.launch { prefs.setCalendarAllDayReminderOverride(calendarId, override) }
+    }
+
     fun setAllowColorOnUnsupportedCalendars(enabled: Boolean) {
         viewModelScope.launch { prefs.setAllowColorOnUnsupportedCalendars(enabled) }
     }

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

@@ -29,6 +29,7 @@ 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.Search
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.DrawerValue
@@ -76,6 +77,7 @@ 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.NowLine
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
@@ -113,6 +115,7 @@ fun WeekScreen(
     onSelectView: (CalendarView) -> Unit,
     onEventClick: (EventInstance) -> Unit,
     onOpenSettings: () -> Unit,
+    onOpenSearch: () -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
     modifier: Modifier = Modifier,
     viewModel: WeekViewModel = hiltViewModel(),
@@ -193,6 +196,7 @@ fun WeekScreen(
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next()) },
                     onOpenDrawer = { scope.launch { drawerState.open() } },
+                    onOpenSearch = onOpenSearch,
                     scrollBehavior = scrollBehavior,
                 )
             },
@@ -351,6 +355,7 @@ private fun WeekTopBar(
     selectedView: CalendarView,
     onCycleView: () -> Unit,
     onOpenDrawer: () -> Unit,
+    onOpenSearch: () -> Unit,
     scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
     TopAppBar(
@@ -369,6 +374,12 @@ private fun WeekTopBar(
             }
         },
         actions = {
+            IconButton(onClick = onOpenSearch) {
+                Icon(
+                    imageVector = Icons.Default.Search,
+                    contentDescription = stringResource(R.string.search_action),
+                )
+            }
             ViewSwitcherPill(
                 current = selectedView,
                 onCycle = onCycleView,
@@ -610,6 +621,7 @@ private fun Timeline(
                             blocks = state.timedByDay[day].orEmpty(),
                             dark = dark,
                             date = day,
+                            today = state.today,
                             onEventClick = onEventClick,
                             onCreateAt = onCreateAt,
                             modifier = Modifier
@@ -628,6 +640,7 @@ private fun DayColumnCard(
     blocks: List<TimedBlock>,
     dark: Boolean,
     date: LocalDate,
+    today: LocalDate,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     modifier: Modifier = Modifier,
@@ -671,6 +684,10 @@ private fun DayColumnCard(
                         .padding(horizontal = 1.dp),
                 )
             }
+            // Current-time line, on top of the events, only on today's column.
+            if (date == today) {
+                NowLine(date = date, hourHeight = HOUR_HEIGHT)
+            }
         }
     }
 }

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

@@ -181,6 +181,18 @@ internal fun weekRange(start: LocalDate, zone: TimeZone): ClosedRange<Instant> {
 
 /** True if this event overlaps the calendar [day] in [zone] (any portion). */
 internal fun EventInstance.coversDay(day: LocalDate, zone: TimeZone): Boolean {
+    if (isAllDay) {
+        // All-day events live at UTC midnights with an exclusive end. Compare
+        // calendar dates in UTC and step the exclusive end back to the last
+        // covered day (mirroring the detail/edit views), so a one-day event
+        // covers exactly its single date. Slicing the day in the device zone
+        // would push the exclusive end a few hours into the next local day
+        // east of UTC, making the event leak onto day + 1.
+        val startDate = start.toLocalDateTime(TimeZone.UTC).date
+        val endExclusive = end.toLocalDateTime(TimeZone.UTC).date
+        val lastDay = maxOf(startDate, endExclusive.minus(1, DateTimeUnit.DAY))
+        return day in startDate..lastDay
+    }
     val dayStart = day.atStartOfDayIn(zone)
     val dayEnd = day.plus(1, DateTimeUnit.DAY).atStartOfDayIn(zone)
     return start < dayEnd && end > dayStart

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

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Monochrome notification-action mark: Material "close" 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,6.41L17.59,5 12,10.59 6.41,5 5,6.41 10.59,12 5,17.59 6.41,19 12,13.41 17.59,19 19,17.59 13.41,12z" />
+</vector>

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

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Monochrome notification-action mark: Material "snooze" 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="M7.88,3.39L6.6,1.86 2,5.71l1.29,1.53 4.59,-3.85zM22,5.72l-4.6,-3.86 -1.29,1.53 4.6,3.86L22,5.72zM12,4c-4.97,0 -9,4.03 -9,9s4.02,9 9,9c4.97,0 9,-4.03 9,-9s-4.03,-9 -9,-9zM12,20c-3.87,0 -7,-3.13 -7,-7s3.13,-7 7,-7 7,3.13 7,7 -3.13,7 -7,7zM9,11h3.63L9,15.2L9,17h6v-2h-3.63L15,10.8L15,9L9,9z" />
+</vector>

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

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Quick Settings tile icon ("New event"): a flat calendar+plus glyph. QS tile
+     icons are tinted by the system from their alpha, so this is a bare white
+     glyph on a transparent background (no brand circle, unlike the launcher
+     shortcut icon). -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24"
+    android:tint="#FFFFFFFF">
+    <path
+        android:fillColor="#FFFFFFFF"
+        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,19H5V8h14V19z" />
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M11.5,10.5h1v2h2v1h-2v2h-1v-2h-2v-1h2z" />
+</vector>

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

@@ -47,6 +47,9 @@
     <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_detail_share">Teilen</string>
+    <string name="event_share_chooser_title">Termin teilen</string>
+    <string name="event_share_failed">Termin konnte nicht geteilt werden.</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>
@@ -74,6 +77,16 @@
     <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_attendees">Gäste</string>
+    <string name="event_edit_add_guest">Gast hinzufügen</string>
+    <string name="event_edit_add_guest_hint">Gast per E-Mail hinzufügen…</string>
+    <string name="event_edit_add_guest_from_contacts">Aus Kontakten hinzufügen</string>
+    <string name="event_edit_location_from_contacts">Adresse aus Kontakten wählen</string>
+    <string name="event_edit_remove_guest">Gast entfernen</string>
+    <string name="event_edit_attendee_required">Erforderlich</string>
+    <string name="event_edit_attendee_optional">Optional</string>
+    <string name="event_edit_attendees_note_synced">Calendula versendet keine Einladungen. Dein Kalenderkonto sendet Gästen bei der Synchronisierung unter Umständen eine E-Mail.</string>
+    <string name="event_edit_attendees_note_local">Auf diesem Gerät gespeichert. Niemand wird benachrichtigt.</string>
     <string name="event_edit_reminder_custom">Benutzerdefiniert</string>
     <string name="reminder_unit_minutes">Minuten</string>
     <string name="reminder_unit_hours">Stunden</string>
@@ -174,6 +187,15 @@
         <item quantity="one">%d Woche vorher</item>
         <item quantity="other">%d Wochen vorher</item>
     </plurals>
+    <!-- Reine Zeitdauern (ohne „vorher"), z. B. die Schlummerdauer. -->
+    <plurals name="duration_minutes">
+        <item quantity="one">%d Minute</item>
+        <item quantity="other">%d Minuten</item>
+    </plurals>
+    <plurals name="duration_hours">
+        <item quantity="one">%d Stunde</item>
+        <item quantity="other">%d Stunden</item>
+    </plurals>
 
     <!-- Geteilte Event-Strings -->
     <string name="event_untitled">(Ohne Titel)</string>
@@ -191,6 +213,8 @@
     <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>
+    <string name="reminder_action_snooze">Schlummern</string>
+    <string name="reminder_action_dismiss">Verwerfen</string>
 
     <!-- View-Switcher (M1) -->
     <string name="view_month">Monat</string>
@@ -209,6 +233,14 @@
     <string name="agenda_empty_title">Nichts geplant</string>
     <string name="agenda_empty_subtitle">Anstehende Termine erscheinen hier.</string>
 
+    <!-- Terminsuche -->
+    <string name="search_action">Suchen</string>
+    <string name="search_hint">Termine suchen</string>
+    <string name="search_back">Zurück</string>
+    <string name="search_clear">Löschen</string>
+    <string name="search_idle_hint">Durchsuche deine Termine nach Titel, Ort oder Notizen.</string>
+    <string name="search_empty">Keine Termine passen zu „%1$s“.</string>
+
     <!-- Startbildschirm-Widgets -->
     <string name="widget_agenda_title">Anstehend</string>
     <string name="widget_agenda_label">Calendula Agenda</string>
@@ -224,6 +256,11 @@
     <string name="shortcut_new_event_short">Neuer Termin</string>
     <string name="shortcut_new_event_long">Neuen Termin erstellen</string>
 
+    <!-- Schnelleinstellungen-Kachel -->
+    <string name="qs_tile_new_event_label">Neuer Termin</string>
+    <string name="settings_qs_tile">Schnelleinstellungen-Kachel hinzufügen</string>
+    <string name="settings_qs_tile_hint">Eine Kachel „Neuer Termin“ zu den Schnelleinstellungen hinzufügen.</string>
+
     <!-- Kalender-Filter (M3) -->
     <string name="filter_title">Kalender</string>
 
@@ -248,14 +285,27 @@
     <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_default_reminder">Standard-Erinnerung</string>
+    <string name="settings_default_reminder_allday">Ganztägige Termine</string>
+    <string name="settings_allday_reminder_time">Uhrzeit für ganztägige Erinnerungen</string>
+    <string name="settings_allday_reminder_time_hint">Erinnerungen für ganztägige Termine werden um %1$s ausgelöst</string>
+    <string name="reminder_none">Keine</string>
+    <string name="reminder_use_default">Standard-Erinnerung verwenden</string>
+    <string name="reminder_custom_amount">Anzahl</string>
+    <string name="reminder_custom_with_value">Benutzerdefiniert (%1$s)</string>
+    <string name="reminder_custom_set">Übernehmen</string>
+    <string name="settings_calendar_reminders_hint">Standard pro Kalender überschreiben — getrennt für Termine mit Uhrzeit und ganztägige Termine. Ein Kalender kann den Standard übernehmen, weglassen oder einen eigenen festlegen.</string>
+    <string name="settings_calendar_reminder_inherits">Standard (%1$s)</string>
+    <string name="settings_reliable_delivery">Zuverlässige Zustellung</string>
+    <string name="settings_reliable_delivery_hint">Android verzögert Erinnerungen womöglich, um Akku zu sparen. Nimm Calendula aus, damit sie pünktlich ankommen.</string>
+    <string name="settings_reliable_delivery_exempt">Von der Akku-Optimierung ausgenommen — Erinnerungen kommen pünktlich.</string>
+    <string name="settings_snooze_duration">Schlummerdauer</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>
@@ -267,6 +317,8 @@
     <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>
+    <string name="settings_report_problem">Problem melden</string>
+    <string name="settings_report_problem_hint">Absturzbericht senden oder Issue-Tracker öffnen</string>
 
     <!-- Calendar manager -->
     <string name="calendars_title">Kalender</string>
@@ -285,4 +337,53 @@
     <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>
+    <!-- Backup (whole-calendar .ics export) -->
+    <string name="calendars_backup_header">Sicherung</string>
+    <string name="calendars_backup_hint">Lokale Kalender werden nirgends synchronisiert – exportiere sie als .ics-Datei, um eine Kopie zu behalten.</string>
+    <string name="calendars_backup_action">Als .ics-Datei exportieren</string>
+    <string name="calendars_backup_failed">Sicherung konnte nicht exportiert werden.</string>
+    <plurals name="calendars_backup_done">
+        <item quantity="one">%d Termin exportiert.</item>
+        <item quantity="other">%d Termine exportiert.</item>
+    </plurals>
+    <!-- Import (.ics) -->
+    <string name="import_title">Termine importieren</string>
+    <string name="import_target_header">Zu Kalender hinzufügen</string>
+    <string name="import_empty">In dieser Datei wurden keine Termine gefunden.</string>
+    <string name="import_failed">Datei konnte nicht gelesen werden.</string>
+    <string name="import_no_calendar">Kein beschreibbarer Kalender zum Importieren. Lege zuerst einen lokalen Kalender an.</string>
+    <string name="import_done_title">Import abgeschlossen</string>
+    <string name="import_close">Schließen</string>
+    <string name="import_warning_recurrence">Einige geänderte Einzeltermine wiederkehrender Termine wurden übersprungen.</string>
+    <string name="import_warning_no_start">Ein Termin ohne Startzeit wurde übersprungen.</string>
+    <string name="import_warning_attendees">Gästelisten wurden nicht importiert.</string>
+    <string name="import_warning_timezone">Eine unbekannte Zeitzone wurde durch die deines Geräts ersetzt.</string>
+    <plurals name="import_event_count">
+        <item quantity="one">%d Termin in dieser Datei.</item>
+        <item quantity="other">%d Termine in dieser Datei.</item>
+    </plurals>
+    <plurals name="import_action">
+        <item quantity="one">%d Termin importieren</item>
+        <item quantity="other">%d Termine importieren</item>
+    </plurals>
+    <plurals name="import_done_imported">
+        <item quantity="one">%d Termin importiert.</item>
+        <item quantity="other">%d Termine importiert.</item>
+    </plurals>
+    <plurals name="import_done_skipped">
+        <item quantity="one">%d bereits in diesem Kalender übersprungen.</item>
+        <item quantity="other">%d bereits in diesem Kalender übersprungen.</item>
+    </plurals>
+
+    <!-- Absturzberichte: vom Nutzer selbst als Gitea-Issue einreichbar -->
+    <string name="crash_dialog_title">Calendula ist abgestürzt</string>
+    <string name="crash_dialog_message">Calendula wurde beim letzten Mal unerwartet beendet. Du kannst bei der Behebung helfen, indem du diesen Bericht als Issue sendest. Er bleibt auf deinem Gerät, bis du ihn teilst, und enthält keine persönlichen Daten oder Kalenderinhalte — nur die technischen Angaben unten.</string>
+    <string name="crash_dialog_report">Melden</string>
+    <string name="crash_dialog_dismiss">Nicht jetzt</string>
+    <string name="crash_report_issue_title">Absturzbericht</string>
+    <string name="crash_report_clip_label">Calendula-Absturzbericht</string>
+    <string name="crash_report_copied">Bericht in die Zwischenablage kopiert</string>
+    <string name="crash_report_open_failed">Der Issue-Tracker konnte nicht geöffnet werden. Der Bericht ist in deiner Zwischenablage.</string>
+    <string name="crash_report_body_template">Danke, dass du einen Absturz in Calendula meldest. Bitte ergänze, was du gerade getan hast, und sende dann ab.\n\n### Was ist passiert\n\n\n### Absturzbericht\n%1$s\n</string>
+    <string name="crash_report_body_paste">_(Der Bericht war zu lang für diesen Link — füge ihn aus deiner Zwischenablage hier ein.)_</string>
 </resources>

app/src/main/res/values-night/colors.xml

@@ -0,0 +1,6 @@
+<resources>
+    <!-- Dark-scheme window backdrop, matching the Compose dark background/surface
+         (#101316) so activity recreation (e.g. language switch) doesn't flash a
+         lighter grey. See values/colors.xml. -->
+    <color name="window_background">#FF101316</color>
+</resources>

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

@@ -3,4 +3,8 @@
     <color name="seed">#FF5C6B7A</color>
     <!-- Adaptive icon background -->
     <color name="ic_launcher_background">#FF5C6B7A</color>
+    <!-- Window backdrop shown during activity recreation (e.g. on a language
+         switch). Matches the Compose light scheme background/surface so the
+         recreation is seamless; overridden for dark in values-night. -->
+    <color name="window_background">#FFFBFCFE</color>
 </resources>

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

@@ -48,6 +48,9 @@
     <string name="event_detail_back">Back</string>
     <string name="event_detail_edit">Edit</string>
     <string name="event_detail_delete">Delete</string>
+    <string name="event_detail_share">Share</string>
+    <string name="event_share_chooser_title">Share event</string>
+    <string name="event_share_failed">Couldn\'t share this event.</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>
@@ -75,6 +78,16 @@
     <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_attendees">Guests</string>
+    <string name="event_edit_add_guest">Add guest</string>
+    <string name="event_edit_add_guest_hint">Add a guest by email…</string>
+    <string name="event_edit_add_guest_from_contacts">Add from contacts</string>
+    <string name="event_edit_location_from_contacts">Pick address from contacts</string>
+    <string name="event_edit_remove_guest">Remove guest</string>
+    <string name="event_edit_attendee_required">Required</string>
+    <string name="event_edit_attendee_optional">Optional</string>
+    <string name="event_edit_attendees_note_synced">Calendula doesn\'t send invitations. Your calendar account may email guests when it syncs.</string>
+    <string name="event_edit_attendees_note_local">Stored on this device. No one is notified.</string>
     <string name="event_edit_reminder_custom">Custom</string>
     <string name="reminder_unit_minutes">minutes</string>
     <string name="reminder_unit_hours">hours</string>
@@ -175,6 +188,15 @@
         <item quantity="one">%d week before</item>
         <item quantity="other">%d weeks before</item>
     </plurals>
+    <!-- Plain durations (no "before"), e.g. the snooze delay. -->
+    <plurals name="duration_minutes">
+        <item quantity="one">%d minute</item>
+        <item quantity="other">%d minutes</item>
+    </plurals>
+    <plurals name="duration_hours">
+        <item quantity="one">%d hour</item>
+        <item quantity="other">%d hours</item>
+    </plurals>
 
     <!-- Shared event strings -->
     <string name="event_untitled">(No title)</string>
@@ -192,6 +214,8 @@
     <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>
+    <string name="reminder_action_snooze">Snooze</string>
+    <string name="reminder_action_dismiss">Dismiss</string>
 
     <!-- View switcher (M1) -->
     <string name="view_month">Month</string>
@@ -210,6 +234,14 @@
     <string name="agenda_empty_title">Nothing scheduled</string>
     <string name="agenda_empty_subtitle">Upcoming events will show up here.</string>
 
+    <!-- Event search -->
+    <string name="search_action">Search</string>
+    <string name="search_hint">Search events</string>
+    <string name="search_back">Back</string>
+    <string name="search_clear">Clear</string>
+    <string name="search_idle_hint">Search your events by title, location or notes.</string>
+    <string name="search_empty">No events match “%1$s”.</string>
+
     <!-- Home-screen widgets -->
     <string name="widget_agenda_title">Upcoming</string>
     <string name="widget_agenda_label">Calendula agenda</string>
@@ -245,14 +277,27 @@
     <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_default_reminder">Default reminder</string>
+    <string name="settings_default_reminder_allday">All-day events</string>
+    <string name="settings_allday_reminder_time">All-day reminder time</string>
+    <string name="settings_allday_reminder_time_hint">Reminders for all-day events fire at %1$s</string>
+    <string name="reminder_none">None</string>
+    <string name="reminder_use_default">Use default reminder</string>
+    <string name="reminder_custom_amount">Amount</string>
+    <string name="reminder_custom_with_value">Custom (%1$s)</string>
+    <string name="reminder_custom_set">Set</string>
+    <string name="settings_calendar_reminders_hint">Override the default per calendar — separately for timed and all-day events. A calendar can keep the default, drop it, or set its own.</string>
+    <string name="settings_calendar_reminder_inherits">Default (%1$s)</string>
+    <string name="settings_reliable_delivery">Reliable delivery</string>
+    <string name="settings_reliable_delivery_hint">Android may delay reminders to save battery. Exempt Calendula so they arrive on time.</string>
+    <string name="settings_reliable_delivery_exempt">Exempt from battery optimisation — reminders arrive on time.</string>
+    <string name="settings_snooze_duration">Snooze duration</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>
@@ -264,6 +309,8 @@
     <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>
+    <string name="settings_report_problem">Report a problem</string>
+    <string name="settings_report_problem_hint">Send a crash report or open the issue tracker</string>
 
     <!-- Calendar manager -->
     <string name="calendars_title">Calendars</string>
@@ -282,10 +329,67 @@
     <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>
+    <!-- Backup (whole-calendar .ics export) -->
+    <string name="calendars_backup_header">Backup</string>
+    <string name="calendars_backup_hint">Local calendars aren\'t synced anywhere, so export them to an .ics file to keep a copy.</string>
+    <string name="calendars_backup_action">Export as .ics file</string>
+    <string name="calendars_backup_failed">Couldn\'t export the backup.</string>
+    <plurals name="calendars_backup_done">
+        <item quantity="one">Exported %d event.</item>
+        <item quantity="other">Exported %d events.</item>
+    </plurals>
+    <!-- Import (.ics) -->
+    <string name="import_title">Import events</string>
+    <string name="import_target_header">Add to calendar</string>
+    <string name="import_empty">No events found in this file.</string>
+    <string name="import_failed">Couldn\'t read this file.</string>
+    <string name="import_no_calendar">No writable calendar to import into. Create a local calendar first.</string>
+    <string name="import_done_title">Import complete</string>
+    <string name="import_close">Close</string>
+    <string name="import_warning_recurrence">Some changed occurrences of recurring events were skipped.</string>
+    <string name="import_warning_no_start">An event without a start time was skipped.</string>
+    <string name="import_warning_attendees">Guest lists weren\'t imported.</string>
+    <string name="import_warning_timezone">An unknown time zone fell back to your device\'s.</string>
+    <plurals name="import_event_count">
+        <item quantity="one">%d event in this file.</item>
+        <item quantity="other">%d events in this file.</item>
+    </plurals>
+    <plurals name="import_action">
+        <item quantity="one">Import %d event</item>
+        <item quantity="other">Import %d events</item>
+    </plurals>
+    <plurals name="import_done_imported">
+        <item quantity="one">Imported %d event.</item>
+        <item quantity="other">Imported %d events.</item>
+    </plurals>
+    <plurals name="import_done_skipped">
+        <item quantity="one">Skipped %d already in this calendar.</item>
+        <item quantity="other">Skipped %d already in this calendar.</item>
+    </plurals>
     <!-- Launcher long-press shortcuts -->
     <string name="shortcut_new_event_short">New event</string>
     <string name="shortcut_new_event_long">Create a new event</string>
 
+    <!-- Quick Settings tile -->
+    <string name="qs_tile_new_event_label">New event</string>
+    <string name="settings_qs_tile">Add Quick Settings tile</string>
+    <string name="settings_qs_tile_hint">Add a “New event” tile to the Quick Settings panel.</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>
+
+    <!-- Crash reporting: a captured report the user can submit, by hand, as a
+         Gitea issue (the app sends nothing automatically). -->
+    <string name="crash_dialog_title">Calendula crashed</string>
+    <string name="crash_dialog_message">Calendula closed unexpectedly last time. You can help fix it by sending this report as an issue. It stays on your device until you choose to share it, and includes no personal data or calendar content — only the technical details below.</string>
+    <string name="crash_dialog_report">Report</string>
+    <string name="crash_dialog_dismiss">Not now</string>
+    <string name="crash_report_issue_title">Crash report</string>
+    <string name="crash_report_clip_label">Calendula crash report</string>
+    <string name="crash_report_copied">Report copied to your clipboard</string>
+    <string name="crash_report_open_failed">Couldn\'t open the issue tracker. The report is on your clipboard.</string>
+    <string name="crash_report_body_template">Thanks for reporting a crash in Calendula. Please add anything you remember about what you were doing, then submit.\n\n### What happened\n\n\n### Crash report\n%1$s\n</string>
+    <string name="crash_report_body_paste">_(The report was too long for this link — paste it from your clipboard here.)_</string>
+    <string name="report_issue_url" translatable="false">https://codeberg.org/jlmakiola/calendula/issues/new</string>
+    <string name="report_issue_choose_url" translatable="false">https://codeberg.org/jlmakiola/calendula/issues/new/choose</string>
 </resources>

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

@@ -1,5 +1,10 @@
 <resources xmlns:tools="http://schemas.android.com/tools">
-    <style name="Theme.Calendula" parent="android:Theme.Material.Light.NoActionBar">
+    <!-- AppCompat (DayNight) parent so MainActivity can be an AppCompatActivity,
+         which is required for AppCompatDelegate.setApplicationLocales (the in-app
+         language picker) to sync to the system. Actual colours are driven by the
+         Compose theme; this is essentially the launch/backdrop theme. -->
+    <style name="Theme.Calendula" parent="Theme.AppCompat.DayNight.NoActionBar">
+        <item name="android:windowBackground">@color/window_background</item>
         <item name="android:statusBarColor">@android:color/transparent</item>
         <item name="android:navigationBarColor">@android:color/transparent</item>
         <item name="android:windowLightStatusBar">true</item>

app/src/main/res/xml/file_paths.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Exposes the cache subdirectory where IcsExporter stages files for sharing. -->
+<paths>
+    <cache-path
+        name="shared_ics"
+        path="shared_ics/" />
+</paths>

app/src/main/res/xml/locales_config.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    The languages Calendula ships translations for. This is the single source of
+    truth: each entry must have a matching res/values-<tag>/strings.xml, and is
+    surfaced automatically in both the in-app language picker (parsed at runtime
+    by AppLanguage) and the system per-app language settings (Android 13+, via
+    android:localeConfig in the manifest). To add a community translation, drop
+    in the values-<tag> folder and add one <locale> line here.
+-->
+<locale-config xmlns:android="http://schemas.android.com/apk/res/android">
+    <locale android:name="en" />
+    <locale android:name="de" />
+</locale-config>

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

@@ -0,0 +1,97 @@
+package de.jeanlucmakiola.calendula.data.calendar
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+import java.time.LocalDate
+import java.time.LocalTime
+import java.time.ZoneId
+import java.time.ZoneOffset
+
+class AllDayReminderEncodingTest {
+
+    private val berlin: ZoneId = ZoneId.of("Europe/Berlin")
+    private val nineAm = 9 * 60
+    private val summer = LocalDate.of(2026, 6, 20) // CEST, UTC+2
+    private val winter = LocalDate.of(2026, 1, 20) // CET, UTC+1
+
+    /** The instant the provider would actually fire: DTSTART(UTC midnight) − raw. */
+    private fun actualFire(rawMinutes: Int, startDate: LocalDate): Long =
+        startDate.atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli() -
+            rawMinutes * 60_000L
+
+    /** The wall-clock instant we intend: [time] local, [daysBefore] days before [startDate]. */
+    private fun intendedFire(startDate: LocalDate, daysBefore: Int, timeMinutes: Int): Long =
+        startDate.minusDays(daysBefore.toLong())
+            .atTime(LocalTime.of(timeMinutes / 60, timeMinutes % 60))
+            .atZone(berlin).toInstant().toEpochMilli()
+
+    @Test
+    fun `one day before at 9am fires at 9am local the day before (summer)`() {
+        val raw = toProviderAllDayMinutes(1_440, summer, berlin, nineAm)
+        assertThat(actualFire(raw, summer)).isEqualTo(intendedFire(summer, 1, nineAm))
+        // 09:00 CEST is 07:00Z, 7h later than the bare midnight offset: 1440 − 420.
+        assertThat(raw).isEqualTo(1_020)
+    }
+
+    @Test
+    fun `one day before at 9am fires at 9am local the day before (winter)`() {
+        val raw = toProviderAllDayMinutes(1_440, winter, berlin, nineAm)
+        assertThat(actualFire(raw, winter)).isEqualTo(intendedFire(winter, 1, nineAm))
+        // 09:00 CET is 08:00Z, 8h later than midnight: 1440 − 480.
+        assertThat(raw).isEqualTo(960)
+    }
+
+    @Test
+    fun `at time of event encodes a negative offset firing 9am on the day (summer)`() {
+        val raw = toProviderAllDayMinutes(0, summer, berlin, nineAm)
+        assertThat(raw).isLessThan(0) // fires after DTSTART; must not be clamped
+        assertThat(actualFire(raw, summer)).isEqualTo(intendedFire(summer, 0, nineAm))
+    }
+
+    @Test
+    fun `round-trips for whole-day lead times across both seasons`() {
+        for (date in listOf(summer, winter)) {
+            for (time in listOf(0, nineAm, 20 * 60)) {
+                for (semantic in listOf(0, 1_440, 2_880, 10_080)) {
+                    val raw = toProviderAllDayMinutes(semantic, date, berlin, time)
+                    assertThat(fromProviderAllDayMinutes(raw, date, berlin)).isEqualTo(semantic)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `pre-feature rows (raw multiple of 1440) still decode to whole days`() {
+        // Reminders written before this feature stored raw N*1440 (fired at UTC
+        // midnight). They must still read back as "N days before".
+        assertThat(fromProviderAllDayMinutes(1_440, summer, berlin)).isEqualTo(1_440)
+        assertThat(fromProviderAllDayMinutes(1_440, winter, berlin)).isEqualTo(1_440)
+        assertThat(fromProviderAllDayMinutes(2_880, summer, berlin)).isEqualTo(2_880)
+    }
+
+    @Test
+    fun `decoding is independent of the time-of-day used to encode`() {
+        val atNine = toProviderAllDayMinutes(1_440, summer, berlin, nineAm)
+        val atEight = toProviderAllDayMinutes(1_440, summer, berlin, 8 * 60)
+        assertThat(atNine).isNotEqualTo(atEight)
+        assertThat(fromProviderAllDayMinutes(atNine, summer, berlin)).isEqualTo(1_440)
+        assertThat(fromProviderAllDayMinutes(atEight, summer, berlin)).isEqualTo(1_440)
+    }
+
+    @Test
+    fun `negative semantic minutes (provider-default sentinel) pass through`() {
+        assertThat(toProviderAllDayMinutes(-1, summer, berlin, nineAm)).isEqualTo(-1)
+    }
+
+    @Test
+    fun `a winter-anchored offset drifts one hour on a summer occurrence`() {
+        // Known limitation: one fixed MINUTES per series can't track DST. An
+        // offset tuned for a CET anchor fires an hour off once the series crosses
+        // into CEST. Bounded to ±1h; documented, not fixed.
+        val raw = toProviderAllDayMinutes(1_440, winter, berlin, nineAm)
+        val summerOccurrence = LocalDate.of(2026, 7, 20)
+        val fire = actualFire(raw, summerOccurrence).let(java.time.Instant::ofEpochMilli)
+            .atZone(berlin).toLocalTime()
+        assertThat(fire).isEqualTo(LocalTime.of(10, 0)) // 09:00 intended, +1h in CEST
+    }
+}

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

@@ -6,6 +6,7 @@ import androidx.datastore.preferences.core.Preferences
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
@@ -28,6 +29,13 @@ class CalendarRepositoryImplTest {
     private fun newPrefs(tempDir: Path): CalendarPrefs =
         CalendarPrefs(newDataStore(tempDir))
 
+    private fun newSettings(tempDir: Path): SettingsPrefs =
+        SettingsPrefs(
+            PreferenceDataStoreFactory.create(
+                produceFile = { tempDir.resolve("repo_test_settings.preferences_pb").toFile() },
+            ),
+        )
+
     private fun newDataStore(tempDir: Path): DataStore<Preferences> =
         PreferenceDataStoreFactory.create(
             produceFile = { tempDir.resolve("repo_test_prefs.preferences_pb").toFile() },
@@ -53,7 +61,7 @@ class CalendarRepositoryImplTest {
         val fake = FakeCalendarDataSource().apply {
             calendarsResult = listOf(makeCal(1L), makeCal(2L))
         }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), UnconfinedTestDispatcher(testScheduler))
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), UnconfinedTestDispatcher(testScheduler))
 
         repo.calendars().test {
             val first = awaitItem()
@@ -67,7 +75,7 @@ class CalendarRepositoryImplTest {
         val fake = FakeCalendarDataSource().apply {
             calendarsResult = listOf(makeCal(1L))
         }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), UnconfinedTestDispatcher(testScheduler))
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), UnconfinedTestDispatcher(testScheduler))
 
         repo.calendars().test {
             assertThat(awaitItem().map { it.id }).containsExactly(1L)
@@ -91,7 +99,7 @@ class CalendarRepositoryImplTest {
                 listOf(makeEvent(10L))
             }
         }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), UnconfinedTestDispatcher(testScheduler))
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), UnconfinedTestDispatcher(testScheduler))
 
         val range = Instant.fromEpochMilliseconds(1_000L)..Instant.fromEpochMilliseconds(2_000L)
         repo.instances(range).test {
@@ -107,7 +115,7 @@ class CalendarRepositoryImplTest {
         val fake = FakeCalendarDataSource().apply {
             instancesResult = {_, _ -> listOf(makeEvent(10L, "Good")) }
         }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), UnconfinedTestDispatcher(testScheduler))
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), UnconfinedTestDispatcher(testScheduler))
 
         val range = Instant.fromEpochMilliseconds(0)..Instant.fromEpochMilliseconds(10_000L)
         repo.instances(range).test {
@@ -129,7 +137,7 @@ class CalendarRepositoryImplTest {
                 )
             }
         }
-        val repo = CalendarRepositoryImpl(fake, prefs, UnconfinedTestDispatcher(testScheduler))
+        val repo = CalendarRepositoryImpl(fake, prefs, newSettings(tempDir), UnconfinedTestDispatcher(testScheduler))
 
         val range = Instant.fromEpochMilliseconds(0)..Instant.fromEpochMilliseconds(10_000L)
         repo.instances(range).test {
@@ -149,7 +157,7 @@ class CalendarRepositoryImplTest {
                 )
             }
         }
-        val repo = CalendarRepositoryImpl(fake, prefs, UnconfinedTestDispatcher(testScheduler))
+        val repo = CalendarRepositoryImpl(fake, prefs, newSettings(tempDir), UnconfinedTestDispatcher(testScheduler))
 
         val range = Instant.fromEpochMilliseconds(0)..Instant.fromEpochMilliseconds(10_000L)
         repo.instances(range).test {
@@ -165,7 +173,7 @@ 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 repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
         val form = EventForm(
             calendarId = 1L,
             title = "Stand-up",
@@ -179,12 +187,32 @@ class CalendarRepositoryImplTest {
         assertThat(fake.insertedForms).containsExactly(form)
     }
 
+    @Test
+    fun `createEvent passes the configured all-day reminder time to the data source`(
+        @TempDir tempDir: Path,
+    ) = runTest {
+        val fake = FakeCalendarDataSource()
+        val settings = newSettings(tempDir)
+        settings.setAllDayReminderTimeMinutes(8 * 60) // 08:00
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), settings, Dispatchers.Unconfined)
+        val form = EventForm(
+            calendarId = 1L,
+            isAllDay = true,
+            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(0, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(0, 0)),
+        )
+
+        repo.createEvent(form)
+
+        assertThat(fake.allDayReminderTimes).containsExactly(480)
+    }
+
     @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 repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
         val form = EventForm(
             calendarId = 1L,
             start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
@@ -202,7 +230,7 @@ class CalendarRepositoryImplTest {
     @Test
     fun `updateEvent forwards id and both forms`(@TempDir tempDir: Path) = runTest {
         val fake = FakeCalendarDataSource()
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
         val original = EventForm(
             calendarId = 1L,
             title = "Stand-up",
@@ -221,7 +249,7 @@ class CalendarRepositoryImplTest {
         val fake = FakeCalendarDataSource().apply {
             writeError = WriteFailedException("update event id=42")
         }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
         val form = EventForm(
             calendarId = 1L,
             start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
@@ -239,7 +267,7 @@ class CalendarRepositoryImplTest {
     @Test
     fun `deleteEvent delegates to the data source`(@TempDir tempDir: Path) = runTest {
         val fake = FakeCalendarDataSource()
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
 
         repo.deleteEvent(eventId = 42L)
 
@@ -250,7 +278,7 @@ class CalendarRepositoryImplTest {
     @Test
     fun `deleteOccurrence forwards event id and begin time`(@TempDir tempDir: Path) = runTest {
         val fake = FakeCalendarDataSource()
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
 
         repo.deleteOccurrence(eventId = 42L, beginMillis = 1_000L)
 
@@ -261,7 +289,7 @@ class CalendarRepositoryImplTest {
     @Test
     fun `deleteEventFromOccurrence forwards event id and begin time`(@TempDir tempDir: Path) = runTest {
         val fake = FakeCalendarDataSource()
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
 
         repo.deleteEventFromOccurrence(eventId = 42L, beginMillis = 1_000L)
 
@@ -273,7 +301,7 @@ class CalendarRepositoryImplTest {
     @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 repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
         val form = EventForm(
             calendarId = 1L,
             title = "Moved",
@@ -291,7 +319,7 @@ class CalendarRepositoryImplTest {
     @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 repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
         val original = EventForm(
             calendarId = 1L,
             title = "Weekly",
@@ -318,7 +346,7 @@ class CalendarRepositoryImplTest {
         val fake = FakeCalendarDataSource().apply {
             writeError = WriteFailedException("delete event id=42")
         }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
 
         try {
             repo.deleteEvent(eventId = 42L)
@@ -331,7 +359,7 @@ class CalendarRepositoryImplTest {
     @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 repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
 
         val id = repo.createLocalCalendar(
             displayName = "Home",
@@ -348,7 +376,7 @@ class CalendarRepositoryImplTest {
     @Test
     fun `updateCalendar forwards id, name, color and description`(@TempDir tempDir: Path) = runTest {
         val fake = FakeCalendarDataSource()
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
 
         repo.updateCalendar(
             id = 5L,
@@ -365,7 +393,7 @@ class CalendarRepositoryImplTest {
     @Test
     fun `deleteCalendar delegates to the data source`(@TempDir tempDir: Path) = runTest {
         val fake = FakeCalendarDataSource()
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
 
         repo.deleteCalendar(id = 7L)
 
@@ -377,7 +405,7 @@ class CalendarRepositoryImplTest {
         val fake = FakeCalendarDataSource().apply {
             writeError = WriteFailedException("create local calendar 'Home'")
         }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
 
         try {
             repo.createLocalCalendar(displayName = "Home", color = 0, description = null)
@@ -392,7 +420,7 @@ class CalendarRepositoryImplTest {
         val fake = FakeCalendarDataSource().apply {
             eventDetailResult = { null }
         }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
 
         try {
             repo.eventDetail(eventId = 999L)
@@ -411,10 +439,41 @@ class CalendarRepositoryImplTest {
                 if (id == 7L) listOf(EventColorOption("5", 0xFF33B679.toInt())) else emptyList()
             }
         }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), Dispatchers.Unconfined)
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
 
         assertThat(repo.eventColorPalette(7L))
             .containsExactly(EventColorOption("5", 0xFF33B679.toInt()))
         assertThat(repo.eventColorPalette(8L)).isEmpty()
     }
+
+    @Test
+    fun `importEvents skips events whose UID already exists and inserts the rest`(
+        @TempDir tempDir: Path,
+    ) = runTest {
+        val fake = FakeCalendarDataSource().apply {
+            existingUidsResult = setOf("dup@x")
+        }
+        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
+        val events = listOf(
+            parsedEvent("dup@x"), // already present → skipped
+            parsedEvent("new@x"), // inserted
+            parsedEvent(null), // no UID → always inserted
+        )
+
+        val summary = repo.importEvents(targetCalendarId = 3L, events = events)
+
+        assertThat(summary.imported).isEqualTo(2)
+        assertThat(summary.skippedDuplicate).isEqualTo(1)
+        assertThat(fake.importedEvents.map { it.first.uid }).containsExactly("new@x", null)
+        assertThat(fake.importedEvents.map { it.second }).containsExactly(3L, 3L)
+    }
+
+    private fun parsedEvent(uid: String?) = de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent(
+        uid = uid,
+        summary = "E",
+        start = Instant.fromEpochMilliseconds(1_000_000_000L),
+        end = Instant.fromEpochMilliseconds(1_000_003_600L),
+        isAllDay = false,
+        zoneId = "UTC",
+    )
 }

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

@@ -5,6 +5,8 @@ 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.ics.IcsEvent
+import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 
 /**
  * Test-only fake. Tunable via the three `var` properties; `tick()` simulates
@@ -14,8 +16,12 @@ internal class FakeCalendarDataSource : CalendarDataSource {
 
     var calendarsResult: List<CalendarSource> = emptyList()
     var instancesResult: (Long, Long) -> List<EventInstance> = { _, _ -> emptyList() }
+    var searchResult: (String) -> List<EventInstance> = { _ -> emptyList() }
     var eventDetailResult: (Long) -> EventDetail? = { null }
     var eventColorPaletteResult: (Long) -> List<EventColorOption> = { emptyList() }
+    var exportableEventsResult: List<IcsEvent> = emptyList()
+    /** UIDs the target calendar already holds, for import dedup. */
+    var existingUidsResult: Set<String> = emptySet()
     /** Set to make the next write call throw. */
     var writeError: Exception? = null
     /** Id returned by the next [insertEvent]. */
@@ -46,9 +52,22 @@ internal class FakeCalendarDataSource : CalendarDataSource {
     override fun calendars(): List<CalendarSource> = calendarsResult
     override fun instances(beginMillis: Long, endMillis: Long): List<EventInstance> =
         instancesResult(beginMillis, endMillis)
+    override fun searchEvents(query: String): List<EventInstance> = searchResult(query)
     override fun eventDetail(eventId: Long): EventDetail? = eventDetailResult(eventId)
     override fun eventColorPalette(calendarId: Long): List<EventColorOption> =
         eventColorPaletteResult(calendarId)
+    override fun exportableEvents(): List<IcsEvent> = exportableEventsResult
+
+    override fun existingUids(calendarId: Long): Set<String> = existingUidsResult
+
+    /** (event, targetCalendarId) pairs passed to [insertImportedEvent]. */
+    val importedEvents = mutableListOf<Pair<ParsedIcsEvent, Long>>()
+
+    override fun insertImportedEvent(event: ParsedIcsEvent, calendarId: Long): Long {
+        writeError?.let { throw it }
+        importedEvents += event to calendarId
+        return nextInsertId
+    }
 
     override fun createLocalCalendar(displayName: String, color: Int, description: String?): Long {
         writeError?.let { throw it }
@@ -66,20 +85,36 @@ internal class FakeCalendarDataSource : CalendarDataSource {
         deletedCalendarIds += id
     }
 
-    override fun insertEvent(form: EventForm): Long {
+    /** All-day reminder fire-time minute-of-day passed into the last write. */
+    val allDayReminderTimes = mutableListOf<Int>()
+
+    override fun insertEvent(form: EventForm, allDayReminderTimeMinutes: Int): Long {
         writeError?.let { throw it }
         insertedForms += form
+        allDayReminderTimes += allDayReminderTimeMinutes
         return nextInsertId
     }
 
-    override fun updateEvent(eventId: Long, original: EventForm, updated: EventForm) {
+    override fun updateEvent(
+        eventId: Long,
+        original: EventForm,
+        updated: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ) {
         writeError?.let { throw it }
         updatedEvents += Triple(eventId, original, updated)
+        allDayReminderTimes += allDayReminderTimeMinutes
     }
 
-    override fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long {
+    override fun updateOccurrence(
+        eventId: Long,
+        beginMillis: Long,
+        form: EventForm,
+        allDayReminderTimeMinutes: Int,
+    ): Long {
         writeError?.let { throw it }
         updatedOccurrences += Triple(eventId, beginMillis, form)
+        allDayReminderTimes += allDayReminderTimeMinutes
         return nextInsertId
     }
 
@@ -88,9 +123,11 @@ internal class FakeCalendarDataSource : CalendarDataSource {
         beginMillis: Long,
         original: EventForm,
         updated: EventForm,
+        allDayReminderTimeMinutes: Int,
     ): Long {
         writeError?.let { throw it }
         updatedFromOccurrences += Triple(eventId, beginMillis, updated)
+        allDayReminderTimes += allDayReminderTimeMinutes
         return nextInsertId
     }
 

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

@@ -0,0 +1,70 @@
+package de.jeanlucmakiola.calendula.data.calendar
+
+import android.provider.CalendarContract
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import org.junit.jupiter.api.Test
+
+class IcsExportMapperTest {
+
+    @Test
+    fun `timed one-off row maps with its DTEND and kept UID`() {
+        val reader = MapColumnReader(
+            EventExportProjection.IDX_ID to 42L,
+            EventExportProjection.IDX_UID to "abc@host",
+            EventExportProjection.IDX_TITLE to "Standup",
+            EventExportProjection.IDX_DTSTART to 1_000_000L,
+            EventExportProjection.IDX_DTEND to 1_900_000L,
+            EventExportProjection.IDX_ALL_DAY to 0,
+            EventExportProjection.IDX_EVENT_TIMEZONE to "Europe/Berlin",
+            EventExportProjection.IDX_AVAILABILITY to CalendarContract.Events.AVAILABILITY_BUSY,
+        )
+
+        val event = reader.toIcsEvent(reminderMinutes = listOf(10), calendarName = "Personal")
+
+        assertThat(event.uid).isEqualTo("abc@host")
+        assertThat(event.summary).isEqualTo("Standup")
+        assertThat(event.start.toEpochMilliseconds()).isEqualTo(1_000_000L)
+        assertThat(event.end.toEpochMilliseconds()).isEqualTo(1_900_000L)
+        assertThat(event.isAllDay).isFalse()
+        assertThat(event.recurrenceRule).isNull()
+        assertThat(event.reminderMinutes).containsExactly(10)
+        assertThat(event.calendarName).isEqualTo("Personal")
+        assertThat(event.status).isEqualTo(EventStatus.Confirmed)
+    }
+
+    @Test
+    fun `recurring row without DTEND reconstructs end from DURATION`() {
+        val reader = MapColumnReader(
+            EventExportProjection.IDX_ID to 7L,
+            // No UID column → synthesised stably from id + dtstart.
+            EventExportProjection.IDX_TITLE to "Weekly",
+            EventExportProjection.IDX_DTSTART to 1_000_000L,
+            // DTEND absent (null); DURATION carries the length.
+            EventExportProjection.IDX_DURATION to "P3600S",
+            EventExportProjection.IDX_ALL_DAY to 0,
+            EventExportProjection.IDX_RRULE to "FREQ=WEEKLY",
+            EventExportProjection.IDX_EVENT_TIMEZONE to "UTC",
+        )
+
+        val event = reader.toIcsEvent(reminderMinutes = emptyList(), calendarName = null)
+
+        assertThat(event.uid).isEqualTo("7-1000000@calendula")
+        assertThat(event.recurrenceRule).isEqualTo("FREQ=WEEKLY")
+        assertThat(event.end.toEpochMilliseconds()).isEqualTo(1_000_000L + 3_600_000L)
+    }
+
+    @Test
+    fun `all-day flag is carried through`() {
+        val reader = MapColumnReader(
+            EventExportProjection.IDX_ID to 1L,
+            EventExportProjection.IDX_TITLE to "Holiday",
+            EventExportProjection.IDX_DTSTART to 0L,
+            EventExportProjection.IDX_DTEND to 86_400_000L,
+            EventExportProjection.IDX_ALL_DAY to 1,
+            EventExportProjection.IDX_EVENT_TIMEZONE to "UTC",
+        )
+
+        assertThat(reader.toIcsEvent(emptyList(), null).isAllDay).isTrue()
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/data/crash/CrashReportBuilderTest.kt

@@ -0,0 +1,56 @@
+package de.jeanlucmakiola.calendula.data.crash
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+class CrashReportBuilderTest {
+
+    private val context = CrashContext(
+        appVersionName = "2.7.0",
+        appVersionCode = 20700,
+        sdkInt = 34,
+        androidRelease = "14",
+        manufacturer = "Google",
+        model = "Pixel 7",
+        locale = "en-DE",
+    )
+
+    @Test
+    fun `report carries the allowlisted facts and the stack trace`() {
+        val report = buildCrashReport(context, IllegalStateException("boom"), nowMillis = 0L)
+
+        assertThat(report).startsWith("Calendula crash report")
+        assertThat(report).contains("App version: 2.7.0 (20700)")
+        assertThat(report).contains("Android: 14 (API 34)")
+        assertThat(report).contains("Device: Google Pixel 7")
+        assertThat(report).contains("Locale: en-DE")
+        // The exception type + message and a frame from this test are present.
+        assertThat(report).contains("IllegalStateException")
+        assertThat(report).contains("boom")
+        assertThat(report).contains("CrashReportBuilderTest")
+    }
+
+    @Test
+    fun `nested causes are included`() {
+        val cause = NullPointerException("inner")
+        val report = buildCrashReport(context, RuntimeException("outer", cause), nowMillis = 0L)
+
+        assertThat(report).contains("outer")
+        assertThat(report).contains("Caused by")
+        assertThat(report).contains("inner")
+    }
+
+    @Test
+    fun `report holds only the allowlisted lines before the stack trace`() {
+        val report = buildCrashReport(context, Exception("x"), nowMillis = 0L)
+        val header = report.substringBefore("Stack trace:").trim().lines()
+
+        // No identifiers, accounts, or extra fields ever creep into the header:
+        // it is exactly the six allowlisted lines plus the title.
+        assertThat(header).hasSize(6)
+        assertThat(header.first()).isEqualTo("Calendula crash report")
+        assertThat(header.map { it.substringBefore(":") }).containsExactly(
+            "Calendula crash report", "App version", "Android", "Device", "Locale", "Time",
+        ).inOrder()
+    }
+}

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

@@ -121,6 +121,135 @@ class SettingsPrefsTest {
         assertThat(prefs.reminderOnboardingDone.first()).isTrue()
     }
 
+    @Test
+    fun `default reminder is none until set`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.defaultReminderMinutes.first()).isNull()
+    }
+
+    @Test
+    fun `default reminder round-trips, including none`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.setDefaultReminderMinutes(30)
+        assertThat(prefs.defaultReminderMinutes.first()).isEqualTo(30)
+        prefs.setDefaultReminderMinutes(null)
+        assertThat(prefs.defaultReminderMinutes.first()).isNull()
+    }
+
+    @Test
+    fun `garbage stored default reminder reads as none`(@TempDir tempDir: Path) = runTest {
+        val store = newDataStore(tempDir)
+        val prefs = SettingsPrefs(store)
+        store.updateData { p ->
+            val m = p.toMutablePreferences()
+            m[SettingsPrefs.DEFAULT_REMINDER_KEY] = "soon"
+            m
+        }
+        assertThat(prefs.defaultReminderMinutes.first()).isNull()
+    }
+
+    @Test
+    fun `per-calendar override round-trips minutes, none, and inherit`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.perCalendarReminderOverride.first()).isEmpty()
+
+        prefs.setCalendarReminderOverride(7L, CalendarReminderOverride.Minutes(15))
+        prefs.setCalendarReminderOverride(9L, CalendarReminderOverride.None)
+        prefs.perCalendarReminderOverride.first().let { map ->
+            assertThat(map).containsExactly(7L, 15, 9L, null)
+        }
+
+        // Inherit drops the override entirely (absent != null value).
+        prefs.setCalendarReminderOverride(9L, CalendarReminderOverride.Inherit)
+        prefs.perCalendarReminderOverride.first().let { map ->
+            assertThat(map).containsExactly(7L, 15)
+            assertThat(map.containsKey(9L)).isFalse()
+        }
+    }
+
+    @Test
+    fun `all-day default round-trips, including none`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.defaultAllDayReminderMinutes.first()).isNull()
+        prefs.setDefaultAllDayReminderMinutes(1_440)
+        assertThat(prefs.defaultAllDayReminderMinutes.first()).isEqualTo(1_440)
+        prefs.setDefaultAllDayReminderMinutes(null)
+        assertThat(prefs.defaultAllDayReminderMinutes.first()).isNull()
+    }
+
+    @Test
+    fun `per-calendar all-day override round-trips independently of the timed one`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.setCalendarReminderOverride(7L, CalendarReminderOverride.Minutes(15))
+        prefs.setCalendarAllDayReminderOverride(7L, CalendarReminderOverride.Minutes(1_440))
+        assertThat(prefs.perCalendarReminderOverride.first()).containsExactly(7L, 15)
+        assertThat(prefs.perCalendarAllDayReminderOverride.first()).containsExactly(7L, 1_440)
+        // Clearing the all-day override leaves the timed one untouched.
+        prefs.setCalendarAllDayReminderOverride(7L, CalendarReminderOverride.Inherit)
+        assertThat(prefs.perCalendarAllDayReminderOverride.first()).isEmpty()
+        assertThat(prefs.perCalendarReminderOverride.first()).containsExactly(7L, 15)
+    }
+
+    @Test
+    fun `resolveDefaultReminder picks the kind-matching override or global`() {
+        val timed = mapOf(7L to 15, 9L to null)
+        val allDay = mapOf(7L to 2_880)
+        fun resolve(calendarId: Long?, isAllDay: Boolean) = resolveDefaultReminder(
+            timedGlobal = 30,
+            allDayGlobal = 1_440,
+            timedOverrides = timed,
+            allDayOverrides = allDay,
+            calendarId = calendarId,
+            isAllDay = isAllDay,
+        )
+        // Timed: minutes override, explicit none, inherit global, no calendar.
+        assertThat(resolve(7L, isAllDay = false)).isEqualTo(15)
+        assertThat(resolve(9L, isAllDay = false)).isNull()
+        assertThat(resolve(5L, isAllDay = false)).isEqualTo(30)
+        assertThat(resolve(null, isAllDay = false)).isEqualTo(30)
+        // All-day: its own override wins; absent → all-day global; a timed-only
+        // override (cal 9) does not bleed into all-day.
+        assertThat(resolve(7L, isAllDay = true)).isEqualTo(2_880)
+        assertThat(resolve(9L, isAllDay = true)).isEqualTo(1_440)
+        assertThat(resolve(5L, isAllDay = true)).isEqualTo(1_440)
+    }
+
+    @Test
+    fun `all-day reminder time defaults to 9am`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.allDayReminderTimeMinutes.first()).isEqualTo(540)
+    }
+
+    @Test
+    fun `all-day reminder time round-trips and clamps to a valid minute-of-day`(
+        @TempDir tempDir: Path,
+    ) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.setAllDayReminderTimeMinutes(8 * 60 + 30)
+        assertThat(prefs.allDayReminderTimeMinutes.first()).isEqualTo(510)
+        prefs.setAllDayReminderTimeMinutes(5_000)
+        assertThat(prefs.allDayReminderTimeMinutes.first()).isEqualTo(1_439)
+        prefs.setAllDayReminderTimeMinutes(-10)
+        assertThat(prefs.allDayReminderTimeMinutes.first()).isEqualTo(0)
+    }
+
+    @Test
+    fun `snooze duration defaults to 10 minutes`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        assertThat(prefs.snoozeMinutes.first()).isEqualTo(10)
+    }
+
+    @Test
+    fun `snooze duration round-trips and clamps to at least one minute`(
+        @TempDir tempDir: Path,
+    ) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.setSnoozeMinutes(30)
+        assertThat(prefs.snoozeMinutes.first()).isEqualTo(30)
+        prefs.setSnoozeMinutes(0)
+        assertThat(prefs.snoozeMinutes.first()).isEqualTo(1)
+    }
+
     @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/domain/EventFormTest.kt

@@ -211,12 +211,55 @@ class EventFormTest {
     }
 
     @Test
-    fun `changes the form cannot write do not fake a conflict`() {
+    fun `a reminder-method change the form cannot write does not fake a conflict`() {
+        // The form carries reminder minutes only, not the method — so a method
+        // flip the form can't express must not read as an external change.
+        val loaded = detail(reminders = listOf(Reminder(10, ReminderMethod.Alert)))
+            .toEditSnapshot(0L, 3_600_000L, berlin)
+        val fresh = detail(reminders = listOf(Reminder(10, ReminderMethod.Email)))
+            .toEditSnapshot(0L, 3_600_000L, berlin)
+        assertThat(fresh).isEqualTo(loaded)
+    }
+
+    @Test
+    fun `an external guest change now trips the conflict check`() {
+        // Attendees are writable now, so they ride in the snapshot: adding a
+        // guest externally is a real conflict, not invisible.
         val loaded = detail().toEditSnapshot(0L, 3_600_000L, berlin)
         val fresh = detail(
-            attendees = listOf(Attendee("Ada", "ada@example.org", AttendeeStatus.Accepted)),
+            attendees = listOf(Attendee("Ada", "ada@example.org", AttendeeStatus.NeedsAction)),
         ).toEditSnapshot(0L, 3_600_000L, berlin)
-        assertThat(fresh).isEqualTo(loaded)
+        assertThat(fresh).isNotEqualTo(loaded)
+    }
+
+    @Test
+    fun `toEditForm carries editable guests with name email and optional role`() {
+        val prefilled = detail(
+            attendees = listOf(
+                Attendee("Ada", "ada@example.org", AttendeeStatus.Accepted, type = AttendeeType.Required),
+                Attendee("", "bob@example.org", AttendeeStatus.NeedsAction, type = AttendeeType.Optional),
+            ),
+        ).toEditForm(beginMillis = 0L, endMillis = 3_600_000L, zone = berlin)
+        assertThat(prefilled.attendees).containsExactly(
+            EventAttendee(email = "ada@example.org", name = "Ada", optional = false),
+            EventAttendee(email = "bob@example.org", name = "", optional = true),
+        ).inOrder()
+        assertThat(prefilled.populatedFields()).contains(EventFormField.Attendees)
+    }
+
+    @Test
+    fun `toEditForm drops the organizer, resources and guests without an email`() {
+        val prefilled = detail(
+            attendees = listOf(
+                Attendee("Org", "org@example.org", AttendeeStatus.Accepted, AttendeeRelationship.Organizer),
+                Attendee("Room A", "room@example.org", AttendeeStatus.Accepted, type = AttendeeType.Resource),
+                Attendee("No address", null, AttendeeStatus.NeedsAction),
+                Attendee("Ada", "ada@example.org", AttendeeStatus.NeedsAction),
+            ),
+        ).toEditForm(beginMillis = 0L, endMillis = 3_600_000L, zone = berlin)
+        assertThat(prefilled.attendees).containsExactly(
+            EventAttendee(email = "ada@example.org", name = "Ada", optional = false),
+        )
     }
 
     @Test

app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsDurationTest.kt

@@ -0,0 +1,28 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+class IcsDurationTest {
+
+    @Test
+    fun `parses the single-unit forms Calendula writes plus general ones`() {
+        assertThat(parseRfc2445DurationMillis("P1D")).isEqualTo(86_400_000L)
+        assertThat(parseRfc2445DurationMillis("P3600S")).isEqualTo(3_600_000L)
+        assertThat(parseRfc2445DurationMillis("PT1H30M")).isEqualTo(5_400_000L)
+        assertThat(parseRfc2445DurationMillis("P1W")).isEqualTo(604_800_000L)
+    }
+
+    @Test
+    fun `is sign-aware for before-start VALARM triggers`() {
+        assertThat(parseRfc2445DurationMillis("-PT15M")).isEqualTo(-900_000L)
+        assertThat(parseRfc2445DurationMillis("PT0M")).isEqualTo(0L)
+    }
+
+    @Test
+    fun `unparseable input is zero`() {
+        assertThat(parseRfc2445DurationMillis(null)).isEqualTo(0L)
+        assertThat(parseRfc2445DurationMillis("")).isEqualTo(0L)
+        assertThat(parseRfc2445DurationMillis("nonsense")).isEqualTo(0L)
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsParserTest.kt

@@ -0,0 +1,168 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.toInstant
+import org.junit.jupiter.api.Test
+import kotlin.time.Instant
+
+class IcsParserTest {
+
+    private val parser = IcsParser(deviceZone = TimeZone.of("Europe/Berlin"))
+    private val writer = IcsWriter()
+    private val stamp = LocalDateTime(2026, 6, 18, 9, 30, 0).toInstant(TimeZone.UTC)
+
+    private fun roundTrip(event: IcsEvent): ParsedIcsEvent {
+        val text = writer.writeCalendar(listOf(event), stamp)
+        val result = parser.parse(text)
+        assertThat(result.events).hasSize(1)
+        return result.events.single()
+    }
+
+    private fun instantUtc(y: Int, mo: Int, d: Int, h: Int, mi: Int): Instant =
+        LocalDateTime(y, mo, d, h, mi, 0).toInstant(TimeZone.UTC)
+
+    @Test
+    fun `round-trips a timed one-off event`() {
+        val event = IcsEvent(
+            uid = "u1@calendula",
+            summary = "Lunch; with, friends",
+            start = instantUtc(2026, 6, 18, 11, 0),
+            end = instantUtc(2026, 6, 18, 12, 0),
+            isAllDay = false,
+            zoneId = "Europe/Berlin",
+            location = "Café",
+            availability = Availability.Free,
+            status = EventStatus.Tentative,
+        )
+        val parsed = roundTrip(event)
+        assertThat(parsed.uid).isEqualTo("u1@calendula")
+        assertThat(parsed.summary).isEqualTo("Lunch; with, friends")
+        assertThat(parsed.start).isEqualTo(event.start)
+        assertThat(parsed.end).isEqualTo(event.end)
+        assertThat(parsed.isAllDay).isFalse()
+        assertThat(parsed.location).isEqualTo("Café")
+        assertThat(parsed.availability).isEqualTo(Availability.Free)
+        assertThat(parsed.status).isEqualTo(EventStatus.Tentative)
+    }
+
+    @Test
+    fun `round-trips a recurring TZID event to the same instant`() {
+        val event = IcsEvent(
+            uid = "u2@calendula",
+            summary = "Weekly",
+            start = instantUtc(2026, 6, 18, 13, 0),
+            end = instantUtc(2026, 6, 18, 14, 0),
+            isAllDay = false,
+            zoneId = "Europe/Berlin",
+            recurrenceRule = "FREQ=WEEKLY",
+        )
+        val parsed = roundTrip(event)
+        assertThat(parsed.start).isEqualTo(event.start)
+        assertThat(parsed.end).isEqualTo(event.end)
+        assertThat(parsed.zoneId).isEqualTo("Europe/Berlin")
+        assertThat(parsed.recurrenceRule).isEqualTo("FREQ=WEEKLY")
+    }
+
+    @Test
+    fun `round-trips an all-day event`() {
+        val event = IcsEvent(
+            uid = "u3@calendula",
+            summary = "Holiday",
+            start = LocalDate(2026, 6, 18).atStartOfDayIn(TimeZone.UTC),
+            end = LocalDate(2026, 6, 19).atStartOfDayIn(TimeZone.UTC),
+            isAllDay = true,
+            zoneId = "UTC",
+        )
+        val parsed = roundTrip(event)
+        assertThat(parsed.isAllDay).isTrue()
+        assertThat(parsed.start).isEqualTo(event.start)
+        assertThat(parsed.end).isEqualTo(event.end)
+    }
+
+    @Test
+    fun `round-trips reminders as before-start lead minutes`() {
+        val event = IcsEvent(
+            uid = "u4@calendula",
+            summary = "Meeting",
+            start = instantUtc(2026, 6, 18, 13, 0),
+            end = instantUtc(2026, 6, 18, 14, 0),
+            isAllDay = false,
+            zoneId = "UTC",
+            reminderMinutes = listOf(15, 0),
+        )
+        val parsed = roundTrip(event)
+        assertThat(parsed.reminderMinutes).containsExactly(15, 0)
+    }
+
+    @Test
+    fun `tolerates folded lines and a missing UID`() {
+        val ics = buildString {
+            append("BEGIN:VCALENDAR\r\n")
+            append("VERSION:2.0\r\n")
+            append("BEGIN:VEVENT\r\n")
+            // Folded DESCRIPTION (continuation line begins with a space).
+            append("DESCRIPTION:This is a long descriptio\r\n n that was folded\r\n")
+            append("SUMMARY:No UID here\r\n")
+            append("DTSTART:20260618T090000Z\r\n")
+            append("DTEND:20260618T100000Z\r\n")
+            append("END:VEVENT\r\n")
+            append("END:VCALENDAR\r\n")
+        }
+        val parsed = parser.parse(ics).events.single()
+        assertThat(parsed.uid).isNull()
+        assertThat(parsed.description).isEqualTo("This is a long description that was folded")
+        assertThat(parsed.summary).isEqualTo("No UID here")
+    }
+
+    @Test
+    fun `skips a RECURRENCE-ID override and reports it`() {
+        val ics = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nUID:x\r\n" +
+            "RECURRENCE-ID:20260618T090000Z\r\nDTSTART:20260618T090000Z\r\n" +
+            "SUMMARY:Override\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n"
+        val result = parser.parse(ics)
+        assertThat(result.events).isEmpty()
+        assertThat(result.warnings).contains(IcsParseWarning.ModifiedOccurrenceSkipped)
+    }
+
+    @Test
+    fun `reports ignored attendees but still imports the event`() {
+        val ics = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nUID:y\r\n" +
+            "DTSTART:20260618T090000Z\r\nSUMMARY:Has guests\r\n" +
+            "ATTENDEE;CN=Bob:mailto:bob@example.com\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n"
+        val result = parser.parse(ics)
+        assertThat(result.events).hasSize(1)
+        assertThat(result.warnings).contains(IcsParseWarning.AttendeesIgnored)
+    }
+
+    @Test
+    fun `parses multiple events and carries the calendar name`() {
+        val events = listOf(
+            IcsEvent("a@c", "One", instantUtc(2026, 6, 18, 9, 0), instantUtc(2026, 6, 18, 10, 0),
+                false, "UTC", calendarName = "Personal"),
+            IcsEvent("b@c", "Two", instantUtc(2026, 6, 19, 9, 0), instantUtc(2026, 6, 19, 10, 0),
+                false, "UTC", calendarName = "Personal"),
+        )
+        val text = writer.writeCalendar(events, stamp)
+        val result = parser.parse(text)
+        assertThat(result.events).hasSize(2)
+        assertThat(result.events.map { it.calendarName }).containsExactly("Personal", "Personal")
+    }
+
+    @Test
+    fun `a malformed event does not sink the rest of the file`() {
+        // First VEVENT has no DTSTART (skipped); second is valid.
+        val ics = "BEGIN:VCALENDAR\r\n" +
+            "BEGIN:VEVENT\r\nUID:bad\r\nSUMMARY:No start\r\nEND:VEVENT\r\n" +
+            "BEGIN:VEVENT\r\nUID:good\r\nDTSTART:20260618T090000Z\r\nSUMMARY:Fine\r\nEND:VEVENT\r\n" +
+            "END:VCALENDAR\r\n"
+        val result = parser.parse(ics)
+        assertThat(result.events.map { it.uid }).containsExactly("good")
+        assertThat(result.warnings).contains(IcsParseWarning.EventWithoutStartSkipped)
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsTextTest.kt

@@ -0,0 +1,57 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+class IcsTextTest {
+
+    @Test
+    fun `escapes backslash semicolon comma and newline`() {
+        assertThat(escapeText("a\\b;c,d\ne"))
+            .isEqualTo("a\\\\b\\;c\\,d\\ne")
+    }
+
+    @Test
+    fun `backslash is escaped before its escape markers, not after`() {
+        // A single backslash must become exactly one escaped backslash, not
+        // accidentally combine with a following separator.
+        assertThat(escapeText("\\;")).isEqualTo("\\\\\\;")
+    }
+
+    @Test
+    fun `short line is returned unfolded`() {
+        val line = "SUMMARY:short"
+        assertThat(foldLine(line)).isEqualTo(line)
+    }
+
+    @Test
+    fun `long line folds into physical lines of at most 75 octets`() {
+        val line = "DESCRIPTION:" + "x".repeat(300)
+        val folded = foldLine(line)
+
+        val physical = folded.split(ICS_CRLF)
+        assertThat(physical.size).isGreaterThan(1)
+        physical.forEach { assertThat(it.toByteArray(Charsets.UTF_8).size).isAtMost(75) }
+        // Every continuation line begins with the single folding space.
+        physical.drop(1).forEach { assertThat(it).startsWith(" ") }
+    }
+
+    @Test
+    fun `unfolding a folded line restores the original`() {
+        val line = "DESCRIPTION:" + "abcdefg ".repeat(40).trim()
+        val unfolded = foldLine(line).replace(ICS_CRLF + " ", "")
+        assertThat(unfolded).isEqualTo(line)
+    }
+
+    @Test
+    fun `folding never splits a multi-byte character`() {
+        // 100 emoji (4 UTF-8 octets each) — a naive byte split would corrupt one.
+        val line = "X-NOTE:" + "😀".repeat(100)
+        val folded = foldLine(line)
+        // The reassembled content must still decode to the same string.
+        assertThat(folded.replace(ICS_CRLF + " ", "")).isEqualTo(line)
+        folded.split(ICS_CRLF).forEach {
+            assertThat(it.toByteArray(Charsets.UTF_8).size).isAtMost(75)
+        }
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsWriterTest.kt

@@ -0,0 +1,152 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.Availability
+import de.jeanlucmakiola.calendula.domain.EventStatus
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.toInstant
+import org.junit.jupiter.api.Test
+import kotlin.time.Instant
+
+class IcsWriterTest {
+
+    private val writer = IcsWriter(prodId = "-//Test//Test//EN")
+    private val stamp = LocalDateTime(2026, 6, 18, 9, 30, 0).toInstant(TimeZone.UTC)
+
+    private fun lines(events: List<IcsEvent>): List<String> =
+        writer.writeCalendar(events, stamp).split(ICS_CRLF)
+
+    private fun instantUtc(y: Int, mo: Int, d: Int, h: Int, mi: Int): Instant =
+        LocalDateTime(y, mo, d, h, mi, 0).toInstant(TimeZone.UTC)
+
+    @Test
+    fun `calendar is wrapped with the required header and CRLF endings`() {
+        val out = writer.writeCalendar(emptyList(), stamp)
+        assertThat(out).startsWith("BEGIN:VCALENDAR\r\n")
+        assertThat(out).endsWith("END:VCALENDAR\r\n")
+        assertThat(out).contains("VERSION:2.0\r\n")
+        assertThat(out).contains("PRODID:-//Test//Test//EN\r\n")
+    }
+
+    @Test
+    fun `timed one-off event writes UTC instants with a Z suffix`() {
+        val event = IcsEvent(
+            uid = "u1@calendula",
+            summary = "Standup",
+            start = instantUtc(2026, 6, 18, 13, 0),
+            end = instantUtc(2026, 6, 18, 13, 30),
+            isAllDay = false,
+            zoneId = "Europe/Berlin",
+        )
+        val l = lines(listOf(event))
+        assertThat(l).contains("DTSTART:20260618T130000Z")
+        assertThat(l).contains("DTEND:20260618T133000Z")
+        assertThat(l).contains("UID:u1@calendula")
+        assertThat(l).contains("STATUS:CONFIRMED")
+        assertThat(l).contains("TRANSP:OPAQUE")
+    }
+
+    @Test
+    fun `recurring timed event anchors to wall-clock with TZID`() {
+        // 13:00 UTC == 15:00 Berlin in summer; the series must read 15:00 local.
+        val event = IcsEvent(
+            uid = "u2@calendula",
+            summary = "Weekly",
+            start = instantUtc(2026, 6, 18, 13, 0),
+            end = instantUtc(2026, 6, 18, 14, 0),
+            isAllDay = false,
+            zoneId = "Europe/Berlin",
+            recurrenceRule = "FREQ=WEEKLY",
+        )
+        val l = lines(listOf(event))
+        assertThat(l).contains("DTSTART;TZID=Europe/Berlin:20260618T150000")
+        assertThat(l).contains("DTEND;TZID=Europe/Berlin:20260618T160000")
+        assertThat(l).contains("RRULE:FREQ=WEEKLY")
+    }
+
+    @Test
+    fun `recurring event with an unknown zone falls back to UTC instants`() {
+        val event = IcsEvent(
+            uid = "u3@calendula",
+            summary = "Weekly",
+            start = instantUtc(2026, 6, 18, 13, 0),
+            end = instantUtc(2026, 6, 18, 14, 0),
+            isAllDay = false,
+            zoneId = "Mars/Olympus",
+            recurrenceRule = "FREQ=WEEKLY",
+        )
+        val l = lines(listOf(event))
+        assertThat(l).contains("DTSTART:20260618T130000Z")
+        assertThat(l).contains("DTEND:20260618T140000Z")
+    }
+
+    @Test
+    fun `all-day event writes exclusive DATE values without a zone`() {
+        val start = LocalDate(2026, 6, 18).atStartOfDayIn(TimeZone.UTC)
+        val end = LocalDate(2026, 6, 19).atStartOfDayIn(TimeZone.UTC)
+        val event = IcsEvent(
+            uid = "u4@calendula",
+            summary = "Holiday",
+            start = start,
+            end = end,
+            isAllDay = true,
+            zoneId = "UTC",
+        )
+        val l = lines(listOf(event))
+        assertThat(l).contains("DTSTART;VALUE=DATE:20260618")
+        assertThat(l).contains("DTEND;VALUE=DATE:20260619")
+    }
+
+    @Test
+    fun `reminders become VALARM blocks with before-start triggers`() {
+        val event = IcsEvent(
+            uid = "u5@calendula",
+            summary = "Meeting",
+            start = instantUtc(2026, 6, 18, 13, 0),
+            end = instantUtc(2026, 6, 18, 14, 0),
+            isAllDay = false,
+            zoneId = "UTC",
+            reminderMinutes = listOf(15, 0, 15), // duplicate is dropped
+        )
+        val out = writer.writeCalendar(listOf(event), stamp)
+        val l = out.split(ICS_CRLF)
+        assertThat(l.count { it == "BEGIN:VALARM" }).isEqualTo(2)
+        assertThat(l).contains("TRIGGER:-PT15M")
+        assertThat(l).contains("TRIGGER:PT0M")
+        assertThat(l).contains("ACTION:DISPLAY")
+    }
+
+    @Test
+    fun `text fields and the calendar name are escaped`() {
+        val event = IcsEvent(
+            uid = "u6@calendula",
+            summary = "Lunch; with, notes",
+            start = instantUtc(2026, 6, 18, 13, 0),
+            end = instantUtc(2026, 6, 18, 14, 0),
+            isAllDay = false,
+            zoneId = "UTC",
+            location = "Cafe\\Bar",
+            availability = Availability.Free,
+            status = EventStatus.Tentative,
+            calendarName = "Work, Personal",
+        )
+        val l = lines(listOf(event))
+        assertThat(l).contains("SUMMARY:Lunch\\; with\\, notes")
+        assertThat(l).contains("LOCATION:Cafe\\\\Bar")
+        assertThat(l).contains("STATUS:TENTATIVE")
+        assertThat(l).contains("TRANSP:TRANSPARENT")
+        assertThat(l).contains("X-CALENDULA-CALENDAR:Work\\, Personal")
+    }
+
+    @Test
+    fun `existing uid is kept and a missing one is synthesised stably`() {
+        assertThat(deriveIcsUid("real-uid@host", 7, 1000)).isEqualTo("real-uid@host")
+        assertThat(deriveIcsUid(null, 7, 1000)).isEqualTo("7-1000@calendula")
+        assertThat(deriveIcsUid("  ", 7, 1000)).isEqualTo("7-1000@calendula")
+        // Stable across calls — a re-export of the same row yields the same UID.
+        assertThat(deriveIcsUid(null, 7, 1000)).isEqualTo(deriveIcsUid(null, 7, 1000))
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/ParsedIcsFormTest.kt

@@ -0,0 +1,54 @@
+package de.jeanlucmakiola.calendula.domain.ics
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.toInstant
+import org.junit.jupiter.api.Test
+
+class ParsedIcsFormTest {
+
+    private val berlin = TimeZone.of("Europe/Berlin")
+
+    @Test
+    fun `timed event maps to wall-clock form times in the device zone`() {
+        val event = ParsedIcsEvent(
+            uid = "u@x",
+            summary = "Call",
+            start = LocalDateTime(2026, 6, 18, 13, 0, 0).toInstant(TimeZone.UTC),
+            end = LocalDateTime(2026, 6, 18, 14, 0, 0).toInstant(TimeZone.UTC),
+            isAllDay = false,
+            zoneId = "UTC",
+            reminderMinutes = listOf(10, 10, 5),
+            recurrenceRule = "FREQ=WEEKLY",
+        )
+        val form = event.toEventForm(berlin)
+
+        assertThat(form.calendarId).isNull()
+        assertThat(form.title).isEqualTo("Call")
+        // 13:00 UTC == 15:00 Berlin (summer).
+        assertThat(form.start).isEqualTo(LocalDateTime(2026, 6, 18, 15, 0, 0))
+        assertThat(form.end).isEqualTo(LocalDateTime(2026, 6, 18, 16, 0, 0))
+        assertThat(form.reminders).containsExactly(5, 10).inOrder()
+        assertThat(form.rrule).isEqualTo("FREQ=WEEKLY")
+    }
+
+    @Test
+    fun `all-day event shows the last covered day, not the exclusive end`() {
+        val event = ParsedIcsEvent(
+            uid = null,
+            summary = "Trip",
+            start = LocalDate(2026, 6, 18).atStartOfDayIn(TimeZone.UTC),
+            end = LocalDate(2026, 6, 20).atStartOfDayIn(TimeZone.UTC), // exclusive
+            isAllDay = true,
+            zoneId = "UTC",
+        )
+        val form = event.toEventForm(berlin)
+
+        assertThat(form.isAllDay).isTrue()
+        assertThat(form.start.date).isEqualTo(LocalDate(2026, 6, 18))
+        assertThat(form.end.date).isEqualTo(LocalDate(2026, 6, 19)) // last covered day
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/ui/week/WeekLayoutTest.kt

@@ -62,13 +62,28 @@ class WeekLayoutTest {
         assertThat(ev.coversDay(wed, zone)).isTrue()
         assertThat(ev.coversDay(mon, zone)).isFalse()
 
-        val multiDay = event(at(mon, 22), at(wed, 2), allDay = true)
+        // All-day: UTC midnights, end exclusive. Mon..Tue covers Mon and Tue
+        // but not Wed (the Wed-midnight end is exclusive).
+        val multiDay = event(at(mon, 0), at(wed, 0), allDay = true)
         assertThat(multiDay.coversDay(mon, zone)).isTrue()
         assertThat(multiDay.coversDay(LocalDate(2026, 6, 9), zone)).isTrue()
-        assertThat(multiDay.coversDay(wed, zone)).isTrue()
+        assertThat(multiDay.coversDay(wed, zone)).isFalse()
         assertThat(multiDay.coversDay(LocalDate(2026, 6, 12), zone)).isFalse()
     }
 
+    @Test
+    fun `single-day all-day event does not leak into the next day east of UTC`() {
+        // A birthday on Wed: the provider stores UTC midnights with an exclusive
+        // end (Thu 00:00 UTC). In a zone east of UTC the device-local day must
+        // still resolve to Wed only — never Thu. Regression for the all-day
+        // event appearing on two days in the views.
+        val berlin = TimeZone.of("Europe/Berlin") // UTC+2 in June
+        val ev = event(at(wed, 0), at(wed.plusDays(1), 0), allDay = true)
+        assertThat(ev.coversDay(wed, berlin)).isTrue()
+        assertThat(ev.coversDay(wed.plusDays(1), berlin)).isFalse()
+        assertThat(ev.coversDay(wed.plusDays(-1), berlin)).isFalse()
+    }
+
     @Test
     fun `single timed event gets one lane`() {
         val blocks = layoutDay(listOf(event(at(wed, 9), at(wed, 10, 30))), wed, zone)

docs/ARCHITECTURE.md

@@ -143,5 +143,6 @@ 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
+(Gitea Actions) runs `lint test assembleDebug` once per pull request; merging a
-additionally build, sign, and publish to the self-hosted F-Droid repo.
+bumped `versionName` to `main` builds, signs, and publishes to the self-hosted
+F-Droid repo and then mints the `vX.Y.Z` tag + release. See docs/RELEASING.md.

docs/README.md

@@ -12,7 +12,9 @@ Where to look for what:
 | [`../.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) |
+| [`../fastlane/metadata/android/`](../fastlane/metadata/android/) | Store metadata (single source of truth): descriptions, title, icon, screenshots (DE + EN). Harvested directly by the official F-Droid repo; transformed into the self-hosted repo layout at release time by [`../scripts/fastlane_to_fdroid_localized.sh`](../scripts/fastlane_to_fdroid_localized.sh) |
+| [`../fdroid-metadata/`](../fdroid-metadata/) | App-level F-Droid control file (`*.yml`: Categories, License, links) for the self-hosted repo's `fdroid update` |
+| [`fdroid-official/`](fdroid-official/) | Draft recipe + notes for publishing to the **official** F-Droid repo (reproducible build + developer-signed binary) |
 
 Conventions: plans and specs under `superpowers/` are point-in-time
 artifacts of the agentic workflow that built each milestone — they get

docs/RELEASING.md

@@ -1,61 +1,98 @@
 # Releasing Calendula
 
-Calendula is distributed through a self-hosted F-Droid repository. Every
+Calendula is distributed through a self-hosted F-Droid repository. A release is
-release is built, signed, and published automatically by
+built, signed, and published automatically by `.gitea/workflows/release.yaml`
-`.gitea/workflows/release.yaml` when a version tag is pushed.
+when a **bumped `versionName` reaches `main`** — the pipeline then creates the
+matching `vX.Y.Z` tag and Gitea release itself.
 
-## Versioning — the git tag is the single source of truth
+## Versioning — the committed version is the source of truth
 
-A release is defined by its tag, `vMAJOR.MINOR.PATCH` (e.g. `v2.1.0`). At
+A release is defined by the `versionName`/`versionCode` committed in
-release time the workflow derives both Gradle fields from the tag:
+`app/build.gradle.kts`:
 
-- `versionName` = the tag without the leading `v` (`2.1.0`)
+- `versionName` = `MAJOR.MINOR.PATCH` (e.g. `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
+So `MINOR` and `PATCH` each have room for 0–99. The release pipeline reads
-`app/build.gradle.kts` are only the dev/local default — CI overwrites them
+`versionName`, pins `versionCode` to the derived value, builds, and — once the
-from the tag. Keep the committed `versionCode`/`versionName` matching the
+APK is published — creates the tag `v<versionName>` at that commit. The tag is
-**latest released tag** so local builds are sanely versioned; the published
+an **output** of a successful release, not its trigger, so a tag always marks a
-value always comes from the tag.
+fully-shipped version (and a failure before publish leaves no tag, so re-running
+the workflow safely retries).
 
 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
+1. **Assemble the release branch.** Create `release/vX.Y.Z` and merge the
+   feature/fix branches that make up this release into it. This branch is the
+   release candidate — everything below happens on it, before it reaches `main`.
+2. 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
+3. Bump the committed `versionName` (and `versionCode`) in
-   `app/build.gradle.kts` to match the new version (keeps local builds tidy).
+   `app/build.gradle.kts` to the new version. **This bump is what triggers the
-3. Commit, then tag and push:
+   release** when the branch merges to `main`. Then run
    ```bash
-   git tag vX.Y.Z
+   scripts/sync_changelog_to_fastlane.sh
-   git push origin vX.Y.Z
    ```
-4. The push triggers the release workflow. **Hold UI releases for on-device
+   and commit the generated
-   review and explicit go-ahead before tagging.**
+   `fastlane/metadata/android/en-US/changelogs/<versionCode>.txt`. This is what
+   makes the **official** F-Droid repo show this version's changelog (it reads
+   the changelog from the tagged source tree). The self-hosted pipeline
+   regenerates it regardless, so forgetting only affects the official listing.
+4. **Verify the release build on a real device** — the mandatory gate. The
+   shipped APK is R8-shrunk/obfuscated, and bugs that only appear there, or
+   only on first run, never show up in the debug build or on a device that
+   already granted the calendar permission (this is how the v2.7.0 launch
+   crash slipped through). Run:
+   ```bash
+   scripts/verify-release.sh
+   ```
+   It builds the `releaseTest` variant (same R8 config as `release`, debug-signed
+   with a `.releasetest` suffix so it installs alongside the real app) and resets
+   it to a first-run state. Then, on the device:
+   - launch from a **clean / permission-not-granted** state — the permission
+     screen must appear, no crash;
+   - grant access — the calendar must load;
+   - add both home-screen **widgets** and confirm they render;
+   - exercise this release's headline changes.
+
+   Only proceed once all of that passes on-device.
+5. **Merge `release/vX.Y.Z` into `main`.** That's it — no manual tagging. The
+   merge triggers `release.yaml`, which detects the new version, builds, signs,
+   publishes to F-Droid, and creates the `vX.Y.Z` tag + Gitea release. **Hold UI
+   releases for on-device review and explicit go-ahead before merging.**
+
+> The `releaseTest` build type exists only for step 4 — it is never published.
+> The pipeline always builds and signs the real `release` variant.
 
 ## What the pipeline does
 
-`release.yaml` has three jobs:
+CI and release are split so a change is built once on its PR and only does
+release work when a merge actually cuts a release:
 
-- **ci** — unit tests + a debug assemble (sanity).
+- **`ci.yaml`** (on `pull_request`) — lint + unit tests + a debug assemble (and
-- **build-and-deploy** — derives the version, builds & signs the release APK
+  a Trivy scan), once per PR. Docs/metadata-only PRs skip the Android build but
-  with the app key, copies it into the F-Droid repo, generates the per-version
+  still report a green `CI` check.
-  changelog, re-signs the F-Droid index with the **repo key**, uploads
+- **`release.yaml`** (on push to `main`, plus `workflow_dispatch`) — a cheap
-  `repo/` + `metadata/` to the box, and attaches the R8 `mapping.txt` to the
+  `detect` job reads `versionName` and checks whether a tag for it already
-  Gitea release (best-effort).
+  exists. Only when it doesn't does the `release` job run: unit tests on the
-- **gitea-release** — creates/updates the Gitea release carrying the tag's
+  merged commit, build & sign the release APK with the **app key**, copy it into
-  CHANGELOG section as notes. Gated on `ci` only (not the deploy) so notes
+  the F-Droid repo, generate the per-version changelog, re-sign the index with
-  publish even if the F-Droid upload hiccups.
+  the **repo key**, upload `repo/` + `metadata/`, then create the `vX.Y.Z` tag +
+  Gitea release (CHANGELOG section as notes) and attach the R8 `mapping.txt`
+  (best-effort). Ordinary merges with no version bump fall through `detect` and
+  do nothing.
 
 ### Manual re-sign / recovery
 
-A manual `workflow_dispatch` of the release workflow **from a branch** (not a
+A manual `workflow_dispatch` of the release workflow runs a **re-sign-only**
-tag) runs a **re-sign-only** path: it skips the APK build and just re-signs
+path: `detect` reports it's not a release, so the `release` job skips the APK
-the existing F-Droid index with the configured repo key and re-uploads. Use
+build, the version bump, and tag/release creation, and just re-signs the
-this for key rotation or repo recovery without publishing a new app version.
+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)
 

docs/fdroid-official/README.md

@@ -0,0 +1,94 @@
+# Official F-Droid submission (draft)
+
+Goal: publish Calendula to the **official F-Droid repo** *alongside* the
+self-hosted repo, as **one app** — same signed binary in both channels, so
+existing self-hosted users migrate with no reinstall and no data loss.
+
+This folder holds the **draft** fdroiddata recipe. Nothing here is submitted
+yet. The self-hosted pipeline (`../../fdroid-metadata/`, `.gitea/workflows/release.yaml`)
+is unaffected by these files.
+
+## Publishing model: reproducible build + developer-signed binary
+
+F-Droid builds Calendula from source on its buildserver, then verifies the
+output is byte-for-byte identical to **our** signed APK (fetched via the
+`Binaries` URL). On a match it publishes **our** binary, signed with **our**
+key — identified by `AllowedAPKSigningKeys`. Result: official and self-hosted
+both carry the same signature. If a build ever fails to match, F-Droid simply
+skips that version (fails safe — no bad publish).
+
+## Verification status (2026-06-21)
+
+- ✅ **Run-to-run reproducible** — `v2.7.0` built twice from a clean worktree
+  (R8 minify + resource-shrink, build cache off) → byte-for-byte identical
+  (`sha256 568c944a…`).
+- ✅ **Cross-JDK reproducible** — rebuilt with JDK 17 and JDK 21 → identical
+  APK. JDK version is not a sensitivity, so it need not be pinned.
+- ✅ **Tag self-consistent** — committed `versionCode`/`versionName` already
+  equal the tag-derived values, so F-Droid building the tag as-is matches the
+  CI-published binary (CI's `sed` substitution is a no-op).
+- ✅ **App signing cert SHA-256 extracted** from published APKs (identical
+  across v1.0.0 / v2.0.0 / v2.4.0): `5cdaee8e…`. No keystore needed.
+- ✅ **Eligibility** — MIT, 100% FOSS deps (no Play Services / Firebase /
+  analytics / billing), no `INTERNET` permission, no native code.
+- ✅ **End-to-end reproducible vs the DISTRIBUTED binary** — built tag `v2.7.1`
+  from source and compared against the published `calendula_v2.7.1.apk`: every
+  app entry (dex / resources / assets / manifest) byte-identical. The only
+  difference was `META-INF/version-control-info.textproto` (AGP's git metadata,
+  env-dependent). Fixed with `vcsInfo { include = false }` on the release build;
+  re-validated → 0 non-signature differences. **Takes effect from the first
+  release built after that change — submit the recipe starting at that version**
+  (v2.7.1 and earlier still embed the textproto and won't verify).
+- ⚠️ **Not yet proven**: cross-host / fixed-build-path reproducibility on
+  F-Droid's buildserver (low risk for a no-NDK pure-JVM app; with vcsInfo
+  disabled, the env-dependent field is gone; F-Droid confirms at review).
+- ✅ **Buildserver toolchain supported** (checked 2026-06-21):
+  - **Gradle 9.5.1** is in F-Droid's gradle-transparency-log (`checksums.json`)
+    with a verified sha256, so `gradlew.py` will download + verify + run it.
+  - **AGP 9.2** is in `gradlew.py`'s `MIN_GRADLE_VERSION` map (`9.2 -> 9.4.1`).
+  - **JDK 17** is standard on the buildserver (AGP 9.2 requires exactly 17).
+  - **build-tools 36.0.0 / android-37**: not statically preinstalled (baseline
+    stops at 33), but `provision-android-sdk` makes `$ANDROID_HOME/build-tools`
+    and `/platforms` group-writable so AGP/Gradle install newer ones on demand.
+
+## Before submitting — checklist
+
+1. Confirm the `Binaries` URL is publicly reachable and stable long-term, e.g.
+   `https://apps.dev.jeanlucmakiola.de/dev/fdroid/repo/calendula_v2.7.0.apk`
+   resolves to the dev-signed APK. F-Droid re-fetches it on every build.
+2. Confirm F-Droid's buildserver supports the toolchain (see timing risk).
+3. (Recommended) Reproduce one published release end-to-end: build the tag from
+   source, strip signatures, and diff against the downloaded `calendula_v<ver>.apk`
+   to confirm the from-source build matches the *distributed* binary — not just
+   another local build.
+
+## Submission steps (fdroiddata, GitLab)
+
+1. Fork `https://gitlab.com/fdroid/fdroiddata`.
+2. Copy `de.jeanlucmakiola.calendula.yml` to `metadata/` in the fork.
+3. Test locally with `fdroid build -v de.jeanlucmakiola.calendula` and
+   `fdroid lint de.jeanlucmakiola.calendula` (and `fdroid readmeta`).
+4. Open a Merge Request. Initial review can take weeks to months; the
+   self-hosted repo keeps serving in the meantime, so there's no rush.
+
+## Listing metadata (descriptions, screenshots, icon)
+
+These are **not** in the recipe `.yml`. F-Droid's `fdroid update` harvests them
+automatically from the fastlane tree in the app's source repo:
+
+    fastlane/metadata/android/<locale>/
+      short_description.txt   full_description.txt   title.txt
+      images/icon.png         images/phoneScreenshots/*.png
+      changelogs/<versionCode>.txt   (optional, per release)
+
+This is the single source of truth: en-US + de-DE already exist there, and the
+self-hosted repo is generated from the same tree at release time via
+`scripts/fastlane_to_fdroid_localized.sh`. Nothing extra to add to fdroiddata —
+F-Droid picks the listing up from source. (Screenshots may not be committed to
+the fdroiddata repo anyway, so the source-tree fastlane layout is required.)
+
+Per-version changelogs: the self-hosted release workflow generates
+`changelogs/<versionCode>.txt` at release time. For the official repo to show a
+changelog, that file must be committed into `fastlane/metadata/android/<locale>/changelogs/`
+at the tagged commit — wire this into the release/version-bump step, or accept
+no in-client changelog for the official listing initially.

docs/fdroid-official/de.jeanlucmakiola.calendula.yml

@@ -0,0 +1,65 @@
+# ---------------------------------------------------------------------------
+# DRAFT fdroiddata metadata for the OFFICIAL F-Droid repository.
+#
+# This is NOT the self-hosted metadata (that lives in ../../fdroid-metadata/).
+# When submitting, this file's contents go to fdroiddata on GitLab as
+#   metadata/de.jeanlucmakiola.calendula.yml
+# See README.md in this folder for the verification status and submission steps.
+#
+# Publishing model: REPRODUCIBLE BUILD + developer-signed binary.
+# F-Droid builds from source on its buildserver, then verifies the result is
+# identical to our own signed APK (fetched via `Binaries`). If it matches,
+# F-Droid publishes OUR binary signed with OUR key (`AllowedAPKSigningKeys`),
+# so the official and self-hosted channels carry the SAME signature and users
+# migrate between them with no reinstall / no data loss.
+# ---------------------------------------------------------------------------
+
+Categories:
+  - Calendar & Agenda
+License: MIT
+AuthorName: Jean-Luc Makiola
+SourceCode: https://gitea.jeanlucmakiola.de/makiolaj/calendula
+IssueTracker: https://gitea.jeanlucmakiola.de/makiolaj/calendula/issues
+Changelog: https://gitea.jeanlucmakiola.de/makiolaj/calendula/src/branch/main/CHANGELOG.md
+
+AutoName: Calendula
+
+RepoType: git
+Repo: https://gitea.jeanlucmakiola.de/makiolaj/calendula.git
+
+# First build entry = v2.7.5, the first release that clears ALL three F-Droid
+# blockers: (1) AGP VCS-info disabled (`vcsInfo { include = false }`, since
+# v2.7.3); (2) the unused Gradle foojay toolchain-resolver plugin removed (since
+# v2.7.4) — the offline build scanner rejects it as it can fetch a JDK; (3) AGP's
+# dependency-metadata block no longer embedded (`dependenciesInfo { includeInApk
+# = false }`) — the binary scanner rejects it as an "extra signing block". All
+# three live outside the zip entries or are inert, so v2.7.5 is functionally
+# identical to v2.7.3 and reproduces byte-for-byte from source. v2.7.4 and
+# earlier trip one of these checks — do not target them. Subsequent versions are
+# added automatically (AutoUpdateMode).
+Builds:
+  - versionName: 2.7.5
+    versionCode: 20705
+    commit: v2.7.5
+    subdir: app
+    gradle:
+      - yes
+    # No NDK / no flavors. The release buildType applies a signingConfig only
+    # when key.properties exists; on the buildserver it does not, so this
+    # produces the unsigned APK F-Droid compares against our binary.
+
+# SHA-256 of our app signing certificate (public; embedded in every published
+# APK). Locks F-Droid to publish only binaries signed with our key.
+AllowedAPKSigningKeys: 5cdaee8eb31cb0df9157c646ae3ec8b3dc43b5bb72624e088c9ddea0c4eb5ec1
+
+# Our own developer-signed APK for reproducible-build verification. %v -> the
+# versionName, so v2.7.5 resolves to calendula_v2.7.5.apk on the self-hosted repo.
+Binaries: https://apps.dev.jeanlucmakiola.de/dev/fdroid/repo/calendula_v%v.apk
+
+# After this one-time submission F-Droid auto-tracks new vX.Y.Z tags and creates
+# build entries itself — no manual recipe edits per release. The tag regex keeps
+# it to release tags only.
+AutoUpdateMode: Version
+UpdateCheckMode: Tags ^v[0-9.]+$
+CurrentVersion: 2.7.5
+CurrentVersionCode: 20705

docs/superpowers/plans/2026-06-18-05-ics-export.md

@@ -0,0 +1,150 @@
+# Calendula - Plan 05: ICS Export (v2.7, Branch 1 von 2)
+
+> **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:** Die Schreib-Hälfte des `.ics`-Themas. Calendula serialisiert eigene
+Events nach RFC 5545 — als Einzel-Event (Share-Sheet) und als
+Ganz-Kalender-Backup (SAF-Datei). Damit existiert für gerätelokale Kalender
+(`ACCOUNT_TYPE_LOCAL`) zum ersten Mal ein Backup; ohne Sync ist ein verlorenes
+Gerät sonst Totalverlust. Diese Branch baut **nur Export**; Import
+(Parser, Restore, Open-into-form) folgt in Branch 2 (`feat/ics-import`),
+beide landen zusammen in **einem** Release v2.7.0 — es gibt also keine
+Zwischenversion, die UIDs schreibt, ohne sie je zu lesen.
+`./gradlew lint test assembleDebug` bleibt grün; Release erst nach
+On-Device-Review (gemeinsam mit Branch 2).
+
+**Architecture:** Neue reine-Kotlin-Engine `domain/ics/` — kein
+`CalendarContract`, keine Android-Deps, voll JVM-testbar. Kern ist
+`IcsWriter` (nimmt eine Liste eigener Event-Modelle + Kalender-Metadaten,
+gibt einen `VCALENDAR`-String zurück). Keine ICS-Library: wir bleiben auf
+`kotlinx-datetime` (kein `java.time`-Desugaring) und hand-rollen wie schon
+bei RRULE in `Recurrence.kt`. Das Schreiben in eine SAF-Datei / das
+Share-Intent liegt in einer dünnen Android-Schicht
+(`data/ics/IcsExporter` o. ä.), die Provider-Reads → Domain-Modelle →
+`IcsWriter` → `OutputStream` verdrahtet.
+
+**Recherche-Befunde (Codebase, 2026-06-18):**
+
+1. **Keine ICS-Library, kein `java.time`-Desugaring** — Stack ist
+   `kotlinx-datetime` + `kotlin.time.Instant`. RRULE wird bereits in
+   `domain/Recurrence.kt` von Hand geparst/gerendert (inkl. der sorgfältigen
+   `UNTIL`/DST-Korrektur). `IcsWriter` reiht sich in genau diese Kultur ein und
+   nutzt `SimpleRecurrence.toRRule()` direkt.
+2. **Kein UID-Handling.** `Events.UID_2445` wird heute nirgends gelesen oder
+   geschrieben. Für idempotenten Restore in Branch 2 muss Import auf UID
+   matchen — ohne UID verdoppelt ein erneuter Import alles. Darum schreibt
+   **diese** Branch bereits UID bei jedem Insert (Vorarbeit; ohne Import noch
+   unsichtbar, zahlt sich erst in Branch 2 aus — beide im selben Release).
+3. **Zeitzonen werden gespeichert, aber nie vom Nutzer gewählt.** Lesen/Anzeige:
+   `EVENT_TIMEZONE` landet in `EventDetail.eventTimezone`, das Detail zeigt ein
+   Fremdzonen-Label nur bei Abweichung vom Gerät (`foreignTimeZoneLabel`).
+   Schreiben (`EventWriteMapper.toWriteTimes`): all-day → UTC-Mitternachten,
+   `EVENT_TIMEZONE="UTC"`; getimt → `EVENT_TIMEZONE = zone.id`, und alle Caller
+   übergeben `currentSystemDefault()` (kein Zonen-Feld im Formular). Jedes selbst
+   erstellte Event trägt also die Gerätezone zum Erstellzeitpunkt; eingesynkte
+   Events behalten ihre Originalzone.
+
+**Leitentscheidungen:**
+
+1. **Zeitzonen-Regel beim Schreiben (fallbasiert):**
+   - **All-day** → `DTSTART;VALUE=DATE:YYYYMMDD`, `DTEND` exklusiv
+     (Tag-danach). Keine Zone — trivial korrekt.
+   - **Getimt, nicht wiederkehrend** → UTC-Instant `…T…Z`. Ein Instant ist ein
+     Instant; die Anzeige rechnet beim Import wieder in die Gerätezone. Verlustfrei.
+   - **Getimt, wiederkehrend** → `DTSTART;TZID=<EVENT_TIMEZONE>:<lokale Wandzeit>`.
+     Eine Serie muss an der **Wandzeit** verankert sein, sonst driftet ein
+     „wöchentlich 9 Uhr" über die nächste DST-Grenze um eine Stunde. Die Zone
+     liegt bereits in `EVENT_TIMEZONE` vor; die lokale Wandzeit ist eine
+     `kotlinx-datetime`-Konversion (Instant → LocalDateTime in der Zone).
+   - **`VTIMEZONE`-Blöcke werden bewusst NICHT emittiert.** Beim eigenen
+     Round-Trip löst Branch-2-Import `TZID` gegen die OS-tz-Datenbank auf
+     (`kotlinx-datetime`/`java.time` kennen jede IANA-Id). Technisch nicht
+     RFC-konform; einziger Preis sind strenge Fremd-Parser ohne tz-DB — als
+     bekannte Lücke dokumentiert (Skip-and-report-Territorium des Imports),
+     kein Blocker. Voll-`VTIMEZONE` ist „später, falls nötig".
+2. **UID bei jedem Insert.** `insertEvent` schreibt fortan `Events.UID_2445`
+   (z. B. `<random-uuid>@calendula`). Bestehende Events ohne UID exportieren
+   wir mit einer **deterministischen, stabilen** Fallback-UID, abgeleitet aus
+   `event-id + DTSTART` (`<id>-<dtstart>@calendula`), damit derselbe Bestand
+   über mehrere Backups dieselbe UID behält und Branch-2-Restore nicht
+   verdoppelt. Bestehende Rows werden **nicht** rückwirkend gestempelt
+   (kein Migrations-Sweep über fremde Kalender).
+3. **Manueller Export, kein Background.** Backup via
+   `ACTION_CREATE_DOCUMENT` (SAF, MIME `text/calendar`, Default-Name
+   `calendula-backup-<datum>.ics`); Einzel-Event-Share via `ACTION_SEND` mit
+   einem `FileProvider`-Cache-File (`text/calendar`). Kein WorkManager, kein
+   geplantes/automatisches Backup (passt zum „kein Hintergrunddienst"-Ethos;
+   Auto-Backup bleibt explizit Roadmap-`later`).
+4. **Backup-Layout: eine kombinierte `VCALENDAR`-Datei** über alle
+   gerätelokalen (beschreibbaren) Kalender. Pro Event ein `VEVENT`; die
+   Kalender-Zugehörigkeit reist als `X-WR-CALNAME` / `CATEGORIES` o. ä. mit,
+   damit Branch-2-Restore wieder auffächern oder per Ziel-Picker einsortieren
+   kann. Eine Datei ist einfacher zu teilen/abzulegen als n Dateien.
+   *Offen, vor dem Backup-Task zu fixieren:* exaktes Property fürs
+   Kalender-Mapping (`X-WR-CALNAME` pro `VCALENDAR` erlaubt nur einen Namen;
+   für mehrere Kalender in einer Datei brauchen wir ein Pro-`VEVENT`-Property
+   wie `X-CALENDULA-CALENDAR` oder `CATEGORIES`).
+5. **Feldumfang = was Calendula modelliert.** `IcsWriter` serialisiert genau
+   die gelesenen Felder: `SUMMARY`, `DTSTART`/`DTEND` (Regel #1),
+   `LOCATION`, `DESCRIPTION`, `RRULE` (über `toRRule`), `VALARM` aus den
+   Remindern (DISPLAY, `TRIGGER` = `-PT<min>M`), `STATUS`
+   (CONFIRMED/TENTATIVE/CANCELLED), `TRANSP` (Free→TRANSPARENT/Busy→OPAQUE),
+   `UID`, `DTSTAMP`. Felder ohne sauberes Modell (Attendees, RECURRENCE-ID-
+   Ausnahmen) bleiben **vorerst weg** — Export erzeugt nichts, was Import in
+   Branch 2 nicht auch wieder lesen kann.
+6. **Korrekte RFC-5545-Mechanik:** Zeilen-Folding bei >75 Oktett (CRLF +
+   Space-Fortsetzung), Text-Escaping (`\` `;` `,` `\n`), CRLF-Zeilenenden,
+   `PRODID`/`VERSION:2.0`-Header. Eine reine, einzeln getestete Hilfsschicht
+   (`IcsLine`/`fold`/`escapeText`), nicht ad hoc im Writer verstreut.
+
+---
+
+## Tasks
+
+**Domain-Engine (`domain/ics/`, reine Kotlin, JVM-Tests):**
+- [x] `IcsText`: `escapeText`, `foldLine` (75-Oktett, CRLF+Space) + Test
+      (`IcsTextTest`). Wert-Helfer (Instant→`…T…Z`, Wandzeit→`TZID`,
+      LocalDate→`VALUE=DATE`) leben als private Helfer in `IcsWriter`.
+- [x] `IcsEvent`-Eingabemodell (reine Kotlin: summary, start/end als Instant
+      + isAllDay + zoneId, recurrenceRule?, location, description,
+      reminderMinutes, status, availability, uid, calendarName) — entkoppelt
+      vom Provider-Modell
+- [x] `IcsWriter.writeCalendar(events, dtStamp)` → String: Header, pro Event
+      `VEVENT` nach Entscheidung #5, Zeitzonen-Regel #1, `VALARM`; JVM-Test
+      `IcsWriterTest` (all-day, getimt, wiederkehrend+TZID, unbekannte Zone,
+      Reminder, Escaping)
+- [x] UID-Ableitung `deriveIcsUid` (`uid ?: "<eventId>-<dtstartMillis>@calendula"`)
+      + Stabilitätstest
+
+**Provider → Domain (`data/calendar/IcsExportMapper.kt`):**
+- [x] Mapper Provider-Row → `IcsEvent` (`ColumnReader.toIcsEvent`) inkl.
+      DURATION→DTEND-Rekonstruktion (`parseRfc2445DurationMillis`),
+      `EventExportProjection`; Datasource-Methode `exportableEvents()` +
+      Repository `exportEvents()`; Test `IcsExportMapperTest`
+- [x] `insertEvent` schreibt `Events.UID_2445` (`UUID@calendula`) bei jedem
+      Create
+
+**Android-Export-Schicht:**
+- [x] `data/ics/IcsExporter`: `writeDocument(uri)` (SAF) + `stageShareFile`
+      (FileProvider-Cache) als UTF-8
+- [x] Einzel-Event-Share: Share-Action im Event-Detail → `IcsWriter` für ein
+      Event (one-off) → Cache-File über `FileProvider` → `ACTION_SEND`
+- [x] Ganz-Kalender-Backup: „Export as .ics file" in Settings → Calendars →
+      `ACTION_CREATE_DOCUMENT` → in den URI streamen; Ergebnis-Snackbar
+      (Plural „Exported N events")
+- [x] `FileProvider` + `file_paths.xml` im Manifest (Cache-Dir für Shares)
+- [x] Strings DE+EN: Share-Label/Chooser/Fehler, Backup-Sektion/Aktion/
+      Fehler + Plural, dateierter Default-Name
+
+**Abschluss:**
+- [ ] `./gradlew lint test assembleDebug` grün ← **nächster Schritt (Test)**
+- [x] CHANGELOG (`[Unreleased]`) ergänzt
+- [ ] On-Device-Review; **kein** Tag/Release vor Review und vor Merge von
+      Branch 2 (`feat/ics-import`)
+
+**Offene Detail-Calls (vor Review klären, nicht-blockierend):**
+- Kalender→Event-Mapping nutzt das per-`VEVENT`-Property `X-CALENDULA-CALENDAR`
+  (statt `X-WR-CALNAME`), damit eine kombinierte Datei mehrere Kalender trägt.
+- Backup = **eine** kombinierte `VCALENDAR`-Datei über alle lokalen Kalender.
+- EXDATE / `RECURRENCE-ID`-Ausnahmen werden beim Export ausgelassen
+  (`ORIGINAL_ID IS NULL`) — dokumentierter v1-Grenzfall, Import lässt sie auch aus.