chore: merge main into release/v1.1.0 (#42)

Brings the exact tag checks from #40 into the release branch. beta.yaml runs from the branch's own files, and the old prefix-matching lookup treated v1.1.0-beta.1 as a shipped v1.1.0, so the 1.1.0-beta.2 run was refused.

The one conflict was in publish_codeberg_release.sh: kept #40's stricter upload handling plus the offline APK assets from #41. scripts/release_gate.sh now reports cut=true for 1.1.0-beta.2.

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

.gitea/workflows/beta.yaml

@@ -27,7 +27,7 @@ jobs:
   detect:
     # Gitea only; see the same guard in release.yaml.
     if: github.repository_owner == 'makiolaj'
-    runs-on: light
+    runs-on: docker
     outputs:
       is_beta: ${{ steps.v.outputs.is_beta }}
       version: ${{ steps.v.outputs.version }}
@@ -57,7 +57,7 @@ jobs:
   beta:
     needs: detect
     if: needs.detect.outputs.is_beta == 'true'
-    runs-on: gradle
+    runs-on: docker
     env:
       ANDROID_HOME: /opt/android-sdk
       ANDROID_SDK_ROOT: /opt/android-sdk

.gitea/workflows/release.yaml

@@ -48,7 +48,7 @@ jobs:
     # secrets. repository_owner differs between the two forges regardless of
     # URL, proxy or instance rename, so this closes it permanently.
     if: github.repository_owner == 'makiolaj'
-    runs-on: light
+    runs-on: docker
     outputs:
       is_release: ${{ steps.v.outputs.is_release }}
       version: ${{ steps.v.outputs.version }}
@@ -105,7 +105,7 @@ jobs:
   release:
     needs: detect
     if: needs.detect.outputs.is_release == 'true' || github.event_name == 'workflow_dispatch'
-    runs-on: gradle
+    runs-on: docker
     env:
       ANDROID_HOME: /opt/android-sdk
       ANDROID_SDK_ROOT: /opt/android-sdk

CHANGELOG.md

@@ -7,51 +7,6 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
-### Added
-- A reminder can count from the task's start as well as from its due date, and
-  tasks with only a start date get reminders too. Default reminders can mix
-  both, e.g. a day before the start and an hour before the due date; each
-  applies to tasks that have its date (#72).
-- An all-day task's reminders can each have their own time, so one task can
-  remind you at 09:00 and again at 17:00 (#78).
-- Other apps can read the tasks kept in Agendula's own database through an
-  OpenTasks-compatible provider, once you grant them permission. Apps that
-  already support OpenTasks or tasks.org need only a small change to support
-  Agendula too (#43).
-- With a second permission, other apps can also add, edit, complete and delete
-  those tasks, including their reminders and tags. They can tick off a single
-  occurrence of a recurring task. Task lists stay read-only for them (#63).
-
-### Changed
-- A new task no longer takes a default reminder whose time has already
-  passed, so a start of "today" does not ring the moment the task is saved.
-- All-day default reminders are whole days; one set in hours rounds to the
-  nearest day.
-- Switching a task between timed and all-day converts its reminders right
-  away in the editor, so what you see is what gets saved.
-- The editor shows the default reminders a new task, or a newly added date,
-  will get, before you save. Removing them leaves the task without a reminder
-  instead of falling back to the default.
-- Reminders now sync. A reminder set on a task is uploaded as a standard alarm
-  (`VALARM`), so it also notifies in macOS and iOS Reminders, Thunderbird,
-  tasks.org and jtx Board, and alarms set in those apps now fire in Agendula
-  instead of the default reminder. Removing a task's alarm in another app
-  turns it off here too, rather than falling back to the default (#52).
-- A new task with a date, or one that gets a new date, takes the default
-  reminder for that date as its own, so it travels with the task to the server.
-  Changing the default later no longer changes those tasks; tasks that rely on
-  the default today are left as they are.
-- On upgrade, reminders on open, synced tasks that so far stayed on this
-  device are uploaded once.
-- Alarms imported from an `.ics` file become reminders on the task.
-- Screens now open and close the way they do in Calendula: they slide in, and
-  a back swipe previews the screen behind before closing (#66).
-- Settings now use Calendula's names and layout. Reminders is now
-  Notifications, Task form is now New task form, and export and import moved
-  out of Storage into a new Backup & restore section (#66).
-
-## [1.1.0] - 2026-10-10
-
 ### Added
 - Four new home-screen widgets: Today, Up next, Lists and Week.
 - A widget can show tasks from several lists at once, optionally grouped by
@@ -59,13 +14,6 @@ All notable changes to this project are documented here. The format follows
 - A setting under Settings → Task form pre-fills a new task's start with today.
 - An offline version of Agendula with no sync and no network access at all,
   published as a separate APK on Codeberg (#39).
-- Tags. Add them while editing a task, see them on the task and in lists,
-  browse them from the home screen and filter any list by them. They are saved
-  as `CATEGORIES`, so they sync with Nextcloud Tasks, tasks.org and DAVx⁵ (#35).
-- Filters. Save your own view of the open tasks by due date (overdue, today,
-  upcoming, no date, in any combination), lists, tags and minimum priority.
-  They live on the home screen and can be shown in the Tasks widget, so today
-  and overdue tasks can now share one widget (#47).
 
 ### Changed
 - The Tasks widget has agenda-style rows, an optional row colour and an "All
@@ -75,17 +23,9 @@ All notable changes to this project are documented here. The format follows
   showed.
 - Synced lists can be renamed and deleted, not only device-only ones. A
   read-only share shows the edit button greyed out and explains why on tap.
-- The sort button in task lists now opens "Sort and filter", which can also
-  filter by tag.
-- While editing a task, its title moves into the top bar once you scroll past
-  it.
 
 ### Fixed
 - The list editor's Where and smart-lists rows no longer have double padding.
-- A field you tap now scrolls fully above the keyboard, and the "add subtask"
-  row in task lists no longer ends up hidden behind it.
-- All-day tasks west of UTC no longer show up a day early in Overdue, Today
-  and Upcoming.
 
 ## [1.0.0] - 2026-09-21
 

README.md

@@ -15,10 +15,6 @@ required.</p>
 </p>
 
 <p>
-<a href="https://f-droid.org/packages/de.jeanlucmakiola.agendula/"><img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png" alt="Get it on F-Droid" height="56"></a>
-&nbsp;
-<a href="https://play.google.com/store/apps/details?id=de.jeanlucmakiola.agendula"><img src="https://play.google.com/intl/en_us/badges/static/images/badges/en_badge_web_generic.png" alt="Get it on Google Play" height="56"></a>
-&nbsp;
 <a href="https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://codeberg.org/jlmakiola/agendula"><img src="https://github.com/ImranR98/Obtainium/blob/main/assets/graphics/badge_obtainium.png?raw=true" alt="Get it on Obtainium" height="56"></a>
 &nbsp;
 <a href="https://ko-fi.com/jeanlucmakiola"><img src="https://storage.ko-fi.com/cdn/brandasset/v2/support_me_on_kofi_badge_beige.png" alt="Support me on Ko-fi" height="56"></a>
@@ -54,8 +50,7 @@ many small *florets* — so the two apps are florets of one bloom.)
   this and the following ones, or the whole series.
 - **Reminders** that fire at the exact time: several per task, separate defaults
   for timed and all-day tasks (globally and per list), Done and Snooze right on
-  the notification, and they survive reboots. They sync as standard `VALARM`s,
+  the notification, and they survive reboots.
-  so they also ring in other CalDAV clients, and theirs ring here.
 - **iCalendar import and export** — open an `.ics` or a zip of them, or write any
   list out as standard `.ics` files.
 - A **home-screen widget**, launcher shortcuts, a Quick Settings tile, and
@@ -81,16 +76,6 @@ back to a full comparison where it does not. Everything the store does not model
 is kept verbatim and sent back unchanged, so passing your tasks through Agendula
 does not quietly lose fields another client wrote.
 
-### Tested With
-
-The following CalDAV Services have been Tested
-
-
-
-| Service | Version | Date | Status | User |
-|---|---|---|---|---|
-| **Nextcloud** | 25.0.0 | Oct 9th 2026 | ✅ | [@jlmakiola](https://codeberg.org/jlmakiola) [@Schanbro](https://codeberg.org/Schanbro)
-
 ## Where your tasks live
 
 |  | Where | Sync | Needs |
@@ -102,10 +87,6 @@ Agendula's own store is an ordinary app database, so it **coexists with
 OpenTasks rather than replacing it**. If you already sync through a provider,
 Agendula can work on top of it exactly as before.
 
-Other apps can read and write the tasks in Agendula's own store through an
-OpenTasks-compatible provider, once you grant them permission. See
-[docs/CONTENT_PROVIDER.md](docs/CONTENT_PROVIDER.md).
-
 Switching between the two moves nothing — each store keeps its own tasks — so
 **Settings → Storage** asks before it switches, and offers to **copy** a
 provider's tasks into Agendula's own store when you want to move over. The copy
@@ -116,20 +97,10 @@ proprietary, and open standards — CalDAV and iCalendar — are the lane.
 
 ## Install
 
-### F-Droid (recommended)
+### F-Droid repository
 
-Agendula is in the official [F-Droid](https://f-droid.org) repository. Search
+Every release is built, signed and published to a self-hosted F-Droid
-for Agendula in any F-Droid client, or
+repository. Add it once and your F-Droid client handles updates from then on:
-[install it from f-droid.org](https://f-droid.org/packages/de.jeanlucmakiola.agendula/).
-
-F-Droid builds from source on its own schedule, so a new version usually shows
-up there a few days after release.
-
-### Self-hosted F-Droid repo (fastest updates)
-
-The release pipeline builds, signs and publishes every release to a
-self-hosted F-Droid repository, so new versions land there first. Add it once
-and your F-Droid client handles updates from then on:
 
 1. In your F-Droid client, open *Settings → Repositories → Add* (or open the
    link below on your phone):
@@ -154,21 +125,12 @@ app.
 Betas of upcoming versions are published there too, as pre-releases; to test
 them, switch on *Include prereleases* for Agendula in Obtainium.
 
-### Google Play
-
-Agendula is on
-[Google Play](https://play.google.com/store/apps/details?id=de.jeanlucmakiola.agendula).
-
-Play builds are signed with Google's key rather than mine, so switching between
-Play and any other channel means uninstalling first. Tasks kept only in
-Agendula's own database go with it, so sync them to a CalDAV account first.
-
 ### Offline version
 
 Each Codeberg release also carries `agendula-offline_v<version>.apk`: Agendula
 without CalDAV sync and **without the network permission**, so it cannot
 connect to anything. It installs alongside the regular app rather than replacing
-it; move tasks between the two with Settings → Backup & restore → Export / Import. In
+it; move tasks between the two with Settings → Storage → Export / Import. In
 Obtainium, pick it with *Filter APKs by regular expression* set to
 `^agendula-offline_v`.
 
@@ -186,9 +148,8 @@ JDK 17 and the Android SDK are all it needs; see
 ## Translations
 
 Translations are managed on a self-hosted **Weblate**, and partial ones are
-fine — an untranslated string simply falls back to English.
+fine — an untranslated string simply falls back to English. Agendula ships in
-
+English, German and Brazilian Portuguese so far.
-<a href="https://weblate.dev.jeanlucmakiola.de/engage/agendula/"><img src="https://weblate.dev.jeanlucmakiola.de/widget/agendula/multi-auto.svg" alt="Translation status" width="600"></a>
 
 **→ [Help translate Agendula](https://weblate.dev.jeanlucmakiola.de/engage/agendula/)**
 

app/build.gradle.kts

@@ -33,8 +33,8 @@ android {
         // (1.0.x: 1.0.0 -> 10000; from 1.1.0: 1.1.0-beta.1 -> 1010001,
         // 1.1.0 -> 1010099), and CI fails if the committed one doesn't match.
         // See docs/RELEASING.md.
-        versionCode = 1020001
+        versionCode = 1010002
-        versionName = "1.2.0-beta.1"
+        versionName = "1.1.0-beta.2"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
 

app/schemas/de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase/2.json

@@ -1,529 +0,0 @@
-{
-  "formatVersion": 1,
-  "database": {
-    "version": 2,
-    "identityHash": "14b159c51416ba27653f6320ac7f6f03",
-    "entities": [
-      {
-        "tableName": "accounts",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `display_name` TEXT NOT NULL, `principal_url` TEXT, `home_set_url` TEXT, `username` TEXT, `last_sync_at` INTEGER, `last_sync_error` TEXT)",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "displayName",
-            "columnName": "display_name",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "principalUrl",
-            "columnName": "principal_url",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "homeSetUrl",
-            "columnName": "home_set_url",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "username",
-            "columnName": "username",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "lastSyncAt",
-            "columnName": "last_sync_at",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "lastSyncError",
-            "columnName": "last_sync_error",
-            "affinity": "TEXT"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        }
-      },
-      {
-        "tableName": "task_lists",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `color` INTEGER NOT NULL, `account_id` INTEGER, `is_visible` INTEGER NOT NULL DEFAULT 1, `is_synced` INTEGER NOT NULL DEFAULT 1, `owner` TEXT, `is_read_only` INTEGER NOT NULL DEFAULT 0, `sort_order` INTEGER NOT NULL DEFAULT 0, `href` TEXT, `ctag` TEXT, `sync_token` TEXT, `is_dirty` INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(`account_id`) REFERENCES `accounts`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "name",
-            "columnName": "name",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "color",
-            "columnName": "color",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "accountId",
-            "columnName": "account_id",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "isVisible",
-            "columnName": "is_visible",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "1"
-          },
-          {
-            "fieldPath": "isSynced",
-            "columnName": "is_synced",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "1"
-          },
-          {
-            "fieldPath": "owner",
-            "columnName": "owner",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "isReadOnly",
-            "columnName": "is_read_only",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "sortOrder",
-            "columnName": "sort_order",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "href",
-            "columnName": "href",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "ctag",
-            "columnName": "ctag",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "syncToken",
-            "columnName": "sync_token",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "isDirty",
-            "columnName": "is_dirty",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        },
-        "indices": [
-          {
-            "name": "index_task_lists_account_id",
-            "unique": false,
-            "columnNames": [
-              "account_id"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_task_lists_account_id` ON `${TABLE_NAME}` (`account_id`)"
-          }
-        ],
-        "foreignKeys": [
-          {
-            "table": "accounts",
-            "onDelete": "SET NULL",
-            "onUpdate": "NO ACTION",
-            "columns": [
-              "account_id"
-            ],
-            "referencedColumns": [
-              "id"
-            ]
-          }
-        ]
-      },
-      {
-        "tableName": "tasks",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `list_id` INTEGER NOT NULL, `uid` TEXT NOT NULL, `href` TEXT, `etag` TEXT, `title` TEXT, `description` TEXT, `location` TEXT, `url` TEXT, `color` INTEGER, `categories` TEXT NOT NULL DEFAULT '', `status` INTEGER NOT NULL DEFAULT 0, `percent_complete` INTEGER, `completed_at` INTEGER, `priority` INTEGER NOT NULL DEFAULT 0, `classification` INTEGER, `dtstart` INTEGER, `due` INTEGER, `duration` TEXT, `is_all_day` INTEGER NOT NULL DEFAULT 0, `timezone` TEXT, `rrule` TEXT, `rdate` TEXT, `exdate` TEXT, `recurrence_id` INTEGER, `master_id` INTEGER, `parent_id` INTEGER, `sort_order` INTEGER NOT NULL DEFAULT 0, `created_at` INTEGER, `last_modified` INTEGER, `sequence` INTEGER NOT NULL DEFAULT 0, `is_dirty` INTEGER NOT NULL DEFAULT 0, `is_deleted` INTEGER NOT NULL DEFAULT 0, `unknown_properties` TEXT, FOREIGN KEY(`list_id`) REFERENCES `task_lists`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`master_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`parent_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "listId",
-            "columnName": "list_id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "uid",
-            "columnName": "uid",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "href",
-            "columnName": "href",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "etag",
-            "columnName": "etag",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "title",
-            "columnName": "title",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "description",
-            "columnName": "description",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "location",
-            "columnName": "location",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "url",
-            "columnName": "url",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "color",
-            "columnName": "color",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "categories",
-            "columnName": "categories",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "''"
-          },
-          {
-            "fieldPath": "status",
-            "columnName": "status",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "percentComplete",
-            "columnName": "percent_complete",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "completedAt",
-            "columnName": "completed_at",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "priority",
-            "columnName": "priority",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "classification",
-            "columnName": "classification",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "dtstart",
-            "columnName": "dtstart",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "due",
-            "columnName": "due",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "duration",
-            "columnName": "duration",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "isAllDay",
-            "columnName": "is_all_day",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "timezone",
-            "columnName": "timezone",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "rrule",
-            "columnName": "rrule",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "rdate",
-            "columnName": "rdate",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "exdate",
-            "columnName": "exdate",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "recurrenceId",
-            "columnName": "recurrence_id",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "masterId",
-            "columnName": "master_id",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "parentId",
-            "columnName": "parent_id",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "sortOrder",
-            "columnName": "sort_order",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "createdAt",
-            "columnName": "created_at",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "lastModified",
-            "columnName": "last_modified",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "sequence",
-            "columnName": "sequence",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isDirty",
-            "columnName": "is_dirty",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isDeleted",
-            "columnName": "is_deleted",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "unknownProperties",
-            "columnName": "unknown_properties",
-            "affinity": "TEXT"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        },
-        "indices": [
-          {
-            "name": "index_tasks_list_id_is_deleted",
-            "unique": false,
-            "columnNames": [
-              "list_id",
-              "is_deleted"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_list_id_is_deleted` ON `${TABLE_NAME}` (`list_id`, `is_deleted`)"
-          },
-          {
-            "name": "index_tasks_parent_id",
-            "unique": false,
-            "columnNames": [
-              "parent_id"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_parent_id` ON `${TABLE_NAME}` (`parent_id`)"
-          },
-          {
-            "name": "index_tasks_master_id_recurrence_id",
-            "unique": false,
-            "columnNames": [
-              "master_id",
-              "recurrence_id"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_master_id_recurrence_id` ON `${TABLE_NAME}` (`master_id`, `recurrence_id`)"
-          },
-          {
-            "name": "index_tasks_is_dirty",
-            "unique": false,
-            "columnNames": [
-              "is_dirty"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_is_dirty` ON `${TABLE_NAME}` (`is_dirty`)"
-          },
-          {
-            "name": "index_tasks_list_id_uid_recurrence_id",
-            "unique": true,
-            "columnNames": [
-              "list_id",
-              "uid",
-              "recurrence_id"
-            ],
-            "orders": [],
-            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_tasks_list_id_uid_recurrence_id` ON `${TABLE_NAME}` (`list_id`, `uid`, `recurrence_id`)"
-          }
-        ],
-        "foreignKeys": [
-          {
-            "table": "task_lists",
-            "onDelete": "CASCADE",
-            "onUpdate": "NO ACTION",
-            "columns": [
-              "list_id"
-            ],
-            "referencedColumns": [
-              "id"
-            ]
-          },
-          {
-            "table": "tasks",
-            "onDelete": "CASCADE",
-            "onUpdate": "NO ACTION",
-            "columns": [
-              "master_id"
-            ],
-            "referencedColumns": [
-              "id"
-            ]
-          },
-          {
-            "table": "tasks",
-            "onDelete": "SET NULL",
-            "onUpdate": "NO ACTION",
-            "columns": [
-              "parent_id"
-            ],
-            "referencedColumns": [
-              "id"
-            ]
-          }
-        ]
-      },
-      {
-        "tableName": "task_alarms",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `task_id` INTEGER NOT NULL, `minutes_before` INTEGER NOT NULL, `reference` TEXT NOT NULL DEFAULT 'DUE', `message` TEXT, FOREIGN KEY(`task_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "taskId",
-            "columnName": "task_id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "minutesBefore",
-            "columnName": "minutes_before",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "reference",
-            "columnName": "reference",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "'DUE'"
-          },
-          {
-            "fieldPath": "message",
-            "columnName": "message",
-            "affinity": "TEXT"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        },
-        "indices": [
-          {
-            "name": "index_task_alarms_task_id",
-            "unique": false,
-            "columnNames": [
-              "task_id"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_task_alarms_task_id` ON `${TABLE_NAME}` (`task_id`)"
-          }
-        ],
-        "foreignKeys": [
-          {
-            "table": "tasks",
-            "onDelete": "CASCADE",
-            "onUpdate": "NO ACTION",
-            "columns": [
-              "task_id"
-            ],
-            "referencedColumns": [
-              "id"
-            ]
-          }
-        ]
-      }
-    ],
-    "setupQueries": [
-      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
-      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '14b159c51416ba27653f6320ac7f6f03')"
-    ]
-  }
-}

app/schemas/de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase/3.json

@@ -1,548 +0,0 @@
-{
-  "formatVersion": 1,
-  "database": {
-    "version": 3,
-    "identityHash": "725292b38bce25ce9032c4650573ae85",
-    "entities": [
-      {
-        "tableName": "accounts",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `display_name` TEXT NOT NULL, `principal_url` TEXT, `home_set_url` TEXT, `username` TEXT, `last_sync_at` INTEGER, `last_sync_error` TEXT)",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "displayName",
-            "columnName": "display_name",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "principalUrl",
-            "columnName": "principal_url",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "homeSetUrl",
-            "columnName": "home_set_url",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "username",
-            "columnName": "username",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "lastSyncAt",
-            "columnName": "last_sync_at",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "lastSyncError",
-            "columnName": "last_sync_error",
-            "affinity": "TEXT"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        }
-      },
-      {
-        "tableName": "task_lists",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `color` INTEGER NOT NULL, `account_id` INTEGER, `is_visible` INTEGER NOT NULL DEFAULT 1, `is_synced` INTEGER NOT NULL DEFAULT 1, `owner` TEXT, `is_read_only` INTEGER NOT NULL DEFAULT 0, `sort_order` INTEGER NOT NULL DEFAULT 0, `href` TEXT, `ctag` TEXT, `sync_token` TEXT, `is_dirty` INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(`account_id`) REFERENCES `accounts`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "name",
-            "columnName": "name",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "color",
-            "columnName": "color",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "accountId",
-            "columnName": "account_id",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "isVisible",
-            "columnName": "is_visible",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "1"
-          },
-          {
-            "fieldPath": "isSynced",
-            "columnName": "is_synced",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "1"
-          },
-          {
-            "fieldPath": "owner",
-            "columnName": "owner",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "isReadOnly",
-            "columnName": "is_read_only",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "sortOrder",
-            "columnName": "sort_order",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "href",
-            "columnName": "href",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "ctag",
-            "columnName": "ctag",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "syncToken",
-            "columnName": "sync_token",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "isDirty",
-            "columnName": "is_dirty",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        },
-        "indices": [
-          {
-            "name": "index_task_lists_account_id",
-            "unique": false,
-            "columnNames": [
-              "account_id"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_task_lists_account_id` ON `${TABLE_NAME}` (`account_id`)"
-          }
-        ],
-        "foreignKeys": [
-          {
-            "table": "accounts",
-            "onDelete": "SET NULL",
-            "onUpdate": "NO ACTION",
-            "columns": [
-              "account_id"
-            ],
-            "referencedColumns": [
-              "id"
-            ]
-          }
-        ]
-      },
-      {
-        "tableName": "tasks",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `list_id` INTEGER NOT NULL, `uid` TEXT NOT NULL, `href` TEXT, `etag` TEXT, `title` TEXT, `description` TEXT, `location` TEXT, `url` TEXT, `color` INTEGER, `categories` TEXT NOT NULL DEFAULT '', `status` INTEGER NOT NULL DEFAULT 0, `percent_complete` INTEGER, `completed_at` INTEGER, `priority` INTEGER NOT NULL DEFAULT 0, `classification` INTEGER, `dtstart` INTEGER, `due` INTEGER, `duration` TEXT, `is_all_day` INTEGER NOT NULL DEFAULT 0, `timezone` TEXT, `rrule` TEXT, `rdate` TEXT, `exdate` TEXT, `recurrence_id` INTEGER, `master_id` INTEGER, `parent_id` INTEGER, `sort_order` INTEGER NOT NULL DEFAULT 0, `created_at` INTEGER, `last_modified` INTEGER, `sequence` INTEGER NOT NULL DEFAULT 0, `is_dirty` INTEGER NOT NULL DEFAULT 0, `is_deleted` INTEGER NOT NULL DEFAULT 0, `unknown_properties` TEXT, `reminders_off` INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(`list_id`) REFERENCES `task_lists`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`master_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`parent_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "listId",
-            "columnName": "list_id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "uid",
-            "columnName": "uid",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "href",
-            "columnName": "href",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "etag",
-            "columnName": "etag",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "title",
-            "columnName": "title",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "description",
-            "columnName": "description",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "location",
-            "columnName": "location",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "url",
-            "columnName": "url",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "color",
-            "columnName": "color",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "categories",
-            "columnName": "categories",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "''"
-          },
-          {
-            "fieldPath": "status",
-            "columnName": "status",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "percentComplete",
-            "columnName": "percent_complete",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "completedAt",
-            "columnName": "completed_at",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "priority",
-            "columnName": "priority",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "classification",
-            "columnName": "classification",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "dtstart",
-            "columnName": "dtstart",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "due",
-            "columnName": "due",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "duration",
-            "columnName": "duration",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "isAllDay",
-            "columnName": "is_all_day",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "timezone",
-            "columnName": "timezone",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "rrule",
-            "columnName": "rrule",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "rdate",
-            "columnName": "rdate",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "exdate",
-            "columnName": "exdate",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "recurrenceId",
-            "columnName": "recurrence_id",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "masterId",
-            "columnName": "master_id",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "parentId",
-            "columnName": "parent_id",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "sortOrder",
-            "columnName": "sort_order",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "createdAt",
-            "columnName": "created_at",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "lastModified",
-            "columnName": "last_modified",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "sequence",
-            "columnName": "sequence",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isDirty",
-            "columnName": "is_dirty",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isDeleted",
-            "columnName": "is_deleted",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "unknownProperties",
-            "columnName": "unknown_properties",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "remindersOff",
-            "columnName": "reminders_off",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        },
-        "indices": [
-          {
-            "name": "index_tasks_list_id_is_deleted",
-            "unique": false,
-            "columnNames": [
-              "list_id",
-              "is_deleted"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_list_id_is_deleted` ON `${TABLE_NAME}` (`list_id`, `is_deleted`)"
-          },
-          {
-            "name": "index_tasks_parent_id",
-            "unique": false,
-            "columnNames": [
-              "parent_id"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_parent_id` ON `${TABLE_NAME}` (`parent_id`)"
-          },
-          {
-            "name": "index_tasks_master_id_recurrence_id",
-            "unique": false,
-            "columnNames": [
-              "master_id",
-              "recurrence_id"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_master_id_recurrence_id` ON `${TABLE_NAME}` (`master_id`, `recurrence_id`)"
-          },
-          {
-            "name": "index_tasks_is_dirty",
-            "unique": false,
-            "columnNames": [
-              "is_dirty"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_tasks_is_dirty` ON `${TABLE_NAME}` (`is_dirty`)"
-          },
-          {
-            "name": "index_tasks_list_id_uid_recurrence_id",
-            "unique": true,
-            "columnNames": [
-              "list_id",
-              "uid",
-              "recurrence_id"
-            ],
-            "orders": [],
-            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_tasks_list_id_uid_recurrence_id` ON `${TABLE_NAME}` (`list_id`, `uid`, `recurrence_id`)"
-          }
-        ],
-        "foreignKeys": [
-          {
-            "table": "task_lists",
-            "onDelete": "CASCADE",
-            "onUpdate": "NO ACTION",
-            "columns": [
-              "list_id"
-            ],
-            "referencedColumns": [
-              "id"
-            ]
-          },
-          {
-            "table": "tasks",
-            "onDelete": "CASCADE",
-            "onUpdate": "NO ACTION",
-            "columns": [
-              "master_id"
-            ],
-            "referencedColumns": [
-              "id"
-            ]
-          },
-          {
-            "table": "tasks",
-            "onDelete": "SET NULL",
-            "onUpdate": "NO ACTION",
-            "columns": [
-              "parent_id"
-            ],
-            "referencedColumns": [
-              "id"
-            ]
-          }
-        ]
-      },
-      {
-        "tableName": "task_alarms",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `task_id` INTEGER NOT NULL, `minutes_before` INTEGER NOT NULL, `reference` TEXT NOT NULL DEFAULT 'DUE', `message` TEXT, `uid` TEXT NOT NULL DEFAULT '', `raw` TEXT, FOREIGN KEY(`task_id`) REFERENCES `tasks`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "taskId",
-            "columnName": "task_id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "minutesBefore",
-            "columnName": "minutes_before",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "reference",
-            "columnName": "reference",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "'DUE'"
-          },
-          {
-            "fieldPath": "message",
-            "columnName": "message",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "uid",
-            "columnName": "uid",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "''"
-          },
-          {
-            "fieldPath": "raw",
-            "columnName": "raw",
-            "affinity": "TEXT"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        },
-        "indices": [
-          {
-            "name": "index_task_alarms_task_id",
-            "unique": false,
-            "columnNames": [
-              "task_id"
-            ],
-            "orders": [],
-            "createSql": "CREATE INDEX IF NOT EXISTS `index_task_alarms_task_id` ON `${TABLE_NAME}` (`task_id`)"
-          }
-        ],
-        "foreignKeys": [
-          {
-            "table": "tasks",
-            "onDelete": "CASCADE",
-            "onUpdate": "NO ACTION",
-            "columns": [
-              "task_id"
-            ],
-            "referencedColumns": [
-              "id"
-            ]
-          }
-        ]
-      }
-    ],
-    "setupQueries": [
-      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
-      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '725292b38bce25ce9032c4650573ae85')"
-    ]
-  }
-}

app/src/androidTest/java/de/jeanlucmakiola/agendula/data/tasks/legacy/OneShotImportTest.kt

@@ -212,15 +212,6 @@ class OneShotImportTest {
         assertThat(db.alarms().all().map { it.message }).doesNotContain("Errands")
     }
 
-    @Test
-    fun importsCategoryPropertiesAsTags() {
-        importer.importFrom(fixture())
-        val tasks = taskRows()
-
-        assertThat(tasks.getValue("Buy milk").categories).containsExactly("Errands")
-        assertThat(tasks.getValue("Ship the release").categories).isEmpty()
-    }
-
     // --- running it -----------------------------------------------------------
 
     @Test

app/src/androidTest/java/de/jeanlucmakiola/agendula/data/tasks/provider/AgendulaTaskProviderTest.kt

@@ -1,157 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import android.content.ContentProviderOperation
-import android.content.ContentValues
-import android.content.Context
-import android.content.pm.PermissionInfo
-import android.os.Build
-import android.os.ParcelFileDescriptor
-import androidx.core.net.toUri
-import androidx.test.core.app.ApplicationProvider
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import com.google.common.truth.Truth.assertThat
-import org.junit.Assert.assertThrows
-import org.junit.Assume.assumeTrue
-import org.junit.Test
-import org.junit.runner.RunWith
-
-/** The provider as another app meets it: manifest, permission, URIs. */
-@RunWith(AndroidJUnit4::class)
-class AgendulaTaskProviderTest {
-
-    private val context = ApplicationProvider.getApplicationContext<Context>()
-    private val authority = "${context.packageName}.tasks"
-    private val readPermission = "${context.packageName}.permission.READ_TASKS"
-    private val writePermission = "${context.packageName}.permission.WRITE_TASKS"
-    private val resolver = context.contentResolver
-
-    private fun uri(path: String) = "content://$authority/$path".toUri()
-
-    @Test
-    fun isExportedUnderItsPermissions() {
-        val info = requireNotNull(context.packageManager.resolveContentProvider(authority, 0))
-
-        assertThat(info.name).isEqualTo(AgendulaTaskProvider::class.java.name)
-        assertThat(info.exported).isTrue()
-        assertThat(info.readPermission).isEqualTo(readPermission)
-        assertThat(info.writePermission).isEqualTo(writePermission)
-    }
-
-    @Test
-    fun bothPermissionsAreDangerous() {
-        listOf(readPermission, writePermission).forEach { permission ->
-            val info = context.packageManager.getPermissionInfo(permission, 0)
-
-            assertThat(info.protection).isEqualTo(PermissionInfo.PROTECTION_DANGEROUS)
-            assertThat(info.loadLabel(context.packageManager).toString()).isNotEmpty()
-            assertThat(info.loadDescription(context.packageManager)?.toString()).isNotEmpty()
-        }
-    }
-
-    @Test
-    fun anAppWithoutThePermissionIsDenied() {
-        assumeTrue(Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
-        // The shell is another uid that was never granted it.
-        val output = shell("content query --uri content://$authority/tasks")
-
-        assertThat(output).contains("Permission Denial")
-    }
-
-    @Test
-    fun anAppWithoutTheWritePermissionCannotWrite() {
-        assumeTrue(Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
-
-        val output = shell("content insert --uri content://$authority/tasks --bind title:s:x --bind list_id:i:1")
-
-        assertThat(output).contains("Permission Denial")
-        assertThat(output).contains(writePermission)
-    }
-
-    @Test
-    fun reportsOpenTasksMimeTypes() {
-        ProviderTable.entries.forEach { table ->
-            assertThat(resolver.getType(uri(table.path))).isEqualTo(table.mimeType(single = false))
-            assertThat(resolver.getType(uri("${table.path}/3"))).isEqualTo(table.mimeType(single = true))
-        }
-    }
-
-    @Test
-    fun everyTableAnswersWithItsColumns() {
-        ProviderTable.entries.forEach { table ->
-            resolver.query(uri(table.path), null, null, null, null)!!.use {
-                assertThat(it.columnNames.toList()).containsExactlyElementsIn(table.columns.map { c -> c.first }).inOrder()
-            }
-        }
-    }
-
-    @Test
-    fun aCursorWatchesTheUriItWasQueriedFor() {
-        val tasks = uri("tasks")
-
-        resolver.query(tasks, null, null, null, null)!!.use { assertThat(it.notificationUri).isEqualTo(tasks) }
-    }
-
-    @Test
-    fun aRowUriReadsOnlyThatRow() {
-        // Ids start at 1, so 0 names nothing whatever the store holds.
-        resolver.query(uri("tasks/0"), null, null, null, null)!!.use { assertThat(it.count).isEqualTo(0) }
-        resolver.query(uri("tasks/0"), null, "1 = 1 OR 1 = 1", null, null)!!.use { assertThat(it.count).isEqualTo(0) }
-    }
-
-    @Test
-    fun anUnknownUriIsRejected() {
-        assertThrows(IllegalArgumentException::class.java) { resolver.query(uri("events"), null, null, null, null) }
-        // ContentResolver.getType swallows the provider's exception and answers null.
-        assertThat(runCatching { resolver.getType(uri("tasks/abc")) }.getOrNull()).isNull()
-    }
-
-    @Test
-    fun listsAreReadOnly() {
-        val values = ContentValues().apply { put("list_name", "x") }
-
-        assertThrows(UnsupportedOperationException::class.java) { resolver.insert(uri("tasklists"), values) }
-        assertThrows(UnsupportedOperationException::class.java) { resolver.update(uri("tasklists/1"), values, null, null) }
-        assertThrows(UnsupportedOperationException::class.java) { resolver.delete(uri("tasklists/1"), null, null) }
-    }
-
-    @Test
-    fun aRowUriTakesNoInsert() {
-        assertThrows(IllegalArgumentException::class.java) {
-            resolver.insert(uri("tasks/1"), ContentValues().apply { put("title", "x") })
-        }
-    }
-
-    @Test
-    fun aBadWriteReachesTheClientAsIllegalArgument() {
-        // No list has this id, so nothing in the app's real store is touched.
-        val values = ContentValues().apply {
-            put("list_id", Long.MAX_VALUE)
-            put("title", "x")
-        }
-
-        assertThrows(IllegalArgumentException::class.java) { resolver.insert(uri("tasks"), values) }
-    }
-
-    @Test
-    fun aFailingBatchWritesNothing() {
-        val missingList = Long.MAX_VALUE
-        val operations = arrayListOf(
-            ContentProviderOperation.newInsert(uri("tasks")).withValue("list_id", missingList).withValue("title", "a").build(),
-        )
-
-        assertThrows(IllegalArgumentException::class.java) { resolver.applyBatch(authority, operations) }
-        resolver.query(uri("tasks"), arrayOf("_id"), "list_id = ?", arrayOf(missingList.toString()), null)!!
-            .use { assertThat(it.count).isEqualTo(0) }
-    }
-
-    /** stdout and stderr of [command]; the denial lands on stderr. */
-    private fun shell(command: String): String {
-        val (stdout, stdin, stderr) = InstrumentationRegistry.getInstrumentation().uiAutomation
-            .executeShellCommandRwe(command)
-        stdin.close()
-        return listOf(stdout, stderr).joinToString("\n") { pfd ->
-            ParcelFileDescriptor.AutoCloseInputStream(pfd).bufferedReader().use { it.readText() }
-        }
-    }
-}

app/src/androidTest/java/de/jeanlucmakiola/agendula/data/tasks/provider/ProviderSnapshotSourceTest.kt

@@ -1,214 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import android.content.Context
-import android.database.ContentObserver
-import android.database.Cursor
-import android.net.Uri
-import androidx.room.Room
-import androidx.test.core.app.ApplicationProvider
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.agendula.data.tasks.ProviderEnvironment
-import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
-import de.jeanlucmakiola.agendula.data.tasks.StorageMode
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Instances
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Lists
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Tasks
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskListEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
-import org.junit.After
-import org.junit.Before
-import org.junit.Test
-import org.junit.runner.RunWith
-import java.util.concurrent.LinkedBlockingQueue
-import java.util.concurrent.TimeUnit
-import kotlin.time.Clock
-import kotlin.time.Duration.Companion.days
-import kotlin.time.Duration.Companion.minutes
-import kotlin.time.Instant
-
-/** The snapshot follows the Room store, the storage mode and the clock, and says when it moved. */
-@RunWith(AndroidJUnit4::class)
-class ProviderSnapshotSourceTest {
-
-    private val context = ApplicationProvider.getApplicationContext<Context>()
-    private lateinit var db: TasksDatabase
-    private lateinit var resolver: ProviderResolver
-    private lateinit var source: ProviderSnapshotSource
-    private val clock = MutableClock(Instant.parse("2026-10-10T08:00:00Z"))
-    private val changes = LinkedBlockingQueue<Uri>()
-    private val observer = object : ContentObserver(null) {
-        override fun onChange(selfChange: Boolean, uri: Uri?) {
-            changes += uri ?: Uri.EMPTY
-        }
-    }
-    private var listId = 0L
-
-    @Before
-    fun setUp() {
-        db = Room.inMemoryDatabaseBuilder(context, TasksDatabase::class.java).allowMainThreadQueries().build()
-        resolver = ProviderResolver(NoProviderInstalled)
-        source = ProviderSnapshotSource(context, db, resolver, awaitStartup = {}, clock = clock)
-        listId = db.taskLists().insert(TaskListEntity(name = "Home", color = 0xFF112233.toInt()))
-        context.contentResolver.registerContentObserver(TasksContract.authorityUri(source.authority), true, observer)
-    }
-
-    @After
-    fun tearDown() {
-        context.contentResolver.unregisterContentObserver(observer)
-        db.close()
-    }
-
-    private fun query(table: ProviderTable, selection: String? = null, args: Array<String>? = null): Cursor =
-        source.query(table, null, selection, args, null)
-
-    private fun titles(): List<String?> = query(ProviderTable.TASKS).use { cursor ->
-        val index = cursor.getColumnIndexOrThrow(Tasks.TITLE)
-        buildList { while (cursor.moveToNext()) add(cursor.getString(index)) }
-    }
-
-    private fun insert(title: String, due: Instant? = null, rrule: String? = null): Long =
-        db.tasks().insert(TaskEntity(listId = listId, uid = title, title = title, due = due, rrule = rrule, timezone = "UTC"))
-
-    /** Waits for the coalesced notification, then drains any stragglers. */
-    private fun awaitChange() {
-        assertThat(changes.poll(5, TimeUnit.SECONDS)).isNotNull()
-        Thread.sleep(700)
-        changes.clear()
-    }
-
-    private fun assertNoChange() {
-        assertThat(changes.poll(1500, TimeUnit.MILLISECONDS)).isNull()
-    }
-
-    @Test
-    fun servesTheOwnStore() {
-        val id = insert("Milk")
-        db.alarms().insert(TaskAlarmEntity(taskId = id, minutesBefore = 10))
-
-        assertThat(titles()).containsExactly("Milk")
-        query(ProviderTable.LISTS).use {
-            it.moveToFirst()
-            assertThat(it.getString(it.getColumnIndexOrThrow(Lists.NAME))).isEqualTo("Home")
-        }
-        query(ProviderTable.INSTANCES).use { assertThat(it.count).isEqualTo(1) }
-        query(ProviderTable.PROPERTIES).use { assertThat(it.count).isEqualTo(1) }
-    }
-
-    @Test
-    fun aDeletedTaskIsNotPublished() {
-        val id = insert("Gone")
-        insert("Kept")
-        db.tasks().markDeleted(id, clock.now())
-
-        assertThat(titles()).containsExactly("Kept")
-    }
-
-    @Test
-    fun aWriteNotifiesObserversAndIsServedNext() {
-        source.start()
-        assertThat(titles()).isEmpty()
-
-        insert("Later")
-
-        awaitChange()
-        assertThat(titles()).containsExactly("Later")
-    }
-
-    @Test
-    fun aBurstOfWritesNotifiesOnce() {
-        source.start()
-        titles()
-
-        repeat(5) { insert("t$it") }
-
-        assertThat(changes.poll(5, TimeUnit.SECONDS)).isNotNull()
-        assertNoChange()
-    }
-
-    @Test
-    fun externalModeServesNothing() {
-        insert("Mine")
-        resolver.storageMode = StorageMode.EXTERNAL
-
-        ProviderTable.entries.forEach { table -> query(table).use { assertThat(it.count).isEqualTo(0) } }
-    }
-
-    @Test
-    fun switchingModeNotifiesAndRebuilds() {
-        source.start()
-        insert("Mine")
-        assertThat(titles()).containsExactly("Mine")
-        changes.clear()
-
-        resolver.storageMode = StorageMode.EXTERNAL
-        awaitChange()
-        assertThat(titles()).isEmpty()
-
-        resolver.storageMode = StorageMode.OWN
-        awaitChange()
-        assertThat(titles()).containsExactly("Mine")
-    }
-
-    @Test
-    fun writesInExternalModeDoNotNotify() {
-        resolver.storageMode = StorageMode.EXTERNAL
-        source.start()
-        titles()
-
-        insert("Hidden")
-
-        assertNoChange()
-    }
-
-    @Test
-    fun aClientSelectionNarrowsTheRows() {
-        insert("a")
-        insert("b")
-
-        query(ProviderTable.TASKS, "${Tasks.TITLE} = ?", arrayOf("b")).use { assertThat(it.count).isEqualTo(1) }
-    }
-
-    @Test
-    fun anHourOldSnapshotIsRebuiltAgainstTheClock() {
-        source.start()
-        insert("Daily", due = Instant.parse("2026-10-10T09:00:00Z"), rrule = "FREQ=DAILY;COUNT=3")
-        awaitChange()
-        assertThat(currentOriginalTime()).isEqualTo(Instant.parse("2026-10-10T09:00:00Z").toEpochMilliseconds())
-
-        clock.current += 1.days
-
-        assertThat(currentOriginalTime()).isEqualTo(Instant.parse("2026-10-11T09:00:00Z").toEpochMilliseconds())
-        awaitChange()
-    }
-
-    @Test
-    fun aFreshSnapshotIsReused() {
-        insert("a")
-        titles()
-
-        clock.current += 30.minutes
-
-        query(ProviderTable.INSTANCES).use { assertThat(it.count).isEqualTo(1) }
-        assertNoChange()
-    }
-
-    private fun currentOriginalTime(): Long =
-        query(ProviderTable.INSTANCES, "${Instances.DISTANCE_FROM_CURRENT} = 0").use {
-            assertThat(it.moveToFirst()).isTrue()
-            it.getLong(it.getColumnIndexOrThrow(Instances.INSTANCE_ORIGINAL_TIME))
-        }
-}
-
-private class MutableClock(var current: Instant) : Clock {
-    override fun now(): Instant = current
-}
-
-private object NoProviderInstalled : ProviderEnvironment {
-    override fun packageDeclaring(authority: String): String? = null
-    override fun isGranted(permission: String): Boolean = false
-    override fun appLabel(packageName: String): String? = null
-}

app/src/androidTest/java/de/jeanlucmakiola/agendula/data/tasks/provider/ProviderWriterTest.kt

@@ -1,811 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import android.content.Context
-import androidx.room.Room
-import androidx.test.core.app.ApplicationProvider
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.agendula.data.tasks.ProviderEnvironment
-import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
-import de.jeanlucmakiola.agendula.data.tasks.StorageMode
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Alarm
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Category
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Instances
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Properties
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Tasks
-import de.jeanlucmakiola.agendula.data.tasks.room.AccountEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.AlarmReference
-import de.jeanlucmakiola.agendula.data.tasks.room.RoomTasksDataSource
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskListEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
-import de.jeanlucmakiola.agendula.domain.TaskStatus
-import org.junit.After
-import org.junit.Assert.assertThrows
-import org.junit.Before
-import org.junit.Test
-import org.junit.runner.RunWith
-import kotlin.time.Clock
-import kotlin.time.Duration.Companion.days
-import kotlin.time.Duration.Companion.hours
-import kotlin.time.Duration.Companion.milliseconds
-import kotlinx.coroutines.awaitCancellation
-import kotlin.time.Instant
-
-/** Writes from another app, applied to the own store through the published tables. */
-@RunWith(AndroidJUnit4::class)
-class ProviderWriterTest {
-
-    private val context = ApplicationProvider.getApplicationContext<Context>()
-    private lateinit var db: TasksDatabase
-    private lateinit var resolver: ProviderResolver
-    private lateinit var source: ProviderSnapshotSource
-    private lateinit var writer: ProviderWriter
-    private var afterWrites = 0
-    private var home = 0L
-
-    /** Truncated to the store's granularity, and on the hour so occurrences land on round times. */
-    private val today = Instant.fromEpochMilliseconds(Clock.System.now().toEpochMilliseconds() / 3_600_000 * 3_600_000)
-
-    @Before
-    fun setUp() {
-        db = Room.inMemoryDatabaseBuilder(context, TasksDatabase::class.java).allowMainThreadQueries().build()
-        resolver = ProviderResolver(NoProvider)
-        source = ProviderSnapshotSource(context, db, resolver, awaitStartup = {})
-        writer = ProviderWriter(db, RoomTasksDataSource(db), source, resolver, afterWrite = { afterWrites++ })
-        home = db.taskLists().insert(TaskListEntity(name = "Home", color = 0))
-    }
-
-    @After
-    fun tearDown() = db.close()
-
-    private fun task(id: Long) = db.tasks().entity(id)
-
-    private fun insert(vararg values: Pair<String, Any?>): Long =
-        writer.insert(ProviderTable.TASKS, mapOf(Tasks.LIST_ID to home, *values))
-
-    private fun byId(table: ProviderTable, id: Long) = "${table.idColumn} = $id"
-
-    private fun synced(readOnly: Boolean = false): Long {
-        val account = db.accounts().insert(AccountEntity(displayName = "me", username = "me"))
-        return db.taskLists().insert(
-            TaskListEntity(name = "Work", color = 0, accountId = account, href = "https://s/w/", isReadOnly = readOnly),
-        )
-    }
-
-    private fun dailySeries(title: String = "Daily"): Long = db.tasks().insert(
-        TaskEntity(listId = home, uid = title, title = title, dtstart = today - 1.days, due = today - 1.days + 1.hours,
-            rrule = "FREQ=DAILY;COUNT=5", timezone = "UTC"),
-    )
-
-    /** Each instance of [taskId]'s series by its original time, with its task row and status. */
-    private fun instances(): List<Triple<Long, Long, Int>> =
-        source.rows(
-            ProviderTable.INSTANCES,
-            listOf(Instances.INSTANCE_ORIGINAL_TIME, Instances.TASK_ID, Tasks.STATUS),
-            null,
-            null,
-        ).map { (original, taskId, status) -> Triple(original as Long, taskId as Long, (status as Long).toInt()) }
-
-    private fun instanceId(original: Instant): Long =
-        source.rows(
-            ProviderTable.INSTANCES,
-            listOf(Tasks.ID),
-            "${Instances.INSTANCE_ORIGINAL_TIME} = ?",
-            arrayOf(original.toEpochMilliseconds().toString()),
-        ).single().single() as Long
-
-    // --- inserts ----------------------------------------------------------------
-
-    @Test
-    fun anInsertedTaskIsPublishedAndOwedASync() {
-        val id = insert(Tasks.TITLE to "Milk", Tasks.PRIORITY to 1)
-
-        val stored = task(id)!!
-        assertThat(stored.title).isEqualTo("Milk")
-        assertThat(stored.priority).isEqualTo(1)
-        assertThat(stored.isDirty).isTrue()
-        assertThat(source.rows(ProviderTable.TASKS, listOf(Tasks.TITLE), byId(ProviderTable.TASKS, id), null))
-            .containsExactly(listOf("Milk"))
-        assertThat(afterWrites).isEqualTo(1)
-    }
-
-    @Test
-    fun anInsertNeedsAListThatExistsAndIsWritable() {
-        assertThrows(IllegalArgumentException::class.java) { writer.insert(ProviderTable.TASKS, mapOf(Tasks.TITLE to "x")) }
-        assertThrows(IllegalArgumentException::class.java) { insert(Tasks.LIST_ID to 999L) }
-        val readOnly = synced(readOnly = true)
-        assertThrows(UnsupportedOperationException::class.java) { insert(Tasks.LIST_ID to readOnly) }
-        assertThat(db.tasks().live()).isEmpty()
-    }
-
-    @Test
-    fun anOccurrenceCannotBeInsertedAsATask() {
-        val series = dailySeries()
-
-        assertThrows(IllegalArgumentException::class.java) {
-            insert(Tasks.ORIGINAL_INSTANCE_ID to series, Tasks.ORIGINAL_INSTANCE_TIME to today.toEpochMilliseconds())
-        }
-    }
-
-    @Test
-    fun aDuplicateUidIsRejected() {
-        insert(Tasks.UID to "same")
-
-        assertThrows(IllegalArgumentException::class.java) { insert(Tasks.UID to "same") }
-    }
-
-    @Test
-    fun listsAndInstancesTakeNoInserts() {
-        assertThrows(UnsupportedOperationException::class.java) {
-            writer.insert(ProviderTable.LISTS, mapOf(TasksContract.Lists.NAME to "New"))
-        }
-        assertThrows(UnsupportedOperationException::class.java) { writer.insert(ProviderTable.INSTANCES, emptyMap()) }
-        assertThrows(UnsupportedOperationException::class.java) {
-            writer.update(ProviderTable.LISTS, mapOf(TasksContract.Lists.NAME to "x"), null, null)
-        }
-        assertThrows(UnsupportedOperationException::class.java) { writer.delete(ProviderTable.LISTS, null, null) }
-    }
-
-    @Test
-    fun anUnknownColumnIsRejected() {
-        assertThrows(IllegalArgumentException::class.java) { insert("etag" to "x") }
-    }
-
-    @Test
-    fun nothingIsWrittenInExternalMode() {
-        val id = insert(Tasks.TITLE to "Mine")
-        resolver.storageMode = StorageMode.EXTERNAL
-
-        assertThrows(IllegalStateException::class.java) { insert() }
-        assertThrows(IllegalStateException::class.java) {
-            writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "x"), null, null)
-        }
-        assertThat(task(id)!!.title).isEqualTo("Mine")
-    }
-
-    // --- updates ----------------------------------------------------------------
-
-    @Test
-    fun anUpdateChangesTheRowsItsSelectionMatches() {
-        val a = insert(Tasks.TITLE to "a")
-        val b = insert(Tasks.TITLE to "b")
-
-        val count = writer.update(ProviderTable.TASKS, mapOf(Tasks.STATUS to 2), "${Tasks.TITLE} = ?", arrayOf("b"))
-
-        assertThat(count).isEqualTo(1)
-        assertThat(task(a)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
-        assertThat(task(b)!!.status).isEqualTo(TaskStatus.COMPLETED)
-        assertThat(task(b)!!.completedAt).isNotNull()
-    }
-
-    @Test
-    fun anUpdateMatchingNothingChangesNothing() {
-        insert(Tasks.TITLE to "a")
-
-        assertThat(writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "x"), "${Tasks.TITLE} = 'zzz'", null)).isEqualTo(0)
-    }
-
-    @Test
-    fun aTaskInAReadOnlyListCannotChange() {
-        val readOnly = synced(readOnly = true)
-        val id = db.tasks().insert(TaskEntity(listId = readOnly, uid = "r", title = "theirs"))
-
-        assertThrows(UnsupportedOperationException::class.java) {
-            writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "mine"), byId(ProviderTable.TASKS, id), null)
-        }
-        assertThrows(UnsupportedOperationException::class.java) {
-            writer.delete(ProviderTable.TASKS, byId(ProviderTable.TASKS, id), null)
-        }
-        assertThat(task(id)!!.title).isEqualTo("theirs")
-    }
-
-    @Test
-    fun aTaskMovesBetweenLists() {
-        val work = synced()
-        val id = insert(Tasks.TITLE to "t")
-
-        writer.update(ProviderTable.TASKS, mapOf(Tasks.LIST_ID to work), byId(ProviderTable.TASKS, id), null)
-
-        assertThat(db.tasks().live().single { it.title == "t" }.listId).isEqualTo(work)
-    }
-
-    @Test
-    fun aParentMustBeInTheSameListAndNotADescendant() {
-        val work = synced()
-        val parent = insert(Tasks.TITLE to "parent")
-        val child = insert(Tasks.TITLE to "child", Tasks.PARENT_ID to parent)
-        val elsewhere = insert(Tasks.LIST_ID to work, Tasks.TITLE to "elsewhere")
-
-        assertThat(task(child)!!.parentId).isEqualTo(parent)
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.update(ProviderTable.TASKS, mapOf(Tasks.PARENT_ID to elsewhere), byId(ProviderTable.TASKS, child), null)
-        }
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.update(ProviderTable.TASKS, mapOf(Tasks.PARENT_ID to child), byId(ProviderTable.TASKS, parent), null)
-        }
-        assertThrows(IllegalArgumentException::class.java) { insert(Tasks.PARENT_ID to 999L) }
-    }
-
-    @Test
-    fun movingASeriesDropsTheOverridesItNoLongerGenerates() {
-        val series = dailySeries()
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-        assertThat(db.tasks().overrides(series)).hasSize(1)
-
-        writer.update(
-            ProviderTable.TASKS,
-            mapOf(Tasks.DTSTART to (today + 2.hours).toEpochMilliseconds(), Tasks.DUE to (today + 3.hours).toEpochMilliseconds()),
-            byId(ProviderTable.TASKS, series),
-            null,
-        )
-
-        assertThat(db.tasks().overrides(series)).isEmpty()
-    }
-
-    @Test
-    fun aClientCannotTouchSyncState() {
-        val work = synced()
-        val id = db.tasks().insert(
-            TaskEntity(listId = work, uid = "s", title = "t", href = "/s.ics", etag = "e", sequence = 2, unknownProperties = "X-A:1"),
-        )
-
-        writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "new", "_sync_id" to "x", "sync1" to "y"), byId(ProviderTable.TASKS, id), null)
-
-        val stored = task(id)!!
-        assertThat(stored.title).isEqualTo("new")
-        assertThat(stored.href).isEqualTo("/s.ics")
-        assertThat(stored.etag).isEqualTo("e")
-        assertThat(stored.sequence).isEqualTo(2)
-        assertThat(stored.unknownProperties).isEqualTo("X-A:1")
-        assertThat(stored.isDirty).isTrue()
-    }
-
-    // --- instances --------------------------------------------------------------
-
-    @Test
-    fun completingAnOccurrenceTicksOffOnlyThatOne() {
-        val series = dailySeries()
-
-        val count = writer.update(ProviderTable.INSTANCES, mapOf(Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        assertThat(count).isEqualTo(1)
-        assertThat(task(series)!!.status).isEqualTo(TaskStatus.NEEDS_ACTION)
-        val override = db.tasks().overrides(series).single()
-        assertThat(override.recurrenceId).isEqualTo(today)
-        assertThat(override.status).isEqualTo(TaskStatus.COMPLETED)
-        val statuses = instances().associate { it.first to it.third }
-        assertThat(statuses[today.toEpochMilliseconds()]).isEqualTo(TasksContract.STATUS_COMPLETED)
-        assertThat(statuses.filterKeys { it != today.toEpochMilliseconds() }.values.toSet())
-            .containsExactly(TasksContract.STATUS_NEEDS_ACTION)
-    }
-
-    @Test
-    fun anOccurrenceCanBeCancelledAndReopened() {
-        val series = dailySeries()
-
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.STATUS to 3), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-        assertThat(db.tasks().overrides(series).single().status).isEqualTo(TaskStatus.CANCELLED)
-
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.PERCENT_COMPLETE to 0), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-        assertThat(db.tasks().overrides(series).single().status).isEqualTo(TaskStatus.NEEDS_ACTION)
-    }
-
-    @Test
-    fun contentWrittenToAnOccurrenceEditsTheSeries() {
-        val series = dailySeries()
-
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.TITLE to "Renamed"), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        assertThat(task(series)!!.title).isEqualTo("Renamed")
-        assertThat(db.tasks().overrides(series)).isEmpty()
-    }
-
-    @Test
-    fun anOccurrenceCannotBeMoved() {
-        dailySeries()
-
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.update(ProviderTable.INSTANCES, mapOf(Tasks.DUE to 0L), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-        }
-    }
-
-    @Test
-    fun anOccurrenceHasNoPartialProgress() {
-        dailySeries()
-
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.update(ProviderTable.INSTANCES, mapOf(Tasks.PERCENT_COMPLETE to 50), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-        }
-    }
-
-    @Test
-    fun aPlainTaskInstanceWritesTheTask() {
-        val id = insert(Tasks.TITLE to "t", Tasks.DUE to today.toEpochMilliseconds())
-        val instance = source.rows(ProviderTable.INSTANCES, listOf(Tasks.ID), "${Instances.TASK_ID} = $id", null).single().single() as Long
-
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.PERCENT_COMPLETE to 50, Tasks.DUE to (today + 1.days).toEpochMilliseconds()), byId(ProviderTable.INSTANCES, instance), null)
-
-        assertThat(task(id)!!.status).isEqualTo(TaskStatus.IN_PROCESS)
-        assertThat(task(id)!!.due).isEqualTo(today + 1.days)
-    }
-
-    @Test
-    fun deletingAnOccurrenceExceptsIt() {
-        val series = dailySeries()
-
-        assertThat(writer.delete(ProviderTable.INSTANCES, byId(ProviderTable.INSTANCES, instanceId(today)), null)).isEqualTo(1)
-
-        assertThat(task(series)!!.exdate).isNotNull()
-        assertThat(instances().map { it.first }).doesNotContain(today.toEpochMilliseconds())
-        assertThat(instances()).hasSize(4)
-    }
-
-    @Test
-    fun deletingAModifiedOccurrenceExceptsItToo() {
-        val series = dailySeries()
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        writer.delete(ProviderTable.INSTANCES, byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        assertThat(db.tasks().overrides(series)).isEmpty()
-        assertThat(instances().map { it.first }).doesNotContain(today.toEpochMilliseconds())
-    }
-
-    // --- deletes ----------------------------------------------------------------
-
-    @Test
-    fun aParentGoesWithItsSubtasks() {
-        val parent = insert(Tasks.TITLE to "parent")
-        val child = insert(Tasks.TITLE to "child", Tasks.PARENT_ID to parent)
-        val grandchild = insert(Tasks.TITLE to "grandchild", Tasks.PARENT_ID to child)
-        val other = insert(Tasks.TITLE to "other")
-
-        assertThat(writer.delete(ProviderTable.TASKS, byId(ProviderTable.TASKS, parent), null)).isEqualTo(1)
-
-        assertThat(task(parent)).isNull()
-        assertThat(task(child)).isNull()
-        assertThat(task(grandchild)).isNull()
-        assertThat(task(other)).isNotNull()
-    }
-
-    @Test
-    fun aSyncedTaskLeavesATombstone() {
-        val work = synced()
-        val id = insert(Tasks.LIST_ID to work, Tasks.TITLE to "t")
-
-        writer.delete(ProviderTable.TASKS, byId(ProviderTable.TASKS, id), null)
-
-        assertThat(task(id)!!.isDeleted).isTrue()
-        assertThat(source.rows(ProviderTable.TASKS, listOf(Tasks.ID), null, null)).isEmpty()
-        assertThat(writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "x"), byId(ProviderTable.TASKS, id), null)).isEqualTo(0)
-    }
-
-    @Test
-    fun deletingAnOverrideThroughTasksExceptsTheOccurrence() {
-        val series = dailySeries()
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-        val override = db.tasks().overrides(series).single().id
-
-        writer.delete(ProviderTable.TASKS, byId(ProviderTable.TASKS, override), null)
-
-        assertThat(task(series)).isNotNull()
-        assertThat(task(series)!!.exdate).isNotNull()
-        assertThat(instances()).hasSize(4)
-    }
-
-    // --- properties -------------------------------------------------------------
-
-    @Test
-    fun anAlarmCanBeAddedChangedAndRemoved() {
-        val id = insert(Tasks.TITLE to "t", Tasks.DUE to (today + 1.days).toEpochMilliseconds())
-        db.tasks().update(task(id)!!.copy(isDirty = false))
-
-        val propertyId = writer.insert(
-            ProviderTable.PROPERTIES,
-            mapOf(Properties.TASK_ID to id, Properties.MIMETYPE to Alarm.MIMETYPE, Alarm.MINUTES_BEFORE to "15", Alarm.REFERENCE to "1"),
-        )
-        val alarm = db.alarms().forTask(id).single()
-        assertThat(alarm.minutesBefore).isEqualTo(15)
-        assertThat(alarm.reference).isEqualTo(AlarmReference.DUE)
-        assertThat(task(id)!!.isDirty).isTrue()
-        assertThat(propertyId).isEqualTo(ProviderIds.alarm(alarm.id))
-
-        writer.update(ProviderTable.PROPERTIES, mapOf(Alarm.MINUTES_BEFORE to 60, Alarm.REFERENCE to 2), byId(ProviderTable.PROPERTIES, propertyId), null)
-        assertThat(db.alarms().forTask(id).single().minutesBefore).isEqualTo(60)
-        assertThat(db.alarms().forTask(id).single().reference).isEqualTo(AlarmReference.START)
-
-        writer.delete(ProviderTable.PROPERTIES, "${Properties.MIMETYPE} = ?", arrayOf(Alarm.MIMETYPE))
-        assertThat(db.alarms().forTask(id)).isEmpty()
-    }
-
-    @Test
-    fun tagsCanBeAddedRenamedAndRemoved() {
-        val id = insert(Tasks.TITLE to "t")
-
-        val propertyId = writer.insert(
-            ProviderTable.PROPERTIES,
-            mapOf(Properties.TASK_ID to id, Properties.MIMETYPE to Category.MIMETYPE, Category.NAME to " errand "),
-        )
-        assertThat(task(id)!!.categories).containsExactly("errand")
-
-        writer.update(ProviderTable.PROPERTIES, mapOf(Category.NAME to "shopping"), byId(ProviderTable.PROPERTIES, propertyId), null)
-        assertThat(task(id)!!.categories).containsExactly("shopping")
-
-        writer.insert(ProviderTable.PROPERTIES, mapOf(Properties.TASK_ID to id, Properties.MIMETYPE to Category.MIMETYPE, Category.NAME to "shopping"))
-        assertThat(task(id)!!.categories).containsExactly("shopping")
-
-        writer.delete(ProviderTable.PROPERTIES, "${Category.NAME} = ?", arrayOf("shopping"))
-        assertThat(task(id)!!.categories).isEmpty()
-    }
-
-    @Test
-    fun aPropertyCannotChangeItsKindOrTask() {
-        val id = insert(Tasks.TITLE to "t")
-        val other = insert(Tasks.TITLE to "o")
-        db.alarms().insert(TaskAlarmEntity(taskId = id, minutesBefore = 5))
-        val propertyId = source.rows(ProviderTable.PROPERTIES, listOf(Properties.PROPERTY_ID), null, null).single().single() as Long
-
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.update(ProviderTable.PROPERTIES, mapOf(Properties.MIMETYPE to Category.MIMETYPE), byId(ProviderTable.PROPERTIES, propertyId), null)
-        }
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.update(ProviderTable.PROPERTIES, mapOf(Properties.TASK_ID to other), byId(ProviderTable.PROPERTIES, propertyId), null)
-        }
-    }
-
-    @Test
-    fun onlyAlarmsAndTagsCanBeWritten() {
-        val id = insert(Tasks.TITLE to "t")
-
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.insert(ProviderTable.PROPERTIES, mapOf(Properties.TASK_ID to id, Properties.MIMETYPE to "vnd.android.cursor.item/comment"))
-        }
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.insert(ProviderTable.PROPERTIES, mapOf(Properties.TASK_ID to id, Properties.MIMETYPE to Alarm.MIMETYPE))
-        }
-    }
-
-    // --- batches ----------------------------------------------------------------
-
-    @Test
-    fun aBatchIsAllOrNothing() {
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.batch {
-                insert(Tasks.TITLE to "first")
-                insert(Tasks.TITLE to "second")
-                insert(Tasks.LIST_ID to 999L)
-            }
-        }
-
-        assertThat(db.tasks().live()).isEmpty()
-        assertThat(source.rows(ProviderTable.TASKS, listOf(Tasks.ID), null, null)).isEmpty()
-    }
-
-    @Test
-    fun aBatchSeesItsOwnWritesAndReArmsRemindersOnce() {
-        writer.batch {
-            insert(Tasks.TITLE to "first")
-            writer.update(ProviderTable.TASKS, mapOf(Tasks.STATUS to 2), "${Tasks.TITLE} = ?", arrayOf("first"))
-        }
-
-        assertThat(db.tasks().live().single().status).isEqualTo(TaskStatus.COMPLETED)
-        assertThat(afterWrites).isEqualTo(1)
-    }
-
-    // --- review regressions -----------------------------------------------------
-
-    @Test
-    fun aBatchDeletingTwoPropertiesDeletesThoseTwo() {
-        val a = insert(Tasks.TITLE to "a")
-        val b = insert(Tasks.TITLE to "b")
-        listOf(5, 10).forEach { db.alarms().insert(TaskAlarmEntity(taskId = a, minutesBefore = it)) }
-        db.alarms().insert(TaskAlarmEntity(taskId = b, minutesBefore = 15))
-        val ids = source.rows(ProviderTable.PROPERTIES, listOf(Properties.PROPERTY_ID), "${Properties.TASK_ID} = $a", null)
-            .map { it.single() as Long }
-
-        writer.batch { ids.forEach { writer.delete(ProviderTable.PROPERTIES, byId(ProviderTable.PROPERTIES, it), null) } }
-
-        assertThat(db.alarms().forTask(a)).isEmpty()
-        assertThat(db.alarms().forTask(b).map { it.minutesBefore }).containsExactly(15)
-    }
-
-    @Test
-    fun aBatchDeletingTwoOccurrencesDeletesThoseTwo() {
-        dailySeries()
-        val first = instanceId(today)
-        val second = instanceId(today + 1.days)
-
-        writer.batch {
-            writer.delete(ProviderTable.INSTANCES, byId(ProviderTable.INSTANCES, first), null)
-            writer.delete(ProviderTable.INSTANCES, byId(ProviderTable.INSTANCES, second), null)
-        }
-
-        assertThat(instances().map { it.first }).containsExactly(
-            (today - 1.days).toEpochMilliseconds(),
-            (today + 2.days).toEpochMilliseconds(),
-            (today + 3.days).toEpochMilliseconds(),
-        )
-    }
-
-    @Test
-    fun anInstanceIdOutlivesAnotherOccurrencesDeletion() {
-        dailySeries()
-        val later = instanceId(today + 2.days)
-
-        writer.delete(ProviderTable.INSTANCES, byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        assertThat(instanceId(today + 2.days)).isEqualTo(later)
-        assertThat(writer.update(ProviderTable.INSTANCES, mapOf(Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, later), null))
-            .isEqualTo(1)
-        assertThat(instances().single { it.third == TasksContract.STATUS_COMPLETED }.first)
-            .isEqualTo((today + 2.days).toEpochMilliseconds())
-    }
-
-    @Test
-    fun aRecurringSubtaskOutsideTheWindowGoesWithItsParent() {
-        val parent = insert(Tasks.TITLE to "parent")
-        val longAgo = today - 1000.days
-        val subtask = db.tasks().insert(
-            TaskEntity(listId = home, uid = "old", title = "old", dtstart = longAgo, rrule = "FREQ=DAILY;COUNT=2",
-                timezone = "UTC", parentId = parent),
-        )
-
-        writer.delete(ProviderTable.TASKS, byId(ProviderTable.TASKS, parent), null)
-
-        assertThat(task(subtask)).isNull()
-    }
-
-    @Test
-    fun anOverriddenRecurringSubtaskGoesWholeWithItsParent() {
-        val parent = insert(Tasks.TITLE to "parent")
-        val subtask = dailySeries("sub")
-        db.tasks().update(task(subtask)!!.copy(parentId = parent))
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        writer.delete(ProviderTable.TASKS, byId(ProviderTable.TASKS, parent), null)
-
-        assertThat(task(subtask)).isNull()
-        assertThat(db.tasks().live()).isEmpty()
-    }
-
-    @Test
-    fun aModifiedOccurrenceCanBeWrittenBackAsRead() {
-        val series = dailySeries()
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-        val override = db.tasks().overrides(series).single().id
-        val row = readRow(ProviderTable.TASKS, override)
-
-        writer.update(ProviderTable.TASKS, row + (Tasks.TITLE to "Renamed"), byId(ProviderTable.TASKS, override), null)
-
-        assertThat(task(override)!!.title).isEqualTo("Renamed")
-    }
-
-    @Test
-    fun anInstanceCanBeWrittenBackAsReadToCompleteIt() {
-        val series = dailySeries()
-        val instance = instanceId(today)
-        val row = readRow(ProviderTable.INSTANCES, instance)
-
-        writer.update(ProviderTable.INSTANCES, row + (Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instance), null)
-
-        assertThat(db.tasks().overrides(series).single().status).isEqualTo(TaskStatus.COMPLETED)
-        assertThat(task(series)!!.dtstart).isEqualTo(today - 1.days)
-    }
-
-    @Test
-    fun movingASubtreeMovesItsSubtasks() {
-        val work = synced()
-        val parent = insert(Tasks.TITLE to "parent")
-        val child = insert(Tasks.TITLE to "child", Tasks.PARENT_ID to parent)
-        val grandchild = insert(Tasks.TITLE to "grandchild", Tasks.PARENT_ID to child)
-
-        writer.update(ProviderTable.TASKS, mapOf(Tasks.LIST_ID to work), byId(ProviderTable.TASKS, parent), null)
-
-        assertThat(listOf(parent, child, grandchild).map { task(it)!!.listId }).containsExactly(work, work, work)
-        assertThat(task(child)!!.parentId).isEqualTo(parent)
-        assertThat(task(grandchild)!!.parentId).isEqualTo(child)
-    }
-
-    @Test
-    fun aMoveOntoATakenUidIsRejected() {
-        val work = synced()
-        insert(Tasks.LIST_ID to work, Tasks.UID to "same")
-        val id = insert(Tasks.UID to "same")
-
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.update(ProviderTable.TASKS, mapOf(Tasks.LIST_ID to work), byId(ProviderTable.TASKS, id), null)
-        }
-        assertThat(task(id)!!.listId).isEqualTo(home)
-    }
-
-    @Test
-    fun contentOnAModifiedOccurrenceStillEditsTheSeries() {
-        val series = dailySeries()
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-        val override = db.tasks().overrides(series).single().id
-
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.TITLE to "Renamed"), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        assertThat(task(series)!!.title).isEqualTo("Renamed")
-        assertThat(task(override)!!.title).isEqualTo("Renamed")
-        assertThat(task(override)!!.status).isEqualTo(TaskStatus.COMPLETED)
-    }
-
-    @Test
-    fun aWriteThatChangesNothingOwesNoSync() {
-        val id = insert(Tasks.TITLE to "t")
-        db.tasks().update(task(id)!!.copy(isDirty = false))
-        val modified = task(id)!!.lastModified
-
-        writer.update(ProviderTable.TASKS, readRow(ProviderTable.TASKS, id), byId(ProviderTable.TASKS, id), null)
-        writer.update(ProviderTable.TASKS, emptyMap(), byId(ProviderTable.TASKS, id), null)
-
-        assertThat(task(id)!!.isDirty).isFalse()
-        assertThat(task(id)!!.lastModified).isEqualTo(modified)
-    }
-
-    @Test
-    fun reopeningAnOpenOccurrenceForksNothing() {
-        val series = dailySeries()
-
-        writer.update(ProviderTable.INSTANCES, mapOf(Tasks.STATUS to 0), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        assertThat(db.tasks().overrides(series)).isEmpty()
-    }
-
-    @Test
-    fun aWriteBeforeStartupSettlesIsRefused() {
-        val stuck = ProviderSnapshotSource(context, db, resolver, awaitStartup = { awaitCancellation() }, startupWait = 50.milliseconds)
-        val early = ProviderWriter(db, RoomTasksDataSource(db), stuck, resolver, afterWrite = {})
-
-        assertThrows(IllegalStateException::class.java) { early.insert(ProviderTable.TASKS, mapOf(Tasks.LIST_ID to home)) }
-        assertThat(db.tasks().live()).isEmpty()
-    }
-
-    @Test
-    fun aSingleRowWriteNeedsNoSnapshot() {
-        val id = insert(Tasks.TITLE to "t")
-        val unknown = 987_654L
-
-        assertThat(writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "x"), byId(ProviderTable.TASKS, unknown), null)).isEqualTo(0)
-        assertThat(writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "x"), byId(ProviderTable.TASKS, id), null)).isEqualTo(1)
-        assertThat(writer.update(ProviderTable.INSTANCES, mapOf(Tasks.TITLE to "x"), byId(ProviderTable.INSTANCES, unknown), null)).isEqualTo(0)
-        assertThat(writer.delete(ProviderTable.PROPERTIES, byId(ProviderTable.PROPERTIES, unknown), null)).isEqualTo(0)
-    }
-
-    // --- second review regressions -----------------------------------------------
-
-    @Test
-    fun tickingOffAModifiedOccurrenceAsReadLeavesTheSeriesAlone() {
-        val series = dailySeries("Standup")
-        // Reopening forks an override, which then gets its own title as the app's "this occurrence" edit would.
-        store().setCompletedInstance(series, today, false)
-        val override = db.tasks().overrides(series).single()
-        db.tasks().update(override.copy(title = "Standup (moved room)"))
-        val row = readRow(ProviderTable.INSTANCES, instanceId(today))
-
-        writer.update(ProviderTable.INSTANCES, row + (Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        assertThat(task(series)!!.title).isEqualTo("Standup")
-        assertThat(task(override.id)!!.title).isEqualTo("Standup (moved room)")
-        assertThat(task(override.id)!!.status).isEqualTo(TaskStatus.COMPLETED)
-    }
-
-    @Test
-    fun anInstanceWrittenBackWithOnlyProgressChangedIsCompleted() {
-        val series = dailySeries()
-        val row = readRow(ProviderTable.INSTANCES, instanceId(today))
-
-        writer.update(ProviderTable.INSTANCES, row + (Tasks.PERCENT_COMPLETE to 100), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        assertThat(db.tasks().overrides(series).single().status).isEqualTo(TaskStatus.COMPLETED)
-    }
-
-    @Test
-    fun aBadZoneOnAnInstanceReportsTheZone() {
-        dailySeries()
-        val instance = instanceId(today)
-
-        val error = assertThrows(IllegalArgumentException::class.java) {
-            writer.update(ProviderTable.INSTANCES, mapOf(Tasks.TZ to "Europe/Berln"), byId(ProviderTable.INSTANCES, instance), null)
-        }
-
-        assertThat(error).hasMessageThat().contains("Unknown time zone")
-    }
-
-    @Test
-    fun anInProcessSeriesCanBeWrittenBackAsRead() {
-        val series = dailySeries()
-        db.tasks().update(task(series)!!.copy(status = TaskStatus.IN_PROCESS, percentComplete = 50))
-        val row = readRow(ProviderTable.INSTANCES, instanceId(today))
-
-        writer.update(ProviderTable.INSTANCES, row + (Tasks.TITLE to "Renamed"), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-
-        assertThat(task(series)!!.title).isEqualTo("Renamed")
-        assertThat(task(series)!!.status).isEqualTo(TaskStatus.IN_PROCESS)
-        assertThat(db.tasks().overrides(series)).isEmpty()
-    }
-
-    @Test
-    fun aFloatingSeriesCanBeWrittenBackAsRead() {
-        val series = db.tasks().insert(
-            TaskEntity(listId = home, uid = "f", title = "Floating", due = today, rrule = "FREQ=DAILY;COUNT=3", timezone = null),
-        )
-        val row = readRow(ProviderTable.INSTANCES, instanceId(today))
-
-        writer.update(ProviderTable.INSTANCES, row + (Tasks.STATUS to 2), byId(ProviderTable.INSTANCES, instanceId(today)), null)
-        writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "Still floating"), byId(ProviderTable.TASKS, series), null)
-
-        assertThat(db.tasks().overrides(series).single().status).isEqualTo(TaskStatus.COMPLETED)
-        assertThat(task(series)!!.timezone).isNull()
-    }
-
-    @Test
-    fun aParentLoopDeletesInsteadOfRecursingForever() {
-        val a = insert(Tasks.TITLE to "a")
-        val b = insert(Tasks.TITLE to "b", Tasks.PARENT_ID to a)
-        db.tasks().update(task(a)!!.copy(parentId = b))
-
-        writer.delete(ProviderTable.TASKS, byId(ProviderTable.TASKS, a), null)
-
-        assertThat(task(a)).isNull()
-        assertThat(task(b)).isNull()
-    }
-
-    @Test
-    fun aBulkMoveWorksWhicheverOrderTheRowsComeIn() {
-        val work = synced()
-        // The subtask gets the lower id, so it comes first unless the writer reorders.
-        val child = insert(Tasks.TITLE to "child")
-        val parent = insert(Tasks.TITLE to "parent")
-        db.tasks().update(task(child)!!.copy(parentId = parent))
-
-        val count = writer.update(ProviderTable.TASKS, mapOf(Tasks.LIST_ID to work), "${Tasks.LIST_ID} = ?", arrayOf(home.toString()))
-
-        assertThat(count).isEqualTo(2)
-        assertThat(task(child)!!.listId).isEqualTo(work)
-        assertThat(task(parent)!!.listId).isEqualTo(work)
-        assertThat(task(child)!!.parentId).isEqualTo(parent)
-    }
-
-    @Test
-    fun aRowSelectedWithAnArgumentIsWritten() {
-        val a = insert(Tasks.TITLE to "a")
-        val b = insert(Tasks.TITLE to "b")
-
-        assertThat(writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "x"), "${Tasks.ID}=?", arrayOf(b.toString()))).isEqualTo(1)
-        assertThat(writer.update(ProviderTable.TASKS, mapOf(Tasks.TITLE to "x"), "${Tasks.ID} = ?", arrayOf("987654"))).isEqualTo(0)
-
-        assertThat(task(a)!!.title).isEqualTo("a")
-        assertThat(task(b)!!.title).isEqualTo("x")
-    }
-
-    @Test
-    fun garbageExceptionDatesAreRejected() {
-        val series = dailySeries()
-
-        assertThrows(IllegalArgumentException::class.java) {
-            writer.update(ProviderTable.TASKS, mapOf(Tasks.EXDATE to "tomorrow"), byId(ProviderTable.TASKS, series), null)
-        }
-        assertThat(task(series)!!.exdate).isNull()
-    }
-
-    private fun store() = RoomTasksDataSource(db)
-
-    /** Every column of one published row, as a client that read it would write it back. */
-    private fun readRow(table: ProviderTable, id: Long): Map<String, Any?> {
-        val columns = table.columns.map { it.first }
-        val row = source.rows(table, columns, byId(table, id), null).single()
-        return columns.zip(row).toMap() - table.idColumn
-    }
-
-}
-
-private object NoProvider : ProviderEnvironment {
-    override fun packageDeclaring(authority: String): String? = null
-    override fun isGranted(permission: String): Boolean = false
-    override fun appLabel(packageName: String): String? = null
-}

app/src/androidTest/java/de/jeanlucmakiola/agendula/data/tasks/provider/SnapshotDatabaseTest.kt

@@ -1,141 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import android.database.Cursor
-import android.os.Build
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Lists
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Tasks
-import org.junit.Assert.assertThrows
-import org.junit.Assume.assumeTrue
-import org.junit.Test
-import org.junit.runner.RunWith
-
-/** The SQL a client sends runs against the snapshot as it would against OpenTasks. */
-@RunWith(AndroidJUnit4::class)
-class SnapshotDatabaseTest {
-
-    private val db = SnapshotDatabase()
-
-    private fun task(id: Long, title: String?, due: Long? = null): ProviderRow =
-        mapOf(Tasks.ID to id, Tasks.LIST_ID to 1L, Tasks.TITLE to title, Tasks.DUE to due, Tasks.PRIORITY to 0)
-
-    private fun load(vararg tasks: ProviderRow, lists: List<ProviderRow> = emptyList()) = db.load(
-        ProviderSnapshot(
-            ProviderTable.entries.associateWith {
-                when (it) {
-                    ProviderTable.TASKS -> tasks.toList()
-                    ProviderTable.LISTS -> lists
-                    else -> emptyList()
-                }
-            },
-        ),
-    )
-
-    private fun Cursor.strings(column: String): List<String?> = use {
-        val index = getColumnIndexOrThrow(column)
-        buildList { while (moveToNext()) add(if (isNull(index)) null else getString(index)) }
-    }
-
-    @Test
-    fun aNullProjectionReturnsEveryColumnInTableOrder() {
-        load(task(1, "a"))
-
-        db.query(ProviderTable.TASKS, null, null, null, null).use {
-            assertThat(it.columnNames.toList()).containsExactlyElementsIn(ProviderTable.TASKS.columns.map { c -> c.first })
-                .inOrder()
-            assertThat(it.count).isEqualTo(1)
-        }
-    }
-
-    @Test
-    fun selectionArgumentsAndSortOrderApply() {
-        load(task(1, "b", due = 30), task(2, "a", due = 10), task(3, "c", due = 20), task(4, "skip", due = 5))
-
-        val titles = db.query(ProviderTable.TASKS, arrayOf(Tasks.TITLE), "${Tasks.TITLE} != ?", arrayOf("skip"), "${Tasks.DUE} ASC")
-            .strings(Tasks.TITLE)
-
-        assertThat(titles).containsExactly("a", "c", "b").inOrder()
-    }
-
-    @Test
-    fun typesSurviveTheCopy() {
-        load(task(1, null, due = 1_700_000_000_000))
-
-        db.query(ProviderTable.TASKS, arrayOf(Tasks.TITLE, Tasks.DUE, Tasks.PRIORITY), null, null, null).use {
-            it.moveToFirst()
-            assertThat(it.isNull(0)).isTrue()
-            assertThat(it.getType(1)).isEqualTo(Cursor.FIELD_TYPE_INTEGER)
-            assertThat(it.getLong(1)).isEqualTo(1_700_000_000_000)
-            assertThat(it.getInt(2)).isEqualTo(0)
-        }
-    }
-
-    @Test
-    fun anUnsupportedColumnReadsAsNull() {
-        load(task(1, "a"))
-
-        assertThat(db.query(ProviderTable.TASKS, arrayOf("_sync_id"), null, null, null).strings("_sync_id"))
-            .containsExactly(null)
-    }
-
-    @Test
-    fun anUnknownProjectionColumnIsRejected() {
-        load(task(1, "a"))
-
-        assertThrows(IllegalArgumentException::class.java) {
-            db.query(ProviderTable.TASKS, arrayOf("no_such_column"), null, null, null)
-        }
-    }
-
-    @Test
-    fun anUnknownSelectionColumnIsRejected() {
-        assumeTrue(Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
-        load(task(1, "a"))
-
-        assertThrows(IllegalArgumentException::class.java) {
-            db.query(ProviderTable.TASKS, null, "sqlite_master.name IS NOT NULL", null, null)
-        }
-    }
-
-    @Test
-    fun aSelectionCannotBreakOutOfItsWhereClause() {
-        load(task(1, "a"))
-
-        assertThrows(IllegalArgumentException::class.java) {
-            db.query(ProviderTable.TASKS, null, "1) UNION SELECT name FROM sqlite_master --", null, null)
-        }
-    }
-
-    @Test
-    fun eachTableAnswersOnlyForItsOwnRows() {
-        load(task(1, "a"), lists = listOf(mapOf(Lists.ID to 7L, Lists.NAME to "Home")))
-
-        assertThat(db.query(ProviderTable.LISTS, arrayOf(Lists.NAME), null, null, null).strings(Lists.NAME))
-            .containsExactly("Home")
-        db.query(ProviderTable.INSTANCES, null, null, null, null).use { assertThat(it.count).isEqualTo(0) }
-    }
-
-    @Test
-    fun aReloadReplacesTheRowsButNotAnOpenCursor() {
-        load(task(1, "old"))
-        val before = db.query(ProviderTable.TASKS, arrayOf(Tasks.TITLE), null, null, null)
-
-        load(task(2, "new"))
-
-        assertThat(before.strings(Tasks.TITLE)).containsExactly("old")
-        assertThat(db.query(ProviderTable.TASKS, arrayOf(Tasks.TITLE), null, null, null).strings(Tasks.TITLE))
-            .containsExactly("new")
-    }
-
-    @Test
-    fun anEmptySnapshotEmptiesEveryTable() {
-        load(task(1, "a"))
-
-        db.load(ProviderSnapshot.EMPTY)
-
-        ProviderTable.entries.forEach { table ->
-            db.query(table, null, null, null, null).use { assertThat(it.count).isEqualTo(0) }
-        }
-    }
-}

app/src/androidTest/java/de/jeanlucmakiola/agendula/data/tasks/room/RoomTasksDataSourceTest.kt

@@ -5,7 +5,7 @@ import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.agendula.data.tasks.TaskQuery
-import de.jeanlucmakiola.agendula.domain.TaskReminder
+import de.jeanlucmakiola.agendula.data.tasks.TaskReminder
 import de.jeanlucmakiola.agendula.domain.TaskForm
 import de.jeanlucmakiola.agendula.domain.TaskStatus
 import org.junit.After
@@ -366,23 +366,41 @@ class RoomTasksDataSourceTest {
     @Test
     fun alarmsRoundTripAndReplaceRatherThanAccumulate() {
         val id = source.insertTask(form(due = now + 1.days))
-        val start = TaskReminder(minutesBefore = 10, fromStart = true)
 
         // The whole reminder, not just the minute count: collapsing it to a bare
-        // Int is what fired an imported START-referenced alarm off DUE.
+        // Int is what fired an imported START-referenced alarm off DUE, and an
-        source.setReminders(id, listOf(start, TaskReminder(30)))
+        // alarm this seam sets from the UI is always due-referenced.
-        assertThat(source.reminders()[id]).containsExactly(start, TaskReminder(30)).inOrder()
+        source.setAlarm(id, 30)
+        assertThat(source.alarms()[id]).isEqualTo(TaskReminder(minutesBefore = 30))
 
-        source.setReminders(id, listOf(TaskReminder(60)))
+        source.setAlarm(id, 60)
         assertThat(db.alarms().forTask(id)).hasSize(1)
-        assertThat(source.reminders()[id]).containsExactly(TaskReminder(60))
+        assertThat(source.alarms()[id]).isEqualTo(TaskReminder(minutesBefore = 60))
+
+        source.setAlarm(id, null)
+        assertThat(source.alarms()).doesNotContainKey(id)
+    }
+
+    @Test
+    fun settingTheEditableReminderLeavesTheOthersAlone() {
+        val id = source.insertTask(form(due = now + 1.days))
+        val start = TaskReminder(minutesBefore = 10, fromStart = true)
+        source.setReminders(id, listOf(start, TaskReminder(30), TaskReminder(120)))
+
+        source.setAlarm(id, 45)
+        assertThat(source.reminders()[id]).containsExactly(start, TaskReminder(30), TaskReminder(45)).inOrder()
+        assertThat(source.alarms()[id]).isEqualTo(TaskReminder(45))
+
+        source.setAlarm(id, null)
+        assertThat(source.reminders()[id]).containsExactly(start, TaskReminder(30)).inOrder()
+        assertThat(source.alarms()[id]).isEqualTo(TaskReminder(30))
     }
 
     @Test
     fun forkingAnOccurrenceCarriesTheReminderOntoIt() {
         val id = source.insertTask(form(due = now + 1.days))
         makeRecurring(id, now)
-        source.setReminders(id, listOf(TaskReminder(30)))
+        source.setAlarm(id, 30)
         val target = source.tasks(TaskQuery(listId = listId))
             .filter { it.taskId == id }
             .first { it.distanceFromCurrent == 1 }
@@ -393,134 +411,6 @@ class RoomTasksDataSourceTest {
         assertThat(db.alarms().forTask(override.id).single().minutesBefore).isEqualTo(30)
     }
 
-    @Test
-    fun aSaveKeepsTheIdentityOfAReminderItDidNotChange() {
-        val id = source.insertTask(form(due = now + 1.days), listOf(TaskReminder(15)))
-        val original = db.alarms().forTask(id).single()
-        db.alarms().update(original.copy(raw = "BEGIN:VALARM\r\nX-VENDOR:keep\r\nEND:VALARM\r\n"))
-
-        source.updateTask(id, form(title = "renamed", due = now + 2.days), reminders = listOf(TaskReminder(15), TaskReminder(60)))
-
-        val rows = db.alarms().forTask(id)
-        val kept = rows.single { it.minutesBefore == 15 }
-        // Same row, same identity on the server, same original text.
-        assertThat(kept.id).isEqualTo(original.id)
-        assertThat(kept.uid).isEqualTo(original.uid)
-        assertThat(kept.raw).contains("X-VENDOR:keep")
-        assertThat(rows.single { it.minutesBefore == 60 }.uid).isNotEqualTo(original.uid)
-    }
-
-    @Test
-    fun aSaveWritesBeforeStartAndBeforeDueRemindersAlike() {
-        val id = source.insertTask(form(due = now + 1.days))
-        source.setReminders(id, listOf(TaskReminder(10, fromStart = true), TaskReminder(30)))
-
-        source.updateTask(id, form(due = now + 1.days), reminders = listOf(TaskReminder(5, fromStart = true), TaskReminder(45)))
-
-        assertThat(source.reminders()[id]).containsExactly(TaskReminder(5, fromStart = true), TaskReminder(45))
-    }
-
-    @Test
-    fun aReminderForOneOccurrenceLeavesTheSeriesUntouched() {
-        val work = syncedList()
-        val id = source.insertTask(form(due = now + 1.days).copy(listId = work), listOf(TaskReminder(30)))
-        makeRecurring(id, now)
-        db.tasks().update(db.tasks().entity(id)!!.copy(isDirty = false))
-        val target = source.tasks(TaskQuery(listId = work))
-            .filter { it.taskId == id }
-            .first { it.distanceFromCurrent == 1 }
-
-        source.updateInstance(id, target.occurrenceStart!!, form(title = "moved").copy(listId = work), listOf(TaskReminder(60)))
-
-        // ⚠️ The master is never written, not even briefly: a sync landing in
-        // between would upload the occurrence's reminder for the whole series.
-        assertThat(db.alarms().forTask(id).map { it.minutesBefore }).containsExactly(30)
-        assertThat(db.tasks().entity(id)!!.isDirty).isFalse()
-        val override = db.tasks().override(id, target.occurrenceStart)!!
-        assertThat(db.alarms().forTask(override.id).map { it.minutesBefore }).containsExactly(60)
-    }
-
-    @Test
-    fun splittingASeriesGivesTheNewSeriesItsOwnReminderIdentities() {
-        val id = source.insertTask(form(due = now + 1.days), listOf(TaskReminder(30)))
-        makeRecurring(id, now - 14.days)
-        val master = db.alarms().forTask(id).single()
-        val target = source.tasks(TaskQuery(listId = listId))
-            .filter { it.taskId == id }
-            .first { it.distanceFromCurrent == 1 }
-
-        val created = source.splitSeries(id, target.occurrenceStart!!, form(title = "later"), listOf(TaskReminder(30)))
-
-        assertThat(created).isNotEqualTo(id)
-        val copy = db.alarms().forTask(created).single()
-        assertThat(copy.minutesBefore).isEqualTo(30)
-        // A different UID on the server, so the alarm must not share one either.
-        assertThat(copy.uid).isNotEqualTo(master.uid)
-        assertThat(db.alarms().forTask(id).single().uid).isEqualTo(master.uid)
-    }
-
-    @Test
-    fun changingOnlyTheRemindersOwesTheServerAPut() {
-        val work = syncedList()
-        val id = source.insertTask(form(due = now + 1.days).copy(listId = work))
-        db.tasks().update(db.tasks().entity(id)!!.copy(isDirty = false))
-
-        source.setReminders(id, listOf(TaskReminder(15)))
-        assertThat(db.tasks().entity(id)!!.isDirty).isTrue()
-
-        db.tasks().update(db.tasks().entity(id)!!.copy(isDirty = false))
-        source.setReminders(id, listOf(TaskReminder(15)))
-        // Nothing changed, so nothing is owed.
-        assertThat(db.tasks().entity(id)!!.isDirty).isFalse()
-    }
-
-    @Test
-    fun aSeriesReminderEditReachesTheOccurrencesThatStillHadTheOldOne() {
-        val id = source.insertTask(form(due = now + 1.days), listOf(TaskReminder(15)))
-        makeRecurring(id, now)
-        val occurrences = source.tasks(TaskQuery(listId = listId)).filter { it.taskId == id }
-        val completed = occurrences.first { it.distanceFromCurrent == 1 }.occurrenceStart!!
-        val own = occurrences.first { it.distanceFromCurrent == 2 }.occurrenceStart!!
-        source.setCompletedInstance(id, completed, true)
-        source.updateInstance(id, own, form(title = "own"), listOf(TaskReminder(5)))
-
-        // Same times and rule, so the series is not reshaped — that drops its overrides.
-        val first = occurrences.first()
-        val unchanged = form().copy(start = first.start, due = first.due, rrule = "FREQ=WEEKLY")
-        source.updateSeries(id, first.occurrenceStart!!, unchanged, listOf(TaskReminder(60)))
-
-        fun leads(anchor: Instant) = db.alarms().forTask(db.tasks().override(id, anchor)!!.id).map { it.minutesBefore }
-        assertThat(db.alarms().forTask(id).map { it.minutesBefore }).containsExactly(60)
-        // A snapshot of the series' reminder follows it…
-        assertThat(leads(completed)).containsExactly(60)
-        // …one set for that occurrence alone does not.
-        assertThat(leads(own)).containsExactly(5)
-    }
-
-    @Test
-    fun aTaskWhoseAlarmsWereTurnedOffElsewhereReportsNone() {
-        val id = source.insertTask(form(due = now + 1.days))
-        db.alarms().setRemindersOff(id, true)
-
-        assertThat(source.reminders()[id]).isEmpty()
-        assertThat(source.reminders()).containsKey(id)
-
-        // A reminder of its own again: the flag goes.
-        source.setReminders(id, listOf(TaskReminder(15)))
-        assertThat(db.tasks().entity(id)!!.remindersOff).isFalse()
-    }
-
-    @Test
-    fun settingRemindersOwesTheServerAPut() {
-        val work = syncedList()
-        val id = source.insertTask(form(due = now + 1.days).copy(listId = work))
-        db.tasks().update(db.tasks().entity(id)!!.copy(isDirty = false))
-
-        source.setReminders(id, listOf(TaskReminder(30)))
-
-        assertThat(db.tasks().entity(id)!!.isDirty).isTrue()
-    }
-
     @Test
     fun deletingATaskInALocalListRemovesItOutright() {
         val id = source.insertTask(form())
@@ -549,7 +439,7 @@ class RoomTasksDataSourceTest {
     fun aForkedOccurrenceCarriesTheSeriesReminder() {
         val id = source.insertTask(form())
         makeRecurring(id, now)
-        source.setReminders(id, listOf(TaskReminder(30)))
+        source.setAlarm(id, minutesBeforeDue = 30)
         val target = source.tasks(TaskQuery(listId = listId))
             .filter { it.taskId == id }
             .first { it.distanceFromCurrent == 1 }
@@ -557,7 +447,7 @@ class RoomTasksDataSourceTest {
         source.updateInstance(id, target.occurrenceStart!!, form(title = "moved"))
 
         // The fork copies the master's properties, which is what carries the
-        // reminder across.
+        // reminder across — the repository is what puts the series' own back.
         val override = db.tasks().override(id, target.occurrenceStart)!!
         assertThat(db.alarms().forTask(override.id).single().minutesBefore).isEqualTo(30)
     }
@@ -649,47 +539,4 @@ class RoomTasksDataSourceTest {
 
         assertThat(thrown).isNotNull()
     }
-
-    @Test
-    fun subtaskIdsNameRowsNotOccurrences() {
-        val parent = source.insertTask(form("parent"))
-        val longAgo = now - 1000.days
-        val outOfWindow = db.tasks().insert(
-            TaskEntity(listId = listId, uid = "old", title = "old", dtstart = longAgo, rrule = "FREQ=DAILY;COUNT=2", parentId = parent),
-        )
-        val series = db.tasks().insert(
-            TaskEntity(listId = listId, uid = "s", title = "s", dtstart = now, rrule = "FREQ=DAILY;COUNT=3", parentId = parent),
-        )
-        source.setCompletedInstance(series, now, true)
-        val plain = source.insertTask(form("plain").copy(parentId = parent))
-
-        assertThat(source.subtaskIds(parent)).containsExactly(outOfWindow, series, plain)
-    }
-
-    @Test
-    fun deletingASubtreeEndsOnAParentLoop() {
-        val a = source.insertTask(form("a"))
-        val b = source.insertTask(form("b").copy(parentId = a))
-        val c = source.insertTask(form("c").copy(parentId = b))
-        db.tasks().update(db.tasks().entity(a)!!.copy(parentId = c))
-
-        source.deleteWithSubtasks(a)
-
-        assertThat(listOf(a, b, c).mapNotNull { db.tasks().entity(it) }).isEmpty()
-    }
-
-    @Test
-    fun deletingFollowingFromTheFirstOccurrenceTakesTheWholeSubtree() {
-        val start = now
-        val series = db.tasks().insert(
-            TaskEntity(listId = listId, uid = "s", title = "s", dtstart = start, rrule = "FREQ=DAILY;COUNT=3"),
-        )
-        val child = source.insertTask(form("child").copy(parentId = series))
-        val grandchild = source.insertTask(form("grandchild").copy(parentId = child))
-
-        source.deleteFollowing(series, start)
-
-        assertThat(listOf(series, child, grandchild).mapNotNull { db.tasks().entity(it) }).isEmpty()
-    }
 }
-

app/src/androidTest/java/de/jeanlucmakiola/agendula/data/tasks/room/TasksDatabaseMigrationTest.kt

@@ -8,7 +8,27 @@ import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 
-/** Migrations, proven against the committed schemas in `app/schemas/`. */
+/**
+ * The migration harness, proven against the committed schema in `app/schemas/`.
+ *
+ * There is one schema version today, so all there is to assert is that the helper
+ * can build v1 from the exported JSON, seed it, and validate it back — i.e. the
+ * export, the assets wiring and the identity hash all line up. That is the point:
+ * the first real migration only has to add its own case.
+ *
+ * **Adding a v1 → v2 case.** When sync adds columns, bump [TasksDatabase]'s
+ * `version`, let KSP export `2.json`, declare the `Migration(1, 2)` next to the
+ * database, and add a test here shaped like this:
+ *
+ * ```
+ * helper.createDatabase(TEST_DB, 1).use { db ->
+ *     db.execSQL("INSERT INTO task_lists (name, color) VALUES ('Groceries', 0)")
+ * }
+ * helper.runMigrationsAndValidate(TEST_DB, 2, true, MIGRATION_1_2).use { db ->
+ *     // read the seeded rows back — validation proves the shape, not the data
+ * }
+ * ```
+ */
 @RunWith(AndroidJUnit4::class)
 class TasksDatabaseMigrationTest {
 
@@ -42,111 +62,6 @@ class TasksDatabaseMigrationTest {
         }
     }
 
-    @Test
-    fun liftsCategoriesOutOfTheResidueWithoutDirtyingTheTask() {
-        helper.createDatabase(TEST_DB, 1).use { db ->
-            db.execSQL("INSERT INTO task_lists (id, name, color) VALUES (1, 'Work', 0)")
-            db.execSQL(
-                "INSERT INTO tasks (id, list_id, uid, title, unknown_properties) VALUES (?, 1, ?, ?, ?)",
-                arrayOf<Any?>(1, "uid-1", "Claimed", "X-FOO:bar\r\nCATEGORIES:Work,Home\r\n"),
-            )
-            db.execSQL(
-                "INSERT INTO tasks (id, list_id, uid, title, unknown_properties) VALUES (?, 1, ?, ?, ?)",
-                arrayOf<Any?>(2, "uid-2", "Split", "CATEGORIES:a\r\nCATEGORIES:b\r\n"),
-            )
-            db.execSQL("INSERT INTO tasks (id, list_id, uid, title) VALUES (3, 1, 'uid-3', 'Untagged')")
-        }
-
-        helper.runMigrationsAndValidate(TEST_DB, 2, true, TasksDatabase.MIGRATION_1_2).use { db ->
-            db.query("SELECT categories, unknown_properties, is_dirty FROM tasks ORDER BY id").use { c ->
-                c.moveToNext()
-                assertThat(c.getString(0)).isEqualTo("Work,Home")
-                assertThat(c.getString(1)).doesNotContain("CATEGORIES")
-                assertThat(c.getString(1)).contains("X-FOO:bar")
-                assertThat(c.getInt(2)).isEqualTo(0)
-
-                c.moveToNext()
-                assertThat(c.getString(0)).isEqualTo("a,b")
-                assertThat(c.getString(1)).isEqualTo("CATEGORIES:a\r\nCATEGORIES:b\r\n")
-
-                c.moveToNext()
-                assertThat(c.getString(0)).isEmpty()
-            }
-        }
-    }
-
-    @Test
-    fun liftsClaimableAlarmsAndPushesRemindersThatNeverLeftTheDevice() {
-        val future = System.currentTimeMillis() + 7L * 24 * 60 * 60 * 1000
-        val past = System.currentTimeMillis() - 7L * 24 * 60 * 60 * 1000
-        val claimable = "X-FOO:bar\r\nBEGIN:VALARM\r\nACTION:DISPLAY\r\nX-WR-ALARMUID:srv\r\n" +
-            "TRIGGER;RELATED=END:-PT15M\r\nEND:VALARM\r\n"
-        val appleDefault = "BEGIN:VALARM\r\nACTION:DISPLAY\r\nX-APPLE-DEFAULT-ALARM:TRUE\r\n" +
-            "TRIGGER;RELATED=END:-PT30M\r\nEND:VALARM\r\n"
-        helper.createDatabase(TEST_DB, 2).use { db ->
-            db.execSQL("INSERT INTO accounts (id, display_name) VALUES (1, 'me')")
-            db.execSQL("INSERT INTO task_lists (id, name, color, account_id) VALUES (1, 'Synced', 0, 1)")
-            db.execSQL("INSERT INTO task_lists (id, name, color) VALUES (2, 'Local', 0)")
-            db.execSQL("INSERT INTO task_lists (id, name, color, account_id, is_read_only) VALUES (3, 'Shared', 0, 1, 1)")
-            fun task(id: Int, list: Int, due: Long, residue: String? = null) = db.execSQL(
-                "INSERT INTO tasks (id, list_id, uid, title, due, unknown_properties) VALUES (?, ?, ?, ?, ?, ?)",
-                arrayOf<Any?>(id, list, "uid-$id", "Task $id", due, residue),
-            )
-            fun alarm(task: Int, minutes: Int) =
-                db.execSQL("INSERT INTO task_alarms (task_id, minutes_before) VALUES (?, ?)", arrayOf<Any?>(task, minutes))
-            // A server alarm, and the same lead copied locally by a fork.
-            task(1, 1, future, claimable)
-            alarm(1, 15)
-            // Set in Agendula, never uploaded — still to fire, already past, device-only.
-            task(2, 1, future)
-            alarm(2, 30)
-            task(3, 1, past)
-            alarm(3, 30)
-            task(4, 2, future)
-            alarm(4, 30)
-            // Somebody else's default alarm: not ours to claim.
-            task(5, 1, future, appleDefault)
-            // A read-only share: dirty would freeze it, never sent and never refreshed.
-            task(6, 3, future)
-            alarm(6, 30)
-        }
-
-        helper.runMigrationsAndValidate(TEST_DB, 3, true, TasksDatabase.MIGRATION_2_3).use { db ->
-            db.query("SELECT task_id, minutes_before, uid, raw FROM task_alarms ORDER BY task_id").use { c ->
-                val rows = buildList { while (c.moveToNext()) add(listOf(c.getLong(0), c.getInt(1), c.getString(2), c.getString(3))) }
-                // One for task 1: the lifted copy won and the local duplicate went.
-                assertThat(rows.map { it[0] }).containsExactly(1L, 2L, 3L, 4L, 6L).inOrder()
-                assertThat(rows[0][2]).isEqualTo("srv")
-                assertThat(rows[0][3] as String).contains("TRIGGER;RELATED=END:-PT15M")
-                // Every pre-existing row got an identity of its own, shaped as a UUID.
-                assertThat(rows.drop(1).map { it[2] as String }.toSet()).hasSize(4)
-                rows.drop(1).forEach {
-                    assertThat(it[2] as String).matches("[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}")
-                }
-                assertThat(rows.drop(1).all { (it[2] as String).isNotEmpty() && it[3] == null }).isTrue()
-            }
-            db.query("SELECT id, unknown_properties, is_dirty, last_modified, reminders_off FROM tasks ORDER BY id").use { c ->
-                c.moveToNext()
-                assertThat(c.getString(1)).isEqualTo("X-FOO:bar\r\n")
-                assertThat(c.getInt(2)).isEqualTo(0)
-                assertThat(c.getInt(4)).isEqualTo(0)
-                c.moveToNext()
-                assertThat(c.getInt(2)).isEqualTo(1)
-                // The body changes, so its modification stamp does too.
-                assertThat(c.isNull(3)).isFalse()
-                c.moveToNext()
-                assertThat(c.getInt(2)).isEqualTo(0)
-                c.moveToNext()
-                assertThat(c.getInt(2)).isEqualTo(0)
-                c.moveToNext()
-                assertThat(c.getString(1)).contains("X-APPLE-DEFAULT-ALARM:TRUE")
-                assertThat(c.getInt(2)).isEqualTo(0)
-                c.moveToNext()
-                assertThat(c.getInt(2)).isEqualTo(0)
-            }
-        }
-    }
-
     private companion object {
         const val TEST_DB = "migration-test.db"
     }

app/src/androidTest/java/de/jeanlucmakiola/agendula/data/tasks/transfer/ExternalImportTest.kt

@@ -11,7 +11,7 @@ import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.agendula.data.tasks.ProviderEnvironment
 import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
 import de.jeanlucmakiola.agendula.data.tasks.TaskQuery
-import de.jeanlucmakiola.agendula.domain.TaskReminder
+import de.jeanlucmakiola.agendula.data.tasks.TaskReminder
 import de.jeanlucmakiola.agendula.data.tasks.TasksDataSource
 import de.jeanlucmakiola.agendula.data.tasks.room.AlarmReference
 import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
@@ -107,17 +107,6 @@ class ExternalImportTest {
         assertThat(importer.hasRun.first()).isTrue()
     }
 
-    @Test
-    fun copiesTagsCleanedUp() = runBlocking {
-        source.lists = listOf(list(7, "Errands"))
-        source.tasks = mapOf(7L to listOf(task(100, "Milk", tags = listOf("Shop", " Shop ", "", "Home"))))
-
-        importer.run()
-
-        assertThat(db.tasks().tasks(listId = null, includeCompleted = true).single().task.categories)
-            .containsExactly("Shop", "Home").inOrder()
-    }
-
     /** Every list arrives device-only: the account belongs to the sync app. */
     @Test
     fun importedListsAreDeviceOnly() = runBlocking {
@@ -252,7 +241,6 @@ class ExternalImportTest {
         title: String,
         uid: String? = "uid-$id",
         parentId: Long? = null,
-        tags: List<String> = emptyList(),
     ) = ExportTask(
         taskId = id,
         uid = uid,
@@ -272,7 +260,6 @@ class ExternalImportTest {
         rrule = null,
         rdate = null,
         parentId = parentId,
-        tags = tags,
     )
 
     private companion object {
@@ -294,25 +281,23 @@ private class FakeExternalStore : TasksDataSource {
         return tasks[listId].orEmpty()
     }
 
-    override fun reminders(): Map<Long, List<TaskReminder>> = alarms.mapValues { listOf(it.value) }
+    override fun alarms(): Map<Long, TaskReminder> = alarms
 
     override fun tasks(query: TaskQuery): List<Task> = unused()
     override fun task(taskId: Long): Task? = unused()
     override fun subtasks(parentTaskId: Long): List<Task> = unused()
-    override fun insertTask(form: TaskForm, reminders: List<TaskReminder>?): Long = unused()
+    override fun insertTask(form: TaskForm): Long = unused()
-    override fun updateTask(taskId: Long, form: TaskForm, reminders: List<TaskReminder>?) = unused()
+    override fun updateTask(taskId: Long, form: TaskForm) = unused()
-    override fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?) =
+    override fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm) = unused()
-        unused()
+    override fun setAlarm(taskId: Long, minutesBeforeDue: Int?) = unused()
     override fun setReminders(taskId: Long, reminders: List<TaskReminder>) = unused()
     override fun setCompleted(taskId: Long, completed: Boolean) = unused()
     override fun setCompletedInstance(taskId: Long, occurrenceStart: Instant, completed: Boolean) = unused()
     override fun deleteTask(taskId: Long) = unused()
     override fun setCancelled(taskId: Long, cancelled: Boolean) = unused()
     override fun setCancelledInstance(taskId: Long, occurrenceStart: Instant, cancelled: Boolean) = unused()
-    override fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?) =
+    override fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm) = unused()
-        unused()
+    override fun splitSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm): Long = unused()
-    override fun splitSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?): Long =
-        unused()
     override fun deleteOccurrence(seriesId: Long, occurrenceStart: Instant) = unused()
     override fun deleteFollowing(seriesId: Long, occurrenceStart: Instant) = unused()
     override fun createLocalList(name: String, color: Int): Long = unused()

app/src/full/java/de/jeanlucmakiola/agendula/data/sync/CollectionSyncer.kt

@@ -1,10 +1,8 @@
 package de.jeanlucmakiola.agendula.data.sync
 
-import de.jeanlucmakiola.agendula.data.tasks.ical.AlarmCodec
 import de.jeanlucmakiola.agendula.data.tasks.ical.CalendarResource
 import de.jeanlucmakiola.agendula.data.tasks.ical.ResourceValidator
 import de.jeanlucmakiola.agendula.data.tasks.ical.VTodoMapper
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TaskListEntity
 import at.bitfire.dav4jvm.exception.UnauthorizedException
@@ -424,9 +422,8 @@ class CollectionSyncer(
 
         /** Null when the resource was rejected before it left the device. */
         private fun serialize(local: LocalResource): String? {
-            val alarms = store.alarmsFor(local.live.map { it.id })
             val todos = local.live.map { row ->
-                VTodoMapper.write(row, parentUidOf(row), now(), alarms[row.id].orEmpty())
+                VTodoMapper.write(row, parentUidOf(row), now())
             }
             val calendar = CalendarResource.build(todos)
 
@@ -781,17 +778,14 @@ class CollectionSyncer(
             val losing = existing.values.firstOrNull { it.isDirty }
 
             val master = mapped.firstOrNull { it.entity.recurrenceId == null } ?: mapped.first()
-            val masterRow = upsert(master, existing[master.entity.recurrenceId], null, href, eTag)
+            val masterRow = upsert(master.entity, existing[master.entity.recurrenceId], null, href, eTag)
             val masterId = masterRow.id
             parents[uid] = master.parentUid
 
             val written = mutableListOf(masterRow)
             mapped.filter { it !== master }.forEach { override ->
-                // ⚠️ An override's alarms are its own: RFC 5545 has an override
-                // replace the component, so one the server sends without a
-                // VALARM has none, whatever its master carries.
                 written += upsert(
-                    override, existing[override.entity.recurrenceId], masterId, href, eTag,
+                    override.entity, existing[override.entity.recurrenceId], masterId, href, eTag,
                 )
             }
             val kept = written.map { it.recurrenceId }.toSet()
@@ -838,13 +832,12 @@ class CollectionSyncer(
 
         /** @return the row as it now stands, so the caller can index it. */
         private fun upsert(
-            mapped: VTodoMapper.Mapped,
+            incoming: TaskEntity,
             existing: TaskEntity?,
             masterId: Long?,
             href: String,
             eTag: String?,
         ): TaskEntity {
-            val incoming = mapped.entity
             // Local-only columns the server has no opinion about. Taking the
             // mapper's defaults here would silently reset the user's ordering and
             // per-task colour on every download.
@@ -861,42 +854,12 @@ class CollectionSyncer(
                 // set uploads what was just downloaded.
                 isDirty = false,
                 isDeleted = false,
-                // The store's to change, from what the alarms do.
-                remindersOff = existing?.remindersOff ?: false,
             )
-            // The server's alarms replace ours, as every other field does: a
+            return if (existing == null) {
-            // dirty row is never downloaded except to discard its edit.
+                row.copy(id = store.insert(row))
-            val alarms = existing?.let { keepLocalPrecision(mapped.alarms, it, row) } ?: mapped.alarms
+            } else {
-            return row.copy(id = store.upsertWithAlarms(row, alarms))
+                store.update(row)
-        }
+                row
-
-        /**
-         * [incoming] with each alarm we uploaded ourselves put back to the lead
-         * we hold for it.
-         *
-         * ⚠️ The wire is coarser than the row: a lead past the end of its
-         * anchor is clamped, and a before-start reminder on a task without a
-         * start goes out before-due. Taking the round trip at its word would
-         * quietly turn a before-start reminder into a before-due one the first
-         * time the task is downloaded again.
-         * An alarm that comes back as exactly what we would have sent has not
-         * been changed, so the row's own lead stands.
-         */
-        private fun keepLocalPrecision(
-            incoming: List<TaskAlarmEntity>,
-            existing: TaskEntity,
-            task: TaskEntity,
-        ): List<TaskAlarmEntity> {
-            val local = store.alarmsFor(listOf(existing.id))[existing.id].orEmpty()
-            if (local.isEmpty()) return incoming
-            return incoming.map { alarm ->
-                val mine = local.firstOrNull { it.uid == alarm.uid } ?: return@map alarm
-                val sent = AlarmCodec.wireLead(mine, task)
-                if (sent == AlarmCodec.Lead(alarm.minutesBefore, alarm.reference)) {
-                    alarm.copy(minutesBefore = mine.minutesBefore, reference = mine.reference)
-                } else {
-                    alarm
-                }
             }
         }
 

app/src/full/java/de/jeanlucmakiola/agendula/data/sync/SyncStore.kt

@@ -1,6 +1,5 @@
 package de.jeanlucmakiola.agendula.data.sync
 
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
 import javax.inject.Inject
@@ -12,33 +11,17 @@ import javax.inject.Inject
  * discovery: the reconciliation above this interface is where local edits are
  * discarded, tombstones swept and conflicts resolved, and every one of those is
  * a decision that should be provable without a device. Room's test double is
- * Robolectric plus an in-memory database; this is a dozen methods.
+ * Robolectric plus an in-memory database; this is eight methods.
  */
 interface SyncStore {
 
     /** Every row in a list, **tombstones included**. */
     fun rowsIn(listId: Long): List<TaskEntity>
 
+    fun insert(row: TaskEntity): Long
+
     fun update(row: TaskEntity)
 
-    /** The reminders of [taskIds] — one resource's rows — by task id, for the body that uploads them. */
-    fun alarmsFor(taskIds: List<Long>): Map<Long, List<TaskAlarmEntity>>
-
-    /**
-     * Writes a downloaded row — inserted when its id is 0 — and makes its
-     * reminders exactly [alarms], in one transaction.
-     *
-     * ⚠️ One transaction, not an [update] and a second call. The row lands clean
-     * with the server's ETag, so if the process died between the two, nothing
-     * would ever download it again and the reminders would stay stale for good.
-     *
-     * A row that is gone by the time it is written — deleted on the device
-     * while the sync ran — stays gone, reminders and all.
-     *
-     * @return the row's id.
-     */
-    fun upsertWithAlarms(row: TaskEntity, alarms: List<TaskAlarmEntity>): Long
-
     fun deleteAll(taskIds: List<Long>)
 
     /**
@@ -73,26 +56,12 @@ class RoomSyncStore @Inject constructor(
 
     override fun rowsIn(listId: Long) = database.tasks().allIn(listId)
 
+    override fun insert(row: TaskEntity) = database.tasks().insert(row)
+
     override fun update(row: TaskEntity) {
         database.tasks().update(row)
     }
 
-    override fun alarmsFor(taskIds: List<Long>) =
-        if (taskIds.isEmpty()) emptyMap() else database.alarms().forTasks(taskIds).groupBy { it.taskId }
-
-    override fun upsertWithAlarms(row: TaskEntity, alarms: List<TaskAlarmEntity>): Long =
-        database.runInTransaction<Long> {
-            if (row.id == 0L) {
-                database.tasks().insert(row).also { database.alarms().replaceFromServer(it, alarms) }
-            } else {
-                // ⚠️ Zero rows means the row was deleted under us. Its alarms
-                // would then name a task that does not exist, and the foreign
-                // key would fail the whole transaction.
-                if (database.tasks().update(row) > 0) database.alarms().replaceFromServer(row.id, alarms)
-                row.id
-            }
-        }
-
     override fun deleteAll(taskIds: List<Long>) {
         if (taskIds.isNotEmpty()) database.tasks().deleteAll(taskIds)
     }

app/src/full/java/de/jeanlucmakiola/agendula/ui/accounts/AccountDetailScreen.kt

@@ -70,7 +70,6 @@ internal fun AccountDetailScreen(
     onSignInAgain: (AccountEntity) -> Unit,
     onOpenStorage: () -> Unit,
     viewModel: AccountsViewModel,
-    visible: Boolean,
 ) {
     val accounts by viewModel.accounts.collectAsStateWithLifecycle()
     val usable by viewModel.accountsUsable.collectAsStateWithLifecycle()
@@ -91,7 +90,7 @@ internal fun AccountDetailScreen(
     // shown on the accounts list rather than here.
     var confirming by remember { mutableStateOf(false) }
 
-    CollapsingScaffold(title = identity.title, onBack = onBack, predictiveBack = true, visible = visible) {
+    CollapsingScaffold(title = identity.title, onBack = onBack) {
         AccountHero(identity)
         Spacer(Modifier.height(24.dp))
 

app/src/full/java/de/jeanlucmakiola/agendula/ui/accounts/AccountsScreen.kt

@@ -48,7 +48,6 @@ internal fun AccountsScreen(
     onOpenStorage: () -> Unit,
     onBack: () -> Unit,
     viewModel: AccountsViewModel,
-    visible: Boolean,
 ) {
     val accounts by viewModel.accounts.collectAsStateWithLifecycle()
     val usable by viewModel.accountsUsable.collectAsStateWithLifecycle()
@@ -61,8 +60,6 @@ internal fun AccountsScreen(
     CollapsingScaffold(
         title = stringResource(R.string.settings_section_accounts),
         onBack = onBack,
-        predictiveBack = true,
-        visible = visible,
     ) {
         val loaded = accounts ?: return@CollapsingScaffold
 

app/src/full/java/de/jeanlucmakiola/agendula/ui/settings/AccountSections.kt

@@ -31,8 +31,8 @@ internal fun AccountSections(
     // Which account the detail screen is showing; the section alone cannot say.
     var openAccount by rememberSaveable(initialAccountId) { mutableStateOf(initialAccountId) }
 
-    // Accounts stays composed under Add account, for the same reason Backup
+    // Accounts stays composed under Add account, for the same reason Storage
-    // stays composed under export and import: the deeper screen slides over it.
+    // stays composed under Export: the deeper screen slides over it.
     val accountsOpen = section == SettingsSection.Accounts ||
         section?.parent == SettingsSection.Accounts
     SlideInSection(visible = accountsOpen) {
@@ -50,11 +50,9 @@ internal fun AccountSections(
             onOpenStorage = { onSection(SettingsSection.Storage) },
             onBack = { onSection(null) },
             viewModel = accountsViewModel,
-            visible = accountsOpen,
         )
     }
-    val accountOpen = section == SettingsSection.Account
+    SlideInSection(visible = section == SettingsSection.Account) {
-    SlideInSection(visible = accountOpen) {
         openAccount?.let { id ->
             AccountDetailScreen(
                 accountId = id,
@@ -63,7 +61,6 @@ internal fun AccountSections(
                 onSignInAgain = signInAgain,
                 onOpenStorage = { onSection(SettingsSection.Storage) },
                 viewModel = accountsViewModel,
-                visible = accountOpen,
             )
         }
     }

app/src/main/AndroidManifest.xml

@@ -9,26 +9,13 @@
          selected External mode. Both are dangerous-level.
 
          StorageMode.OWN needs nothing here: it is a Room database in our own data
-         directory. -->
+         directory. Agendula publishes no ContentProvider and declares no
+         permissions of its own. -->
     <uses-permission android:name="org.dmfs.permission.READ_TASKS" />
     <uses-permission android:name="org.dmfs.permission.WRITE_TASKS" />
     <uses-permission android:name="org.tasks.permission.READ_TASKS" />
     <uses-permission android:name="org.tasks.permission.WRITE_TASKS" />
 
-    <!-- What another app requests to read or write the own store through
-         AgendulaTaskProvider. Dangerous, like OpenTasks' own: the user grants
-         them per app. Suffixed per build, so debug and release can coexist. -->
-    <permission
-        android:name="${applicationId}.permission.READ_TASKS"
-        android:description="@string/permission_read_tasks_description"
-        android:label="@string/permission_read_tasks_label"
-        android:protectionLevel="dangerous" />
-    <permission
-        android:name="${applicationId}.permission.WRITE_TASKS"
-        android:description="@string/permission_write_tasks_description"
-        android:label="@string/permission_write_tasks_label"
-        android:protectionLevel="dangerous" />
-
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <!-- Exact due-time reminders. User-granted: USE_EXACT_ALARM is reserved for
@@ -50,7 +37,6 @@
     <application
         android:name=".AgendulaApp"
         android:allowBackup="true"
-        android:enableOnBackInvokedCallback="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"
         android:icon="@mipmap/ic_launcher"
@@ -247,16 +233,6 @@
             </intent-filter>
         </receiver>
 
-        <!-- The own store under the OpenTasks contract. Empty, and refusing
-             writes, while External mode is active. -->
-        <provider
-            android:name=".data.tasks.provider.AgendulaTaskProvider"
-            android:authorities="${applicationId}.tasks"
-            android:exported="true"
-            android:readPermission="${applicationId}.permission.READ_TASKS"
-            android:writePermission="${applicationId}.permission.WRITE_TASKS"
-            tools:ignore="SystemPermissionTypo" />
-
         <!-- WorkManager's on-demand initialisation. Removing the default
              initializer is what lets AgendulaApp supply a HiltWorkerFactory, so
              @HiltWorker workers can take injected dependencies. -->

app/src/main/java/de/jeanlucmakiola/agendula/AgendulaApp.kt

@@ -16,7 +16,6 @@ import de.jeanlucmakiola.agendula.data.reminders.ReminderScheduler
 import de.jeanlucmakiola.agendula.data.reminders.TaskNotifier
 import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
 import de.jeanlucmakiola.agendula.data.tasks.StartupGate
-import de.jeanlucmakiola.agendula.data.tasks.provider.ProviderSnapshotSource
 import de.jeanlucmakiola.agendula.data.tasks.room.DatabaseCheckpoint
 import de.jeanlucmakiola.agendula.widget.TaskWidgetUpdater
 import de.jeanlucmakiola.floret.crash.CrashConfig
@@ -88,7 +87,6 @@ class AgendulaApp : Application(), Configuration.Provider {
                 scheduler.sync()
             }
             runCatching { entryPoint.taskWidgetUpdater().start() }
-            runCatching { entryPoint.providerSnapshotSource().start() }
             runCatching { ReminderMaintenanceWorker.schedule(this@AgendulaApp) }
         }
     }
@@ -124,6 +122,5 @@ class AgendulaApp : Application(), Configuration.Provider {
         fun taskNotifier(): TaskNotifier
         fun channelRefreshers(): Set<@JvmSuppressWildcards ChannelRefresher>
         fun taskWidgetUpdater(): TaskWidgetUpdater
-        fun providerSnapshotSource(): ProviderSnapshotSource
     }
 }

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

@@ -149,8 +149,6 @@ class MainActivity : ComponentActivity() {
         const val ACTION_TODAY = "de.jeanlucmakiola.agendula.action.TODAY"
         private const val ACTION_OPEN_SMART = "de.jeanlucmakiola.agendula.action.OPEN_SMART"
         private const val ACTION_OPEN_LIST = "de.jeanlucmakiola.agendula.action.OPEN_LIST"
-        private const val ACTION_OPEN_FILTER = "de.jeanlucmakiola.agendula.action.OPEN_FILTER"
-        private const val EXTRA_FILTER_ID = "de.jeanlucmakiola.agendula.extra.FILTER_ID"
         private const val EXTRA_SMART_LIST = "de.jeanlucmakiola.agendula.extra.SMART_LIST"
         private const val EXTRA_LIST_ID = "de.jeanlucmakiola.agendula.extra.LIST_ID"
         private const val EXTRA_PRESET_LIST_ID = "de.jeanlucmakiola.agendula.extra.PRESET_LIST_ID"
@@ -200,12 +198,6 @@ class MainActivity : ComponentActivity() {
                 .putExtra(EXTRA_LIST_ID, listId)
                 .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
 
-        /** Opens one saved filter. */
-        fun filterIntent(context: Context, filterId: Long): Intent =
-            Intent(ACTION_OPEN_FILTER, "agendula://filter/$filterId".toUri(), context, MainActivity::class.java)
-                .putExtra(EXTRA_FILTER_ID, filterId)
-                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-
         internal fun navRequestOf(intent: Intent?): NavRequest? {
             if (intent == null) return null
             if (BuildConfig.SYNC_ENABLED) {
@@ -223,8 +215,6 @@ class MainActivity : ComponentActivity() {
                     ?.let { return NavRequest.OpenSmart(it) }
                 ACTION_OPEN_LIST -> intent.getLongExtra(EXTRA_LIST_ID, -1L).takeIf { it > 0L }
                     ?.let { return NavRequest.OpenList(it) }
-                ACTION_OPEN_FILTER -> intent.getLongExtra(EXTRA_FILTER_ID, -1L).takeIf { it > 0L }
-                    ?.let { return NavRequest.OpenFilter(it) }
             }
             importIntentUri(intent)?.let { return NavRequest.Import(it) }
             if (intent.action == Intent.ACTION_SEND && intent.type?.startsWith("text/plain") == true) {

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

@@ -89,7 +89,6 @@ object DataProvideModule {
             // backed-up `.db` does not. The backup rules carry all three files and
             // the app checkpoints on ON_STOP.
             .setJournalMode(RoomDatabase.JournalMode.WRITE_AHEAD_LOGGING)
-            .addMigrations(TasksDatabase.MIGRATION_1_2, TasksDatabase.MIGRATION_2_3)
             .build()
 
     /**

app/src/main/java/de/jeanlucmakiola/agendula/data/prefs/SavedFilterCodec.kt

@@ -1,83 +0,0 @@
-package de.jeanlucmakiola.agendula.data.prefs
-
-import de.jeanlucmakiola.agendula.domain.DueWindow
-import de.jeanlucmakiola.agendula.domain.Priority
-import de.jeanlucmakiola.agendula.domain.SavedFilter
-import de.jeanlucmakiola.agendula.domain.TagMatch
-import java.net.URLDecoder
-import java.net.URLEncoder
-
-/**
- * Stored form of the saved filters: one line per filter,
- * `id|name|due|lists|tags|match|priority`, with name and tags URL-encoded and
- * list ids qualified by the store they belong to (`OWN:3`), since each store
- * numbers its lists on its own. Fixed once released — don't change without a
- * data migration.
- */
-internal object SavedFilterCodec {
-
-    /** The filters in [raw], with only the list ids of [mode]'s store. */
-    fun decode(raw: String?, mode: String): List<SavedFilter> =
-        lines(raw).mapNotNull { runCatching { decodeLine(it, mode) }.getOrNull() }
-
-    /** [raw] with [filter] replacing the line of the same id, or appended. */
-    fun upsert(raw: String?, filter: SavedFilter, mode: String): String {
-        val existing = lines(raw)
-        val index = existing.indexOfFirst { idOf(it) == filter.id }
-        // Keep the lists another store contributed, so switching stores and back
-        // doesn't widen a filter that was edited in between, unless "any list"
-        // was chosen here, which drops them on purpose.
-        val foreign = if (filter.anyList) {
-            emptyList()
-        } else {
-            existing.getOrNull(index)?.let(::fields)?.getOrNull(3)
-                ?.let(::splitList)?.filterNot { it.startsWith("$mode:") }.orEmpty()
-        }
-        val line = encodeLine(filter, mode, foreign)
-        val updated = if (index >= 0) existing.toMutableList().also { it[index] = line } else existing + line
-        return updated.joinToString("\n")
-    }
-
-    fun remove(raw: String?, id: Long): String = lines(raw).filterNot { idOf(it) == id }.joinToString("\n")
-
-    private fun lines(raw: String?): List<String> = raw.orEmpty().split('\n').filter { it.isNotBlank() }
-
-    private fun fields(line: String): List<String> = line.split('|')
-
-    private fun idOf(line: String): Long? = fields(line).firstOrNull()?.toLongOrNull()
-
-    private fun splitList(value: String): List<String> = value.split(',').filter { it.isNotEmpty() }
-
-    private fun encodeLine(filter: SavedFilter, mode: String, foreignLists: List<String>): String =
-        listOf(
-            filter.id.toString(),
-            encode(filter.name),
-            filter.due.sorted().joinToString(",") { it.name },
-            (filter.listIds.sorted().map { "$mode:$it" } + foreignLists).joinToString(","),
-            filter.tags.sorted().joinToString(",") { encode(it) },
-            filter.tagMatch.name,
-            filter.minPriority.name,
-        ).joinToString("|")
-
-    private fun decodeLine(line: String, mode: String): SavedFilter? {
-        val f = fields(line)
-        if (f.size < 7) return null
-        val id = f[0].toLongOrNull() ?: return null
-        val lists = splitList(f[3])
-        val here = lists.filter { it.startsWith("$mode:") }.mapNotNull { it.removePrefix("$mode:").toLongOrNull() }.toSet()
-        return SavedFilter(
-            id = id,
-            name = decode(f[1]),
-            due = splitList(f[2]).mapNotNull { runCatching { DueWindow.valueOf(it) }.getOrNull() }.toSet(),
-            listIds = here,
-            listsElsewhere = lists.any { !it.startsWith("$mode:") },
-            tags = splitList(f[4]).map(::decode).toSet(),
-            tagMatch = runCatching { TagMatch.valueOf(f[5]) }.getOrDefault(TagMatch.ANY),
-            minPriority = runCatching { Priority.valueOf(f[6]) }.getOrDefault(Priority.NONE),
-        )
-    }
-
-    private fun encode(value: String): String = URLEncoder.encode(value, Charsets.UTF_8.name())
-
-    private fun decode(value: String): String = URLDecoder.decode(value, Charsets.UTF_8.name())
-}

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

@@ -10,22 +10,16 @@ import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.core.stringSetPreferencesKey
 import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
 import de.jeanlucmakiola.agendula.data.tasks.StorageMode
-import de.jeanlucmakiola.agendula.domain.SavedFilter
 import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskFilter
 import de.jeanlucmakiola.agendula.domain.TaskFormField
-import de.jeanlucmakiola.agendula.domain.TaskReminder
-import de.jeanlucmakiola.agendula.domain.asTaskReminder
-import de.jeanlucmakiola.agendula.domain.asReminderLead
 import de.jeanlucmakiola.agendula.domain.TaskSortOrder
-import de.jeanlucmakiola.floret.reminders.ReminderLead
 import de.jeanlucmakiola.floret.reminders.ReminderOverride
 import de.jeanlucmakiola.floret.reminders.ReminderOverrideCodec
 import de.jeanlucmakiola.floret.reminders.applyReminderOverride
 import de.jeanlucmakiola.floret.reminders.normalizeReminders
 import de.jeanlucmakiola.floret.reminders.reminderLeadsFor
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.distinctUntilChanged
 import java.time.DayOfWeek
 import kotlinx.coroutines.flow.map
 import javax.inject.Inject
@@ -61,10 +55,10 @@ data class Settings(
     val dynamicColor: Boolean = true,
     /** The list a new task defaults to; `null` = first available. */
     val defaultListId: Long? = null,
-    /** Default reminders (0 before due = at due time); empty = none. */
+    /** Default reminders, as minutes before due (0 = at due time); empty = none. */
-    val defaultReminders: List<ReminderLead> = listOf(ReminderLead(0)),
+    val defaultReminderMinutes: List<Int> = listOf(0),
-    /** Default reminders for all-day tasks, in whole days, rung at [allDayReminderMinuteOfDay]. */
+    /** Default reminders for all-day tasks, as days-scale minutes before [allDayReminderMinuteOfDay]. */
-    val defaultAllDayReminders: List<ReminderLead> = listOf(ReminderLead(0)),
+    val defaultAllDayReminderMinutes: List<Int> = listOf(0),
     /** Local time (minutes from midnight) an all-day task's reminder counts back from. */
     val allDayReminderMinuteOfDay: Int = DEFAULT_ALL_DAY_REMINDER_MINUTE,
     /** Master switch for due reminders; off clears every scheduled alarm. */
@@ -78,13 +72,13 @@ data class Settings(
      */
     val bottomAddBar: Boolean = false,
     /**
-     * Per-list overrides of [defaultReminders]: a list present in the map
+     * Per-list overrides of [defaultReminderMinutes]: a list present in the map
      * overrides the global default (an empty list = no reminder); absent =
      * inherit.
      */
-    val perListReminderOverride: Map<Long, List<ReminderLead>> = emptyMap(),
+    val perListReminderOverride: Map<Long, List<Int>> = emptyMap(),
-    /** Per-list overrides of [defaultAllDayReminders], same shape as [perListReminderOverride]. */
+    /** Per-list overrides of [defaultAllDayReminderMinutes], same shape as [perListReminderOverride]. */
-    val perListAllDayReminderOverride: Map<Long, List<ReminderLead>> = emptyMap(),
+    val perListAllDayReminderOverride: Map<Long, List<Int>> = emptyMap(),
     /** Optional edit-form fields shown by default; the rest sit behind "More fields". */
     val defaultEditFields: Set<TaskFormField> = emptySet(),
     val sortOrder: TaskSortOrder = TaskSortOrder.DUE,
@@ -113,16 +107,12 @@ data class Settings(
         }
 
     /** The lead times for a task in [listId]: its override if set, else the global default. */
-    fun reminderLeadsFor(listId: Long): List<ReminderLead> =
+    fun reminderLeadsFor(listId: Long): List<Int> =
-        perListReminderOverride.reminderLeadsFor(listId, defaultReminders)
+        perListReminderOverride.reminderLeadsFor(listId, defaultReminderMinutes)
 
     /** The lead times for an all-day task in [listId]. */
-    fun allDayReminderLeadsFor(listId: Long): List<ReminderLead> =
+    fun allDayReminderLeadsFor(listId: Long): List<Int> =
-        perListAllDayReminderOverride.reminderLeadsFor(listId, defaultAllDayReminders)
+        perListAllDayReminderOverride.reminderLeadsFor(listId, defaultAllDayReminderMinutes)
-
-    /** The default reminders a task in [listId] takes — the one rule for which default applies. */
-    fun defaultRemindersFor(listId: Long, allDay: Boolean): List<TaskReminder> =
-        (if (allDay) allDayReminderLeadsFor(listId) else reminderLeadsFor(listId)).map { it.asTaskReminder() }
 }
 
 /** App preferences, backed by DataStore. Mirrors Calendula's prefs shape. */
@@ -138,18 +128,16 @@ class SettingsPrefs @Inject constructor(
             dynamicColor = p[DYNAMIC_COLOR] ?: true,
             defaultListId = p[DEFAULT_LIST_ID]?.takeIf { it > 0 },
             // The single lead of earlier versions carries over until a list is saved.
-            defaultReminders = p[DEFAULT_REMINDERS]?.let(::parseLeads)
+            defaultReminderMinutes = p[DEFAULT_REMINDERS]?.let(::parseMinutes)
-                ?: listOf(ReminderLead(p[REMINDER_LEAD] ?: 0)),
+                ?: listOf(p[REMINDER_LEAD] ?: 0),
-            defaultAllDayReminders = p[DEFAULT_ALL_DAY_REMINDERS]?.let(::parseLeads)?.inWholeDays()
+            defaultAllDayReminderMinutes = p[DEFAULT_ALL_DAY_REMINDERS]?.let(::parseMinutes) ?: listOf(0),
-                ?: listOf(ReminderLead(0)),
             allDayReminderMinuteOfDay = p[ALL_DAY_REMINDER_MINUTE]?.takeIf { it in 0 until 24 * 60 }
                 ?: DEFAULT_ALL_DAY_REMINDER_MINUTE,
             remindersEnabled = p[REMINDERS_ENABLED] ?: true,
             showAddSubtaskRow = p[SHOW_ADD_SUBTASK_ROW] ?: true,
             bottomAddBar = p[BOTTOM_ADD_BAR] ?: false,
-            perListReminderOverride = reminderCodec.parseLeads(p[LIST_REMINDER_OVERRIDE]),
+            perListReminderOverride = reminderCodec.parse(p[LIST_REMINDER_OVERRIDE]),
-            perListAllDayReminderOverride = reminderCodec.parseLeads(p[LIST_ALL_DAY_REMINDER_OVERRIDE])
+            perListAllDayReminderOverride = reminderCodec.parse(p[LIST_ALL_DAY_REMINDER_OVERRIDE]),
-                .mapValues { it.value.inWholeDays() },
             defaultEditFields = p[DEFAULT_EDIT_FIELDS].orEmpty()
                 .mapNotNull { name -> runCatching { TaskFormField.valueOf(name) }.getOrNull() }
                 .toSet(),
@@ -195,12 +183,12 @@ class SettingsPrefs @Inject constructor(
         if (id == null) it.remove(DEFAULT_LIST_ID) else it[DEFAULT_LIST_ID] = id
     }
 
-    suspend fun setDefaultReminders(leads: List<ReminderLead>) = dataStore.edit {
+    suspend fun setDefaultReminderMinutes(minutes: List<Int>) = dataStore.edit {
-        it[DEFAULT_REMINDERS] = leads.normalizeReminders().joinToString(",") { lead -> lead.toToken() }
+        it[DEFAULT_REMINDERS] = minutes.normalizeReminders().joinToString(",")
     }
 
-    suspend fun setDefaultAllDayReminders(leads: List<ReminderLead>) = dataStore.edit {
+    suspend fun setDefaultAllDayReminderMinutes(minutes: List<Int>) = dataStore.edit {
-        it[DEFAULT_ALL_DAY_REMINDERS] = leads.normalizeReminders().joinToString(",") { lead -> lead.toToken() }
+        it[DEFAULT_ALL_DAY_REMINDERS] = minutes.normalizeReminders().joinToString(",")
     }
 
     suspend fun setAllDayReminderMinuteOfDay(minuteOfDay: Int) =
@@ -253,16 +241,16 @@ class SettingsPrefs @Inject constructor(
 
     /** Set (or clear, via [ReminderOverride.Inherit]) a list's reminder override. */
     suspend fun setListReminderOverride(listId: Long, override: ReminderOverride) = dataStore.edit { p ->
-        val current = reminderCodec.parseLeads(p[LIST_REMINDER_OVERRIDE]).toMutableMap()
+        val current = reminderCodec.parse(p[LIST_REMINDER_OVERRIDE]).toMutableMap()
         current.applyReminderOverride(listId, override)
-        p[LIST_REMINDER_OVERRIDE] = reminderCodec.serializeLeads(current)
+        p[LIST_REMINDER_OVERRIDE] = reminderCodec.serialize(current)
     }
 
     /** Set (or clear) a list's all-day reminder override. */
     suspend fun setListAllDayReminderOverride(listId: Long, override: ReminderOverride) = dataStore.edit { p ->
-        val current = reminderCodec.parseLeads(p[LIST_ALL_DAY_REMINDER_OVERRIDE]).toMutableMap()
+        val current = reminderCodec.parse(p[LIST_ALL_DAY_REMINDER_OVERRIDE]).toMutableMap()
         current.applyReminderOverride(listId, override)
-        p[LIST_ALL_DAY_REMINDER_OVERRIDE] = reminderCodec.serializeLeads(current)
+        p[LIST_ALL_DAY_REMINDER_OVERRIDE] = reminderCodec.serialize(current)
     }
 
     suspend fun setHiddenFromSmartLists(listId: Long, hidden: Boolean) = dataStore.edit { p ->
@@ -271,34 +259,6 @@ class SettingsPrefs @Inject constructor(
         p[SMART_LIST_HIDDEN] = if (hidden) current + entry else current - entry
     }
 
-    /** The saved filters, oldest first, with the list ids of the current store. */
-    val savedFilters: Flow<List<SavedFilter>> =
-        dataStore.data.map { p -> p[SAVED_FILTERS] to p[STORAGE_MODE] }
-            .distinctUntilChanged()
-            .map { (raw, mode) -> SavedFilterCodec.decode(raw, (storedMode(mode) ?: resolver.autoMode()).name) }
-            .distinctUntilChanged()
-
-    /** One saved filter; `null` while it doesn't exist. */
-    fun savedFilter(id: Long): Flow<SavedFilter?> =
-        savedFilters.map { all -> all.firstOrNull { it.id == id } }.distinctUntilChanged()
-
-    /** Store [filter]; an id of 0 makes a new one. Returns the filter's id. */
-    suspend fun saveFilter(filter: SavedFilter): Long {
-        var id = filter.id
-        dataStore.edit { p ->
-            if (id <= 0) {
-                id = p[SAVED_FILTER_NEXT_ID] ?: 1L
-                p[SAVED_FILTER_NEXT_ID] = id + 1
-            }
-            p[SAVED_FILTERS] = SavedFilterCodec.upsert(p[SAVED_FILTERS], filter.copy(id = id), modeOf(p).name)
-        }
-        return id
-    }
-
-    suspend fun deleteFilter(id: Long) = dataStore.edit { p ->
-        p[SAVED_FILTERS] = SavedFilterCodec.remove(p[SAVED_FILTERS], id)
-    }
-
     suspend fun setDefaultEditFields(fields: Set<TaskFormField>) = dataStore.edit {
         it[DEFAULT_EDIT_FIELDS] = fields.mapTo(mutableSetOf()) { field -> field.name }
     }
@@ -328,8 +288,6 @@ class SettingsPrefs @Inject constructor(
         val PUSH_ENABLED = booleanPreferencesKey("push_enabled")
         val SMART_LIST_HIDDEN = stringSetPreferencesKey("smart_list_hidden")
         val DEFAULT_START_TODAY = booleanPreferencesKey("default_start_today")
-        val SAVED_FILTERS = stringPreferencesKey("saved_filters")
-        val SAVED_FILTER_NEXT_ID = longPreferencesKey("saved_filter_next_id")
     }
 }
 
@@ -340,13 +298,6 @@ class SettingsPrefs @Inject constructor(
  */
 private val reminderCodec = ReminderOverrideCodec.DEFAULT
 
-/** `s5,30` → [5 before start, 30 before due]; an empty string is an explicit "no reminder". */
+/** `5,30` → [5, 30]; an empty string is an explicit "no reminder". */
-private fun parseLeads(stored: String): List<ReminderLead> =
+private fun parseMinutes(stored: String): List<Int> =
-    stored.split(',').mapNotNull { ReminderLead.parse(it)?.takeIf { lead -> lead.minutes >= 0 } }.normalizeReminders()
+    stored.split(',').mapNotNull { it.trim().toIntOrNull()?.takeIf { m -> m >= 0 } }.normalizeReminders()
-
-/**
- * All-day defaults as whole days. Before 1.2 an all-day default could be hours
- * before the all-day time; a lead that is not whole days now names a time of day.
- */
-private fun List<ReminderLead>.inWholeDays(): List<ReminderLead> =
-    map { it.asTaskReminder().inWholeDays().asReminderLead() }.normalizeReminders()

app/src/main/java/de/jeanlucmakiola/agendula/data/reminders/ReminderPlanner.kt

@@ -1,9 +1,8 @@
 package de.jeanlucmakiola.agendula.data.reminders
 
 import de.jeanlucmakiola.agendula.data.prefs.Settings
-import de.jeanlucmakiola.agendula.domain.AllDayReminder
+import de.jeanlucmakiola.agendula.data.tasks.TaskReminder
 import de.jeanlucmakiola.agendula.domain.Task
-import de.jeanlucmakiola.agendula.domain.TaskReminder
 import de.jeanlucmakiola.agendula.domain.calendarDate
 import java.time.LocalTime
 import java.time.ZoneId
@@ -37,53 +36,31 @@ internal object ReminderPlanner {
         // One reminder per *occurrence* and lead: a recurring series yields a row
         // per occurrence, all sharing a taskId, so this is a Set rather than a
         // taskId-keyed Map.
-        .filter { !it.isClosed && (it.due != null || it.start != null) }
+        .filter { !it.isClosed && it.due != null }
         .flatMap { task ->
-            // Reminders set on the task itself win — every one of them;
+            // Reminders set on the task itself win — every one of them, not just
-            // otherwise the task's list may override the global lead, or opt
+            // the one the editor shows; otherwise the task's list may override the
-            // out entirely (override = null). All-day tasks have their own
+            // global lead, or opt out entirely (override = null). All-day tasks
-            // day-scale defaults.
+            // have their own day-scale defaults.
-            //
+            val reminders = perTask[task.taskId].orEmpty().ifEmpty {
-            // ⚠️ Present-but-empty is "none", not "the default": the store's
+                val leads = if (task.isAllDay) settings.allDayReminderLeadsFor(task.listId)
-            // answer for a task whose alarms another client turned off. A
+                else settings.reminderLeadsFor(task.listId)
-            // default here would keep ringing for what the user switched off.
+                leads.map { TaskReminder(it) }
-            // A default counts only from a date the task has; its own reminders
+            }
-            // stand in each date for the other when the task lacks it.
+            reminders.map { reminder ->
-            val own = perTask[task.taskId]
+                // A stored reminder says what it counts back from. Ours are always
-            val reminders = own ?: settings.defaultRemindersFor(task.listId, task.isAllDay)
+                // before due, but an imported dmfs alarm or another client's can be
-                .filter { (if (it.fromStart) task.start else task.due) != null }
+                // before *start*.
-            val created = task.created?.toEpochMilliseconds()
+                val anchor = if (reminder.fromStart) task.start ?: task.due!! else task.due!!
-            reminders.mapNotNull { reminder ->
-                val anchor = if (reminder.fromStart) task.start ?: task.due!! else task.due ?: task.start!!
-                val trigger = triggerAt(
-                    anchor,
-                    task.isAllDay,
-                    reminder.minutesBefore,
-                    settings.allDayReminderMinuteOfDay,
-                    zone,
-                )
-                // A default never rings for a moment before the task existed:
-                // that is a task saved after its default had passed, not a
-                // reminder missed while the device was off.
-                if (own == null && created != null && trigger < created) return@mapNotNull null
-                // Dismissed on another client already: firing it here within
-                // the missed-reminder grace would ring for something done with.
-                //
-                // ⚠️ An all-day reminder without a time of its own is compared
-                // from the start of its day, not from this device's time of
-                // day: other clients ring it at midnight, or at their own hour,
-                // so a dismissal at 07:00 must still silence the 09:00 this
-                // device would ring it at.
-                val earliest = if (task.isAllDay && reminder.allDay.minuteOfDay == null) {
-                    triggerAt(anchor, true, reminder.minutesBefore, 0, zone)
-                } else {
-                    trigger
-                }
-                val acknowledged = reminder.acknowledgedAt?.let { earliest <= it.toEpochMilliseconds() } == true
-                if (acknowledged) return@mapNotNull null
                 ScheduledReminder(
                     taskId = task.taskId,
-                    triggerAt = trigger,
+                    triggerAt = triggerAt(
+                        anchor,
+                        task.isAllDay,
+                        reminder.minutesBefore,
+                        settings.allDayReminderMinuteOfDay,
+                        zone,
+                    ),
                     occurrenceStart = task.occurrenceStart?.toEpochMilliseconds() ?: ScheduledReminder.NO_OCCURRENCE,
                 )
             }
@@ -103,9 +80,8 @@ internal object ReminderPlanner {
      *
      * ⚠️ An all-day anchor is UTC midnight of its date (see `AllDayTime.kt`), a
      * storage convention and not a moment — firing off it rang at 02:00 in
-     * Berlin and the evening before in New York. It is read as its calendar
+     * Berlin and the evening before in New York. It is read as its calendar date
-     * date instead, and the lead as [TaskReminder.allDay]: whole days ring at
+     * at [allDayMinuteOfDay] local time instead, and the lead counts back from that.
-     * [allDayMinuteOfDay] local time, anything else at the time it names.
      */
     fun triggerAt(
         anchor: Instant,
@@ -114,11 +90,12 @@ internal object ReminderPlanner {
         allDayMinuteOfDay: Int,
         zone: ZoneId,
     ): Long {
-        if (!allDay) return anchor.toEpochMilliseconds() - leadMinutes.coerceAtLeast(0) * 60_000L
+        val base = if (allDay) {
-        val (days, minuteOfDay) = AllDayReminder.of(leadMinutes)
+            val time = LocalTime.of(allDayMinuteOfDay / 60 % 24, allDayMinuteOfDay % 60)
-        val minute = minuteOfDay ?: allDayMinuteOfDay
+            anchor.calendarDate(allDay = true).atTime(time).atZone(zone).toInstant().toEpochMilli()
-        val time = LocalTime.of(minute / 60 % 24, minute % 60)
+        } else {
-        return anchor.calendarDate(allDay = true).minusDays(days.toLong())
+            anchor.toEpochMilliseconds()
-            .atTime(time).atZone(zone).toInstant().toEpochMilli()
+        }
+        return base - leadMinutes.coerceAtLeast(0) * 60_000L
     }
 }

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/AndroidTasksDataSource.kt

@@ -1,7 +1,5 @@
 package de.jeanlucmakiola.agendula.data.tasks
 
-import de.jeanlucmakiola.agendula.domain.TaskReminder
-import android.content.ContentProviderOperation
 import android.content.ContentResolver
 import android.content.ContentUris
 import android.content.ContentValues
@@ -21,7 +19,6 @@ import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskForm
 import de.jeanlucmakiola.agendula.domain.TaskList
 import de.jeanlucmakiola.agendula.domain.export.ExportTask
-import de.jeanlucmakiola.agendula.domain.normalizeTags
 import de.jeanlucmakiola.agendula.domain.recurrence.ExpansionWindow
 import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceExpander
 import de.jeanlucmakiola.agendula.domain.recurrence.RecurrenceSpec
@@ -86,27 +83,6 @@ class AndroidTasksDataSource @Inject constructor(
     override fun subtasks(parentTaskId: Long): List<Task> =
         queryInstances("${Tasks.PARENT_ID} = ?", arrayOf(parentTaskId.toString()))
 
-    /**
-     * Read from the `tasks` table, so a recurring subtask with no occurrence in
-     * the window still counts. All columns and a lenient `_deleted`, as in
-     * [exportTasks], since the table's shape varies across providers.
-     */
-    override fun subtaskIds(parentTaskId: Long): List<Long> = resolver.query(
-        TasksContract.tasksUri(authority()),
-        null,
-        "${Tasks.PARENT_ID} = ? AND (${Tasks.DELETED} IS NULL OR ${Tasks.DELETED} = 0)",
-        arrayOf(parentTaskId.toString()),
-        null,
-    )?.use { c ->
-        val r = CursorColumnReader(c)
-        buildList {
-            while (c.moveToNext()) {
-                if (r.getLong(Tasks.ORIGINAL_INSTANCE_ID) != null) continue
-                r.getLong(Tasks.ID)?.takeIf { it != parentTaskId }?.let(::add)
-            }
-        }
-    } ?: emptyList()
-
     private fun queryInstances(selection: String?, args: Array<String>?): List<Task> {
         val uri = TasksContract.instancesUri(authority())
         // projection = null (all columns): the instances view differs across
@@ -114,14 +90,11 @@ class AndroidTasksDataSource @Inject constructor(
         // `is_recurring` / `distance_from_current`). The by-name mapper reads
         // whatever is present and nulls the rest; the repository re-sorts, so we
         // don't depend on a provider sort column either.
-        val tasks = resolver.query(uri, null, selection, args, null)
+        return resolver.query(uri, null, selection, args, null)
             ?.use { c ->
                 val reader = CursorColumnReader(c)
                 buildList { while (c.moveToNext()) add(TaskMapper.task(reader)) }
             } ?: emptyList()
-        if (tasks.isEmpty()) return tasks
-        val tags = categories(tasks.map { it.taskId })
-        return tasks.map { task -> tags[task.taskId]?.let { task.copy(tags = it) } ?: task }
     }
 
     override fun exportTasks(listId: Long): List<ExportTask> {
@@ -129,7 +102,7 @@ class AndroidTasksDataSource @Inject constructor(
         // table's shape varies across provider versions, and the by-name mapper
         // reads what's there.
         val uri = TasksContract.tasksUri(authority())
-        val tasks = resolver.query(
+        return resolver.query(
             uri,
             null,
             // _deleted marks a row awaiting a sync round-trip. It's gone as far as
@@ -142,58 +115,24 @@ class AndroidTasksDataSource @Inject constructor(
             val reader = CursorColumnReader(c)
             buildList { while (c.moveToNext()) add(TaskMapper.exportTask(reader)) }
         } ?: emptyList()
-        if (tasks.isEmpty()) return tasks
-        val tags = categories(tasks.map { it.taskId })
-        return tasks.map { task -> tags[task.taskId]?.let { task.copy(tags = it) } ?: task }
     }
 
     // --- writes ---------------------------------------------------------------
 
-    override fun insertTask(form: TaskForm, reminders: List<TaskReminder>?): Long {
+    override fun insertTask(form: TaskForm): Long {
         val values = TaskWriteMapper.seriesValues(form, ZoneId.systemDefault().id)
-        // One batch, so a refused tag or alarm leaves no task behind for a retry
+        val uri = resolver.insert(TasksContract.tasksUri(authority()), values.toContentValues())
-        // to duplicate.
+            ?: throw TaskWriteFailedException("insert task")
-        val authority = authority()
+        return uri.lastPathSegment?.toLongOrNull() ?: throw TaskWriteFailedException("insert task: no id")
-        val ops = arrayListOf(
-            ContentProviderOperation.newInsert(TasksContract.tasksUri(authority))
-                .withValues(values.toContentValues())
-                .build(),
-        )
-        normalizeTags(form.tags).forEach { tag ->
-            ops += ContentProviderOperation.newInsert(TasksContract.propertiesUri(authority))
-                .withValues(TaskWriteMapper.categoryValues(0, tag).toContentValues().apply { remove(Properties.TASK_ID) })
-                .withValueBackReference(Properties.TASK_ID, 0)
-                .build()
-        }
-        reminders.orEmpty().forEach { reminder ->
-            ops += ContentProviderOperation.newInsert(TasksContract.propertiesUri(authority))
-                .withValues(
-                    TaskWriteMapper.alarmValues(0, reminder.minutesBefore, reminder.fromStart)
-                        .toContentValues().apply { remove(Properties.TASK_ID) },
-                )
-                .withValueBackReference(Properties.TASK_ID, 0)
-                .build()
-        }
-        val results = runCatching { resolver.applyBatch(authority, ops) }
-            .getOrElse { throw TaskWriteFailedException("insert task", it) }
-        return results.firstOrNull()?.uri?.lastPathSegment?.toLongOrNull()
-            ?: throw TaskWriteFailedException("insert task: no id")
     }
 
-    override fun updateTask(taskId: Long, form: TaskForm, reminders: List<TaskReminder>?) {
+    override fun updateTask(taskId: Long, form: TaskForm) {
         val values = TaskWriteMapper.seriesValues(form, ZoneId.systemDefault().id)
         val rows = resolver.update(taskUri(authority(), taskId), values.toContentValues(), null, null)
         if (rows == 0) throw TaskWriteFailedException("update task $taskId")
-        setCategories(taskId, form.tags)
-        writeReminders(taskId, reminders)
     }
 
-    private fun writeReminders(taskId: Long, reminders: List<TaskReminder>?) {
+    override fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm) {
-        if (reminders == null) return
-        setReminders(taskId, reminders)
-    }
-
-    override fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?) {
         val occurrence = task(seriesId, occurrenceStart)
         val anchors = resolver.query(
             taskUri(authority(), seriesId), arrayOf(Tasks.DTSTART, Tasks.DUE), null, null, null,
@@ -212,8 +151,6 @@ class AndroidTasksDataSource @Inject constructor(
             (Tasks.DUE to shifted(anchors?.second, occurrence?.due, form.due))
         val rows = resolver.update(taskUri(authority(), seriesId), values.toContentValues(), null, null)
         if (rows == 0) throw TaskWriteFailedException("update series $seriesId")
-        setCategories(seriesId, form.tags)
-        writeReminders(seriesId, reminders)
     }
 
     /**
@@ -222,10 +159,10 @@ class AndroidTasksDataSource @Inject constructor(
      * task. Per-occurrence edits past the split point are dropped rather than
      * carried over — the provider offers no way to re-parent an exception.
      */
-    override fun splitSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?): Long {
+    override fun splitSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm): Long {
         val spec = seriesSpec(seriesId) ?: throw TaskWriteFailedException("split series $seriesId")
         if (spec.rrule == null || occurrenceStart <= spec.anchor) {
-            updateSeries(seriesId, occurrenceStart, form, reminders)
+            updateSeries(seriesId, occurrenceStart, form)
             return seriesId
         }
         // COUNT counts before EXDATE is applied (RFC 5545 §3.8.5.3).
@@ -235,12 +172,12 @@ class AndroidTasksDataSource @Inject constructor(
         ).size
         endSeriesBefore(seriesId, spec, occurrenceStart)
         val rule = form.rrule?.let { if (it == spec.rrule) TaskFormWriter.remainingCount(it, spent) else it }
-        return insertTask(form.copy(rrule = rule, percentComplete = null), reminders)
+        return insertTask(form.copy(rrule = rule, percentComplete = null))
     }
 
     override fun deleteFollowing(seriesId: Long, occurrenceStart: Instant) {
         val spec = seriesSpec(seriesId) ?: return
-        if (spec.rrule == null || occurrenceStart <= spec.anchor) return deleteWithSubtasks(seriesId)
+        if (spec.rrule == null || occurrenceStart <= spec.anchor) return deleteTask(seriesId)
         endSeriesBefore(seriesId, spec, occurrenceStart)
     }
 
@@ -301,49 +238,13 @@ class AndroidTasksDataSource @Inject constructor(
         resolver.delete(TasksContract.instanceUri(authority(), instanceId), null, null)
     }
 
-    override fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?) {
+    override fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm) {
-        if (reminders == null) return writeInstance(taskId, occurrenceStart, form)
-        // ⚠️ Written to the series, and then put back. Forking an occurrence
-        // copies the task's *current* properties onto the new override row, so
-        // setting the alarm beforehand is the only way to carry it across — and
-        // leaving it there would silently give every other occurrence in the
-        // series the reminder the user set on one of them.
-        val seriesReminders = alarmRows(taskId).map { it.second }
-        writeReminders(taskId, reminders)
-        try {
-            writeInstance(taskId, occurrenceStart, form)
-        } finally {
-            setReminders(taskId, seriesReminders)
-        }
-    }
-
-    private fun writeInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm) {
         val instanceId = instanceIdFor(taskId, occurrenceStart)
             ?: throw TaskWriteFailedException("update instance $taskId@$occurrenceStart: no such occurrence")
         val values = TaskWriteMapper.instanceValues(form, ZoneId.systemDefault().id)
         val uri = TasksContract.instanceUri(authority(), instanceId)
-        // The fork copies the series' properties onto the override, so the tags
+        val rows = resolver.update(uri, values.toContentValues(), null, null)
-        // go onto the series first and are put back once the override exists.
+        if (rows == 0) throw TaskWriteFailedException("update instance $instanceId")
-        // Unchanged tags are inherited as they are, and the series is left alone.
-        val seriesTags = categories(listOf(taskId))[taskId].orEmpty()
-        val retag = normalizeTags(form.tags) != seriesTags
-        if (retag) setCategories(taskId, form.tags)
-        var failure: Throwable? = null
-        try {
-            val rows = resolver.update(uri, values.toContentValues(), null, null)
-            if (rows == 0) throw TaskWriteFailedException("update instance $instanceId")
-        } catch (e: Throwable) {
-            failure = e
-            throw e
-        } finally {
-            if (retag) {
-                try {
-                    setCategories(taskId, seriesTags)
-                } catch (e: Throwable) {
-                    failure?.addSuppressed(e) ?: throw e
-                }
-            }
-        }
     }
 
     /**
@@ -370,6 +271,21 @@ class AndroidTasksDataSource @Inject constructor(
         }
     }
 
+    override fun setAlarm(taskId: Long, minutesBeforeDue: Int?) {
+        val uri = TasksContract.propertiesUri(authority())
+        // Replace rather than update: the provider's AlarmHandler re-validates the
+        // whole row on every update, so a partial edit throws. Only the editable
+        // (last before-due) row goes — a start-relative or additional alarm
+        // another client wrote is not ours to drop.
+        alarmRows(taskId).lastOrNull { !it.second.fromStart }?.let { (propertyId, _) ->
+            resolver.delete(uri, "${Properties.PROPERTY_ID} = ?", arrayOf(propertyId.toString()))
+        }
+        if (minutesBeforeDue != null) {
+            resolver.insert(uri, TaskWriteMapper.alarmValues(taskId, minutesBeforeDue).toContentValues())
+                ?: throw TaskWriteFailedException("set alarm for task $taskId")
+        }
+    }
+
     override fun setReminders(taskId: Long, reminders: List<TaskReminder>) {
         val uri = TasksContract.propertiesUri(authority())
         resolver.delete(
@@ -386,6 +302,9 @@ class AndroidTasksDataSource @Inject constructor(
     override fun reminders(): Map<Long, List<TaskReminder>> =
         readAlarms(null).groupBy({ it.first }) { it.third }
 
+    override fun alarms(): Map<Long, TaskReminder> =
+        reminders().mapNotNull { (id, list) -> list.editable()?.let { id to it } }.toMap()
+
     /** `(property_id, reminder)` for [taskId]'s alarm rows, in stored order. */
     private fun alarmRows(taskId: Long): List<Pair<Long, TaskReminder>> =
         readAlarms(taskId).map { it.second to it.third }
@@ -429,58 +348,6 @@ class AndroidTasksDataSource @Inject constructor(
         } ?: emptyList()
     }
 
-    /** Tags by task id for [taskIds], in stored order. */
-    private fun categories(taskIds: Collection<Long>): Map<Long, List<String>> {
-        val rows = taskIds.distinct().chunked(MAX_SQL_ARGS - 1).flatMap { chunk ->
-            val selection = "${Properties.MIMETYPE} = ? AND ${Properties.TASK_ID} IN (${chunk.joinToString(",") { "?" }})"
-            val args = (listOf(TasksContract.Category.MIMETYPE) + chunk.map(Long::toString)).toTypedArray()
-            resolver.query(
-                TasksContract.propertiesUri(authority()),
-                arrayOf(Properties.TASK_ID, TasksContract.Category.NAME),
-                selection,
-                args,
-                Properties.PROPERTY_ID,
-            )?.use { c ->
-                val reader = CursorColumnReader(c)
-                buildList {
-                    while (c.moveToNext()) {
-                        val id = reader.getLong(Properties.TASK_ID) ?: continue
-                        val name = reader.getString(TasksContract.Category.NAME) ?: continue
-                        add(id to name)
-                    }
-                }
-            } ?: emptyList()
-        }
-        return rows.groupBy({ it.first }, { it.second }).mapValues { normalizeTags(it.value) }
-    }
-
-    /**
-     * Replaces [taskId]'s category rows in one batch, so a refused insert cannot
-     * leave half the tags, and leaves them alone when nothing changed so the task
-     * isn't dirtied.
-     */
-    private fun setCategories(taskId: Long, tags: List<String>) {
-        val wanted = normalizeTags(tags)
-        if (categories(listOf(taskId))[taskId].orEmpty() == wanted) return
-        val authority = authority()
-        val uri = TasksContract.propertiesUri(authority)
-        val ops = arrayListOf(
-            ContentProviderOperation.newDelete(uri)
-                .withSelection(
-                    "${Properties.TASK_ID} = ? AND ${Properties.MIMETYPE} = ?",
-                    arrayOf(taskId.toString(), TasksContract.Category.MIMETYPE),
-                )
-                .build(),
-        )
-        wanted.forEach {
-            ops += ContentProviderOperation.newInsert(uri)
-                .withValues(TaskWriteMapper.categoryValues(taskId, it).toContentValues())
-                .build()
-        }
-        runCatching { resolver.applyBatch(authority, ops) }
-            .getOrElse { throw TaskWriteFailedException("set categories for task $taskId", it) }
-    }
-
     override fun setCancelled(taskId: Long, cancelled: Boolean) {
         val rows = resolver.update(taskUri(authority(), taskId), cancelValues(cancelled).toContentValues(), null, null)
         if (rows == 0) throw TaskWriteFailedException("cancel task $taskId")
@@ -593,6 +460,3 @@ class AndroidTasksDataSource @Inject constructor(
         return cv
     }
 }
-
-/** SQLite's default bound-argument limit on older Android releases. */
-private const val MAX_SQL_ARGS = 999

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/Failures.kt

@@ -5,8 +5,8 @@ class ProviderUnavailableException :
     IllegalStateException("No tasks provider installed")
 
 /** A ContentResolver write returned no URI or affected no rows. */
-class TaskWriteFailedException(operation: String, cause: Throwable? = null) :
+class TaskWriteFailedException(operation: String) :
-    RuntimeException("Task write failed: $operation", cause)
+    RuntimeException("Task write failed: $operation")
 
 /**
  * The task changed (e.g. a DAVx5 sync or another app) since the edit form loaded

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/ModeRoutingTasksDataSource.kt

@@ -1,6 +1,5 @@
 package de.jeanlucmakiola.agendula.data.tasks
 
-import de.jeanlucmakiola.agendula.domain.TaskReminder
 import de.jeanlucmakiola.agendula.data.tasks.room.RoomTasksDataSource
 import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskForm
@@ -35,24 +34,23 @@ class ModeRoutingTasksDataSource(
     override fun tasks(query: TaskQuery): List<Task> = active().tasks(query)
     override fun task(taskId: Long): Task? = active().task(taskId)
     override fun task(taskId: Long, occurrenceStart: Instant?): Task? = active().task(taskId, occurrenceStart)
-    override fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?) =
+    override fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm) =
-        active().updateSeries(seriesId, occurrenceStart, form, reminders)
+        active().updateSeries(seriesId, occurrenceStart, form)
-    override fun splitSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?): Long =
+    override fun splitSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm): Long =
-        active().splitSeries(seriesId, occurrenceStart, form, reminders)
+        active().splitSeries(seriesId, occurrenceStart, form)
     override fun deleteOccurrence(seriesId: Long, occurrenceStart: Instant) =
         active().deleteOccurrence(seriesId, occurrenceStart)
     override fun deleteFollowing(seriesId: Long, occurrenceStart: Instant) =
         active().deleteFollowing(seriesId, occurrenceStart)
     override fun subtasks(parentTaskId: Long): List<Task> = active().subtasks(parentTaskId)
-    override fun subtaskIds(parentTaskId: Long): List<Long> = active().subtaskIds(parentTaskId)
+    override fun insertTask(form: TaskForm): Long = active().insertTask(form)
-    override fun deleteWithSubtasks(taskId: Long) = active().deleteWithSubtasks(taskId)
+    override fun updateTask(taskId: Long, form: TaskForm) = active().updateTask(taskId, form)
-    override fun insertTask(form: TaskForm, reminders: List<TaskReminder>?): Long = active().insertTask(form, reminders)
-    override fun updateTask(taskId: Long, form: TaskForm, reminders: List<TaskReminder>?) =
-        active().updateTask(taskId, form, reminders)
 
-    override fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?) =
+    override fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm) =
-        active().updateInstance(taskId, occurrenceStart, form, reminders)
+        active().updateInstance(taskId, occurrenceStart, form)
 
+    override fun setAlarm(taskId: Long, minutesBeforeDue: Int?) = active().setAlarm(taskId, minutesBeforeDue)
+    override fun alarms(): Map<Long, TaskReminder> = active().alarms()
     override fun reminders(): Map<Long, List<TaskReminder>> = active().reminders()
     override fun setReminders(taskId: Long, reminders: List<TaskReminder>) =
         active().setReminders(taskId, reminders)

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/StoredReminders.kt

@@ -1,101 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks
-
-import de.jeanlucmakiola.agendula.data.prefs.Settings
-import de.jeanlucmakiola.agendula.data.reminders.ReminderPlanner
-import de.jeanlucmakiola.agendula.domain.Task
-import de.jeanlucmakiola.agendula.domain.TaskForm
-import de.jeanlucmakiola.agendula.domain.TaskReminder
-import java.time.ZoneId
-import kotlin.time.Instant
-
-internal object StoredReminders {
-
-    /**
-     * The reminders to store for [form], given the task as it was.
-     *
-     * A date the task gets in this write brings the list's or the app's
-     * default for it *as the task's own reminders*. The default is this
-     * device's setting, which nothing else can see; stored on the task, it
-     * travels with it to the server and fires on every client. The cost is
-     * tasks.org's: changing the default later does not reach the tasks that
-     * already have it.
-     *
-     * A task getting its first date takes the defaults only when the form
-     * names no reminder; one that already had a date takes those of the new
-     * date that no reminder of the form counts from. Otherwise the form is
-     * kept, so an edit that clears every reminder means "use the default
-     * here" as before.
-     *
-     * The form's reminders are already of its kind, timed or all-day — see
-     * [switched]. Reminders the editor [chose][TaskForm.remindersChosen] are
-     * kept as they are: it showed these defaults already.
-     */
-    fun of(form: TaskForm, current: Task?, settings: Settings, now: Long, zone: ZoneId): List<TaskReminder> {
-        val wanted = form.reminders.map { it.lead }.distinct()
-        if (form.remindersChosen) return wanted
-        return withDefaults(form, current?.start, current?.due, settings, now, zone)
-    }
-
-    /** [of] for a task whose dates were [start] and [due], whatever the form chose. */
-    fun withDefaults(
-        form: TaskForm,
-        start: Instant?,
-        due: Instant?,
-        settings: Settings,
-        now: Long,
-        zone: ZoneId,
-    ): List<TaskReminder> {
-        val wanted = form.reminders.map { it.lead }.distinct()
-        val had = anchorsOf(start, due)
-        val gained = anchorsOf(form.start, form.due) - had
-        if (gained.isEmpty()) return wanted
-        if (had.isEmpty() || wanted.isEmpty()) return wanted.ifEmpty { defaultsFor(form, settings, now, zone) }
-        val named = wanted.map { it.fromStart }.toSet()
-        return wanted + defaultsFor(form, settings, now, zone).filter { it.fromStart in gained && it.fromStart !in named }
-    }
-
-    /**
-     * [reminders] for [form] once it has switched between timed and all-day.
-     * Reminders that are exactly the old kind's default become the new kind's;
-     * the rest keep what still means something: whole days, rounded to them on
-     * an all-day task.
-     */
-    fun switched(
-        reminders: List<TaskReminder>,
-        form: TaskForm,
-        settings: Settings,
-        now: Long,
-        zone: ZoneId,
-    ): List<TaskReminder> {
-        if (reminders.isEmpty()) return reminders
-        if (reminders.toSet() == settings.defaultRemindersFor(form.listId, !form.isAllDay).toSet()) {
-            return defaultsFor(form, settings, now, zone)
-        }
-        val kept = if (form.isAllDay) {
-            reminders.map { it.inWholeDays() }
-        } else {
-            reminders.filter { it.allDay.minuteOfDay == null }
-        }
-        return kept.distinct().ifEmpty { defaultsFor(form, settings, now, zone) }
-    }
-
-    /** The dates a reminder can count from, as [TaskReminder.fromStart]. */
-    private fun anchorsOf(start: Any?, due: Any?): Set<Boolean> =
-        setOfNotNull(true.takeIf { start != null }, false.takeIf { due != null })
-
-    /**
-     * The defaults [form] takes: those counting from a date it has. A one-off
-     * task leaves out what is already past — a start of "now" would ring at once.
-     */
-    private fun defaultsFor(form: TaskForm, settings: Settings, now: Long, zone: ZoneId): List<TaskReminder> =
-        settings.defaultRemindersFor(form.listId, form.isAllDay).filter { reminder ->
-            val anchor = (if (reminder.fromStart) form.start else form.due) ?: return@filter false
-            form.rrule != null || ReminderPlanner.triggerAt(
-                anchor,
-                form.isAllDay,
-                reminder.minutesBefore,
-                settings.allDayReminderMinuteOfDay,
-                zone,
-            ) >= now
-        }
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/TaskWriteMapper.kt

@@ -113,12 +113,6 @@ object TaskWriteMapper {
         Alarm.ALARM_TYPE to Alarm.TYPE_MESSAGE,
     )
 
-    fun categoryValues(taskId: Long, name: String): Map<String, Any?> = mapOf(
-        Properties.TASK_ID to taskId,
-        Properties.MIMETYPE to TasksContract.Category.MIMETYPE,
-        TasksContract.Category.NAME to name,
-    )
-
     /** The user-owned columns of a list — what an edit is allowed to change. */
     fun listValues(name: String, color: Int): Map<String, Any?> = mapOf(
         Lists.NAME to name.trim(),

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/TasksContract.kt

@@ -86,12 +86,6 @@ object TasksContract {
 
         const val UID = "_uid"
         const val DELETED = "_deleted"
-
-        const val HAS_ALARMS = "has_alarms"
-        const val ORIGINAL_INSTANCE_ALLDAY = "original_instance_allday"
-        const val LIST_OWNER = "list_owner"
-        const val LIST_ACCESS_LEVEL = "list_access_level"
-        const val VISIBLE = "visible"
     }
 
     /**
@@ -109,7 +103,6 @@ object TasksContract {
         const val INSTANCE_DUE_SORTING = "instance_due_sorting"
         const val DISTANCE_FROM_CURRENT = "distance_from_current"
         const val IS_RECURRING = "is_recurring"
-        const val INSTANCE_DURATION = "instance_duration"
 
         /**
          * The occurrence's `RECURRENCE-ID` — the time this occurrence was
@@ -125,10 +118,6 @@ object TasksContract {
         const val PROPERTY_ID = "property_id"
         const val TASK_ID = "task_id"
         const val MIMETYPE = "mimetype"
-        const val DATA0 = "data0"
-        const val DATA1 = "data1"
-        const val DATA2 = "data2"
-        const val DATA3 = "data3"
     }
 
     /**
@@ -165,21 +154,6 @@ object TasksContract {
         const val TYPE_MESSAGE = 1
     }
 
-    /**
-     * A category property row — one tag. DAVx5 maps these to and from
-     * `CATEGORIES`. Inserting with only [NAME] is enough: the provider looks the
-     * category up in the task's account, or creates it, and fills in `data0`.
-     */
-    object Category {
-        const val MIMETYPE = "vnd.android.cursor.item/category"
-
-        /** `data1` — the tag as spelled. */
-        const val NAME = "data1"
-
-        /** `data2` — the tag's colour, if any. */
-        const val COLOR = "data2"
-    }
-
     fun propertiesUri(authority: String): Uri = "content://$authority/${Properties.PATH}".toUri()
 
     // --- status values (TaskColumns.STATUS_*) --------------------------------

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/TasksDataSource.kt

@@ -3,9 +3,26 @@ package de.jeanlucmakiola.agendula.data.tasks
 import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskForm
 import de.jeanlucmakiola.agendula.domain.TaskList
-import de.jeanlucmakiola.agendula.domain.TaskReminder
 import kotlin.time.Instant
 
+/**
+ * A stored reminder: how long before, and what it counts back from.
+ *
+ * [fromStart] matters because both stores can hold a `START`-referenced alarm —
+ * the dmfs import preserves one, and an external provider's other clients write
+ * them — while Agendula's own UI only ever sets a before-due lead. Collapsing it
+ * to a number here is what silently fired those reminders off the wrong anchor.
+ */
+data class TaskReminder(val minutesBefore: Int, val fromStart: Boolean = false)
+
+/**
+ * The one reminder Agendula's single-reminder editor shows and writes: the last
+ * before-due one, which is where a write lands, so it stays the same one across
+ * saves. Anything else a task carries — a start-relative alarm, or the extra ones
+ * another client or the dmfs import brought — is left to ride along.
+ */
+fun List<TaskReminder>.editable(): TaskReminder? = lastOrNull { !it.fromStart }
+
 /** What to fetch from the provider. Smart-list date logic is applied above this. */
 data class TaskQuery(
     val listId: Long? = null,
@@ -29,38 +46,8 @@ interface TasksDataSource {
     fun task(taskId: Long, occurrenceStart: Instant?): Task? = task(taskId)
     fun subtasks(parentTaskId: Long): List<Task>
 
-    /**
+    fun insertTask(form: TaskForm): Long
-     * The task rows directly under [parentTaskId]: one id per subtask, its series
+    fun updateTask(taskId: Long, form: TaskForm)
-     * master when it recurs, whether or not any occurrence falls in the window
-     * [subtasks] expands.
-     */
-    fun subtaskIds(parentTaskId: Long): List<Long> =
-        subtasks(parentTaskId).map { it.seriesId ?: it.taskId }.distinct().filter { it != parentTaskId }
-
-    /**
-     * Delete [taskId] and its subtasks, all the way down; left behind they would
-     * hang off a tombstone. Each task once, so a parent loop an import brought in
-     * ends instead of recursing forever.
-     */
-    fun deleteWithSubtasks(taskId: Long) {
-        val seen = HashSet<Long>()
-        fun delete(id: Long) {
-            if (!seen.add(id)) return
-            subtaskIds(id).forEach(::delete)
-            deleteTask(id)
-        }
-        delete(taskId)
-    }
-
-    /**
-     * The write paths take the task's reminders in the same write as the task
-     * itself, so a sync can never upload one without the other.
-     *
-     * Each takes the task's whole set of [reminders], before-start and
-     * before-due alike, and `null` leaves the stored ones alone.
-     */
-    fun insertTask(form: TaskForm, reminders: List<TaskReminder>? = null): Long
-    fun updateTask(taskId: Long, form: TaskForm, reminders: List<TaskReminder>? = null)
 
     /**
      * Update a single occurrence of a recurring task, addressed by the task row and
@@ -73,19 +60,27 @@ interface TasksDataSource {
      * instance row id keeps this seam independent of any one store's row
      * numbering; External mode maps it back to an instance row itself.
      */
-    fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>? = null)
+    fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm)
+    /**
+     * Set (or clear, with `null`) the task's [editable] reminder lead, stored as an
+     * Alarm property row. Every other reminder on the task is left untouched. The
+     * provider never fires it — [de.jeanlucmakiola.agendula.data.reminders
+     * .ReminderScheduler] does — but persisting it here is what syncs the lead and
+     * shares it with other OpenTasks clients.
+     */
+    fun setAlarm(taskId: Long, minutesBeforeDue: Int?)
 
     /**
      * Edit the whole series [seriesId] through its occurrence at [occurrenceStart]:
      * content from [form], and the series moved by however far that occurrence moved.
      */
-    fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>? = null)
+    fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm)
 
     /**
      * "This and following": end [seriesId] before [occurrenceStart] and continue
      * from there as a new series built from [form]. Returns the new series' id.
      */
-    fun splitSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>? = null): Long
+    fun splitSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm): Long
 
     /** Delete one generated occurrence of [seriesId] (an `EXDATE`). */
     fun deleteOccurrence(seriesId: Long, occurrenceStart: Instant)
@@ -94,15 +89,14 @@ interface TasksDataSource {
     fun deleteFollowing(seriesId: Long, occurrenceStart: Instant)
 
 
-    /** Make [taskId]'s reminders exactly [reminders]. A synced task is owed a PUT for it. */
+    /** Replace every reminder on [taskId] with [reminders], in order. */
     fun setReminders(taskId: Long, reminders: List<TaskReminder>)
 
-    /**
+    /** Every task's reminders, by task id, in stored order. One query, for the scheduler. */
-     * Every task's reminders, by task id, in stored order. One query, for the
+    fun reminders(): Map<Long, List<TaskReminder>> = alarms().mapValues { listOf(it.value) }
-     * scheduler. A task missing from the map takes the default; one present
+
-     * with an empty list has none (see `TaskEntity.remindersOff`).
+    /** Every task's [editable] reminder, by task id. */
-     */
+    fun alarms(): Map<Long, TaskReminder>
-    fun reminders(): Map<Long, List<TaskReminder>>
 
     /**
      * Every task in [listId] read from the **`tasks` table**, for export. Masters,

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/TasksRepository.kt

@@ -1,7 +1,5 @@
 package de.jeanlucmakiola.agendula.data.tasks
 
-import de.jeanlucmakiola.agendula.domain.TaskReminder
-import de.jeanlucmakiola.agendula.domain.SavedFilter
 import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskDetail
 import de.jeanlucmakiola.agendula.domain.TaskFilter
@@ -15,9 +13,6 @@ import kotlin.time.Instant
 /** Whether Agendula can use the tasks provider right now. Drives onboarding. */
 enum class ProviderStatus { READY, NEEDS_PERMISSION, NO_PROVIDER }
 
-/** Tasks for a filter; [savedFilter] is a saved filter's definition, `null` once it's deleted. */
-data class FilteredTasks(val tasks: List<Task>, val savedFilter: SavedFilter? = null)
-
 /**
  * The single entry point the UI layer uses. Flows re-emit automatically when the
  * provider changes (our writes *and* external sync like DAVx5), via the
@@ -32,10 +27,7 @@ interface TasksRepository {
      */
     fun writableTaskLists(): Flow<List<TaskList>> =
         taskLists().map { lists -> lists.filter { it.acceptsWrites } }
-    fun tasks(filter: TaskFilter): Flow<List<Task>> = filteredTasks(filter).map { it.tasks }
+    fun tasks(filter: TaskFilter): Flow<List<Task>>
-
-    /** [tasks] together with the definition behind a [TaskFilter.Saved]. */
-    fun filteredTasks(filter: TaskFilter): Flow<FilteredTasks>
 
     /**
      * The direct children of [parentId], re-emitting live like the other flows.
@@ -83,6 +75,13 @@ interface TasksRepository {
         scope: RecurringScope = RecurringScope.AllOccurrences,
     )
 
+    /**
+     * The per-task reminder lead in minutes before due, or `null` if the task has
+     * none (in which case the list's / global setting applies). Read when the edit
+     * form loads so saving can't silently drop it.
+     */
+    suspend fun reminderFor(taskId: Long): Int?
+
     /** Every reminder stored on the task, in order — including start-relative ones. */
     suspend fun remindersFor(taskId: Long): List<TaskReminder>
 

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/TasksRepositoryImpl.kt

@@ -1,10 +1,7 @@
 package de.jeanlucmakiola.agendula.data.tasks
 
-import de.jeanlucmakiola.agendula.domain.TaskReminder
 import de.jeanlucmakiola.agendula.data.di.IoDispatcher
-import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.floret.time.DayWindow
-import de.jeanlucmakiola.agendula.domain.SavedFilter
 import de.jeanlucmakiola.agendula.domain.SeriesCollapse
 import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskDetail
@@ -20,11 +17,7 @@ import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.channels.consumeEach
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.callbackFlow
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -39,26 +32,12 @@ class TasksRepositoryImpl @Inject constructor(
     private val dataSource: TasksDataSource,
     private val providerResolver: ProviderResolver,
     private val startupGate: StartupGate,
-    private val settingsPrefs: SettingsPrefs,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : TasksRepository {
 
     override fun taskLists(): Flow<List<TaskList>> = observing { dataSource.taskLists() }
 
-    @OptIn(ExperimentalCoroutinesApi::class)
+    override fun tasks(filter: TaskFilter): Flow<List<Task>> = observing { loadTasks(filter) }
-    override fun filteredTasks(filter: TaskFilter): Flow<FilteredTasks> = when (filter) {
-        // A deleted filter shows nothing rather than failing the screen or widget on it.
-        is TaskFilter.Saved -> settingsPrefs.savedFilter(filter.id)
-            .flatMapLatest { saved ->
-                if (saved == null) flowOf(FilteredTasks(emptyList()))
-                else observing {
-                    // A deleted list's id would otherwise leave the filter quietly empty.
-                    val current = saved.withListsIn(dataSource.taskLists().mapTo(HashSet()) { it.id })
-                    FilteredTasks(loadTasks(filter, current), current)
-                }
-            }
-        else -> observing { FilteredTasks(loadTasks(filter)) }
-    }
 
     override fun subtasks(parentId: Long): Flow<List<Task>> = observing {
         SeriesCollapse.visible(dataSource.subtasks(parentId))
@@ -76,7 +55,7 @@ class TasksRepositoryImpl @Inject constructor(
         }
     }
 
-    private fun loadTasks(filter: TaskFilter, saved: SavedFilter? = null): List<Task> {
+    private fun loadTasks(filter: TaskFilter): List<Task> {
         val query = when (filter) {
             is TaskFilter.OfList -> TaskQuery(listId = filter.listId, includeCompleted = true)
             // Read completed tasks too, then let [TaskFiltering.matches] enforce each
@@ -87,8 +66,6 @@ class TasksRepositoryImpl @Inject constructor(
             // Same over-read as Smart: TaskQuery.listId only narrows to one list, so
             // several lists are read in full and membership is filtered in-memory.
             is TaskFilter.OfLists -> TaskQuery(includeCompleted = true)
-            is TaskFilter.Tagged -> TaskQuery(includeCompleted = true)
-            is TaskFilter.Saved -> TaskQuery(includeCompleted = true)
         }
         val (todayStart, todayEnd) = DayWindow.today(Clock.System.now(), ZoneId.systemDefault())
         val all = SeriesCollapse.visible(dataSource.tasks(query))
@@ -100,7 +77,7 @@ class TasksRepositoryImpl @Inject constructor(
                 (if (t.isCompleted) done + 1 else done) to (total + 1)
             }
         return all
-            .filter { TaskFiltering.matches(it, filter, todayStart, todayEnd, saved) }
+            .filter { TaskFiltering.matches(it, filter, todayStart, todayEnd) }
             .map { task ->
                 progress[task.taskId]?.let { (done, total) ->
                     task.copy(subtaskDone = done, subtaskTotal = total)
@@ -111,18 +88,11 @@ class TasksRepositoryImpl @Inject constructor(
 
     override suspend fun createTask(form: TaskForm): Long =
         withContext(io) {
-            dataSource.insertTask(form, storedRemindersFor(form, current = null))
+            val id = dataSource.insertTask(form)
+            writeReminders(id, form)
+            id
         }
 
-    private suspend fun storedRemindersFor(form: TaskForm, current: Task?): List<TaskReminder> =
-        StoredReminders.of(
-            form,
-            current,
-            settingsPrefs.settings.first(),
-            Clock.System.now().toEpochMilliseconds(),
-            ZoneId.systemDefault(),
-        )
-
     override suspend fun duplicateTask(taskId: Long, occurrenceStart: Instant?): Long =
         withContext(io) {
             val task = checkNotNull(dataSource.task(taskId, occurrenceStart)) { "Task $taskId is gone" }
@@ -130,9 +100,6 @@ class TasksRepositoryImpl @Inject constructor(
         }
 
     private fun copyOf(task: Task, parentId: Long?, depth: Int): Long {
-        // In the same write as the copy: inserted first and given its reminders
-        // after, a sync landing in between uploads the copy without them.
-        val reminders = dataSource.reminders()[task.taskId].orEmpty().map { it.lead }
         val id = dataSource.insertTask(
             TaskForm(
                 title = task.title,
@@ -145,10 +112,10 @@ class TasksRepositoryImpl @Inject constructor(
                 parentId = parentId,
                 location = task.location,
                 url = task.url,
-                tags = task.tags,
             ),
-            reminders,
         )
+        val reminders = dataSource.reminders()[task.taskId].orEmpty()
+        if (reminders.isNotEmpty()) dataSource.setReminders(id, reminders)
         if (depth < MAX_COPY_DEPTH) {
             SeriesCollapse.visible(dataSource.subtasks(task.taskId))
                 .filter { it.taskId != task.taskId && it.status != TaskStatus.CANCELLED }
@@ -157,6 +124,9 @@ class TasksRepositoryImpl @Inject constructor(
         return id
     }
 
+    override suspend fun reminderFor(taskId: Long): Int? =
+        withContext(io) { runCatching { dataSource.alarms()[taskId]?.minutesBefore }.getOrNull() }
+
     override suspend fun remindersFor(taskId: Long): List<TaskReminder> =
         withContext(io) { runCatching { dataSource.reminders()[taskId].orEmpty() }.getOrDefault(emptyList()) }
 
@@ -180,17 +150,18 @@ class TasksRepositoryImpl @Inject constructor(
             val seen = current?.lastModified
             if (seen != null && seen != expectedLastModified) throw TaskConflictException(taskId)
         }
-        val reminders = storedRemindersFor(form, current)
         val seriesId = current?.seriesId
         val occurrence = current?.occurrenceStart
         if (seriesId != null && occurrence != null) {
             when (scope) {
                 RecurringScope.AllOccurrences -> {
-                    dataSource.updateSeries(seriesId, occurrence, form, reminders)
+                    writeReminders(seriesId, form)
+                    dataSource.updateSeries(seriesId, occurrence, form)
                     return@withContext
                 }
                 RecurringScope.ThisAndFollowing -> {
-                    dataSource.splitSeries(seriesId, occurrence, form, reminders)
+                    val created = dataSource.splitSeries(seriesId, occurrence, form)
+                    writeReminders(created, form)
                     return@withContext
                 }
                 RecurringScope.ThisOccurrence -> Unit
@@ -198,11 +169,31 @@ class TasksRepositoryImpl @Inject constructor(
         }
         // A recurring task's start/due are one occurrence's resolved times, so
         // writing them back to the task row would re-anchor the whole series.
-        // Going through the occurrence forks an override instead, which takes
+        // Going through the occurrence forks an override instead.
-        // the reminders on its own row and leaves the series' alone.
         val instance = current?.takeIf { it.isRecurring }?.occurrenceStart
-        if (instance == null) dataSource.updateTask(taskId, form, reminders)
+        if (instance == null) {
-        else dataSource.updateInstance(taskId, instance, form, reminders)
+            writeReminders(taskId, form)
+            dataSource.updateTask(taskId, form)
+            return@withContext
+        }
+        // ⚠️ Written to the series, and then put back. Forking an occurrence
+        // copies the task's *current* properties onto the new override row,
+        // so setting the alarm beforehand is the only way to carry it
+        // across — and leaving it there would silently give every other
+        // occurrence in the series the reminder the user set on one of them.
+        val seriesReminders = dataSource.reminders()[taskId].orEmpty()
+        writeReminders(taskId, form)
+        try {
+            dataSource.updateInstance(taskId, instance, form)
+        } finally {
+            dataSource.setReminders(taskId, seriesReminders)
+        }
+    }
+
+    /** The form's before-due reminders; a start-relative one from elsewhere is kept as it was. */
+    private fun writeReminders(taskId: Long, form: TaskForm) {
+        val kept = dataSource.reminders()[taskId].orEmpty().filter { it.fromStart }
+        dataSource.setReminders(taskId, kept + form.reminders.distinct().sorted().map { TaskReminder(it) })
     }
 
     override suspend fun setCancelled(taskId: Long, occurrenceStart: Instant?, cancelled: Boolean) =
@@ -235,7 +226,7 @@ class TasksRepositoryImpl @Inject constructor(
             val current = dataSource.task(taskId, occurrenceStart)
             val seriesId = current?.seriesId
             val occurrence = current?.occurrenceStart
-            if (seriesId == null || occurrence == null) return@withContext dataSource.deleteWithSubtasks(taskId)
+            if (seriesId == null || occurrence == null) return@withContext deleteWithSubtasks(taskId)
             when (scope) {
                 RecurringScope.ThisOccurrence ->
                     // An override row deletes itself into an EXDATE; a generated
@@ -243,10 +234,18 @@ class TasksRepositoryImpl @Inject constructor(
                     if (current.taskId != seriesId) dataSource.deleteTask(current.taskId)
                     else dataSource.deleteOccurrence(seriesId, occurrence)
                 RecurringScope.ThisAndFollowing -> dataSource.deleteFollowing(seriesId, occurrence)
-                RecurringScope.AllOccurrences -> dataSource.deleteWithSubtasks(seriesId)
+                RecurringScope.AllOccurrences -> deleteWithSubtasks(seriesId)
             }
         }
 
+    /** A parent goes with its subtasks; left behind they would hang off a tombstone. */
+    private fun deleteWithSubtasks(taskId: Long) {
+        dataSource.subtasks(taskId).map { it.taskId }.distinct()
+            .filter { it != taskId }
+            .forEach { dataSource.deleteTask(it) }
+        dataSource.deleteTask(taskId)
+    }
+
     override suspend fun createLocalList(name: String, color: Int): Long =
         withContext(io) { dataSource.createLocalList(name, color) }
 

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/ical/AlarmCodec.kt

@@ -1,228 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.ical
-
-import de.jeanlucmakiola.agendula.data.reminders.ReminderPlanner
-import de.jeanlucmakiola.agendula.data.tasks.room.AlarmReference
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
-import de.jeanlucmakiola.agendula.domain.ical.ICalComponent
-import de.jeanlucmakiola.agendula.domain.ical.ICalParam
-import de.jeanlucmakiola.agendula.domain.ical.ICalParser
-import de.jeanlucmakiola.agendula.domain.ical.ICalProperty
-import de.jeanlucmakiola.agendula.domain.ical.ICalSerializer
-import de.jeanlucmakiola.agendula.domain.ical.ICalValues
-import de.jeanlucmakiola.agendula.domain.DAY_MINUTES
-import de.jeanlucmakiola.agendula.domain.MIN_ALL_DAY_LEAD
-import kotlin.math.roundToLong
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.Duration.Companion.seconds
-import kotlin.time.Instant
-
-/**
- * `VALARM` ↔ [TaskAlarmEntity].
- *
- * ## What is claimed
- *
- * Only an alarm Agendula can fire exactly as written becomes a reminder row.
- * Everything else stays in the task's residue and round-trips untouched — it
- * still fires in the client that wrote it, just not here:
- *
- * - `ACTION` other than `DISPLAY`/`AUDIO`;
- * - Apple's default alarms (`X-APPLE-DEFAULT-ALARM:TRUE`). They are that Mac's
- *   preference, not task data: claimed, they would come back to the Mac as an
- *   explicit alarm without the flag after the first edit here;
- * - location alarms (`X-APPLE-PROXIMITY`, RFC 9074 `PROXIMITY`, a nested
- *   component) and Apple's `19760401T005545Z` sentinel trigger they carry;
- * - repeating alarms (`REPEAT`/`DURATION`) and RFC 9074 snoozes (`RELATED-TO`);
- * - a trigger *after* its anchor — on an all-day task, after the end of its
- *   day. The planner coerces a negative lead to 0, so it would fire at the
- *   wrong time;
- * - an absolute trigger on a recurring task, or on one with no `DUE` to count
- *   back from.
- *
- * ## What "unchanged" means
- *
- * A claimed row keeps the `VALARM` it was read from in [TaskAlarmEntity.raw].
- * On write, the row is "unchanged" when that original still [resolve]s to the
- * row's lead against the task *as it is now* — so `-PT15M` and `-P0DT0H15M0S`
- * are the same, a relative alarm survives a due-date edit, and an absolute one
- * stops matching once `DUE` moves. An unchanged row is re-emitted verbatim; a
- * changed one is authored fresh under its existing uid.
- *
- * ## Anchors
- *
- * `RELATED=END` counts from `DUE`. `RELATED=START` (the default) counts from
- * `DTSTART` — except when `DTSTART` equals `DUE`, or when there is no
- * `DTSTART` but there is a `DUE`. Apple writes the latter shape (against §3.8.6.3,
- * which wants `DTSTART` present).
- *
- * ## All-day tasks
- *
- * A relative trigger counts from the date's midnight, so the lead is the
- * reminder as [de.jeanlucmakiola.agendula.domain.TaskReminder.allDay] reads it:
- * `-P1D` is a day before at this device's all-day time, which this mapper cannot
- * see, and `PT9H` is 09:00 on the day. An absolute trigger has no zone to read
- * a time of day in, so it rounds to the nearest whole day.
- */
-object AlarmCodec {
-
-    /** Apple's placeholder trigger for location alarms. Never a real time. */
-    private const val APPLE_SENTINEL = "19760401T005545Z"
-
-    /** What a `VALARM` means to the scheduler. */
-    data class Lead(val minutesBefore: Int, val reference: AlarmReference)
-
-    /** A `VALARM` as a reminder row — `taskId` is the caller's — or null if it is not ours to claim. */
-    fun fromVAlarm(alarm: ICalComponent, task: TaskEntity): TaskAlarmEntity? {
-        val lead = resolve(alarm, task) ?: return null
-        val raw = ICalSerializer.serialize(alarm)
-        // Too large to keep verbatim means it could not be re-emitted, and an
-        // alarm that is authored fresh on every write loses what made it large.
-        if (raw.toByteArray(Charsets.UTF_8).size > VTodoMapper.MAX_RESIDUE_BYTES) return null
-        val uid = (alarm.property("X-WR-ALARMUID") ?: alarm.property("UID"))?.value?.trim()?.takeIf { it.isNotEmpty() }
-        val base = TaskAlarmEntity(
-            taskId = 0,
-            minutesBefore = lead.minutesBefore,
-            reference = lead.reference,
-            raw = raw,
-        )
-        return if (uid == null) base else base.copy(uid = uid)
-    }
-
-    /** The lead [alarm] stands for on [task], or null when it is not claimable. */
-    fun resolve(alarm: ICalComponent, task: TaskEntity): Lead? {
-        val action = alarm.property("ACTION")?.value?.trim()?.uppercase()
-        if (action != "DISPLAY" && action != "AUDIO") return null
-        if (alarm.property("X-APPLE-DEFAULT-ALARM")?.value?.trim().equals("TRUE", ignoreCase = true)) return null
-        val excluded = listOf("X-APPLE-PROXIMITY", "PROXIMITY", "REPEAT", "DURATION", "RELATED-TO")
-        if (excluded.any { alarm.property(it) != null }) return null
-        if (alarm.components.isNotEmpty()) return null
-
-        val trigger = alarm.properties("TRIGGER").singleOrNull() ?: return null
-        val value = trigger.value.trim()
-        if (value.startsWith(APPLE_SENTINEL)) return null
-
-        val absolute = trigger.param("VALUE").equals("DATE-TIME", ignoreCase = true) ||
-            (!value.startsWith("P", ignoreCase = true) && !value.startsWith("-") && !value.startsWith("+"))
-        return if (absolute) absoluteLead(trigger, task) else relativeLead(trigger, task)
-    }
-
-    private fun relativeLead(trigger: ICalProperty, task: TaskEntity): Lead? {
-        val seconds = ICalValues.parseDuration(trigger.value) ?: return null
-        val reference = when {
-            trigger.param("RELATED").equals("END", ignoreCase = true) ->
-                if (task.due != null) AlarmReference.DUE else return null
-            task.dtstart != null && task.dtstart != task.due -> AlarmReference.START
-            task.due != null -> AlarmReference.DUE
-            else -> return null
-        }
-        val before = -seconds
-        // A lead in seconds is not one the planner can reproduce.
-        if (before % 60 != 0L) return null
-        val minutes = before / 60
-        val latest = if (task.isAllDay) MIN_ALL_DAY_LEAD.toLong() else 0L
-        return minutes.takeIf { it in latest..Int.MAX_VALUE }?.let { Lead(it.toInt(), reference) }
-    }
-
-    private fun absoluteLead(trigger: ICalProperty, task: TaskEntity): Lead? {
-        if (task.rrule != null || task.rdate != null) return null
-        val due = task.due ?: return null
-        val at = (ICalValues.parseTime(trigger) as? ICalValues.TimeValue.Timed)
-            ?.takeIf { it.tzid == null } // §3.8.6.3: an absolute trigger MUST be UTC
-            ?.instant ?: return null
-        val before = (due - at).inWholeSeconds
-        val minutes = if (task.isAllDay) {
-            // An all-day DUE is stored as UTC midnight of its date, which is
-            // the calendar date the trigger counts back from.
-            roundToDays(before)
-        } else {
-            Math.floorDiv(before, 60L)
-        }
-        return minutes.toIntOrNull()?.let { Lead(it, AlarmReference.DUE) }
-    }
-
-    /**
-     * [read] as builds before 1.2 stored it on an all-day task: rounded to whole
-     * days. Such a row keeps the other client's time of day instead of overwriting it.
-     */
-    private fun readAsWholeDays(read: Lead, task: TaskEntity): Lead? =
-        if (task.isAllDay && read.minutesBefore % DAY_MINUTES != 0) {
-            read.copy(minutesBefore = roundToDays(read.minutesBefore * 60L).coerceAtLeast(0).toInt())
-        } else {
-            null
-        }
-
-    /** Nearest whole day, in minutes. */
-    private fun roundToDays(seconds: Long): Long =
-        (seconds / 86_400.0).roundToLong() * DAY_MINUTES
-
-    /** Negative is after the anchor, which is not claimed. */
-    private fun Long.toIntOrNull(): Int? = takeIf { it in 0..Int.MAX_VALUE }?.toInt()
-
-    /**
-     * [row] as a `VALARM` on [task], or null when it cannot be written: its
-     * anchor is missing. That row stays on the device — the planner ignores it
-     * too — because `RELATED=END` without `DUE` is a resource the server
-     * refuses ([VTodoMapper.validate]).
-     *
-     * ⚠️ A row whose anchor the task has lost is written against the other
-     * date, which is what the planner fires it from. Leaving it out would drop
-     * it from every other client, and the next download would then take it off
-     * this device too.
-     *
-     * [now] marks an authored alarm `ACKNOWLEDGED` once it is past even the
-     * planner's missed-reminder grace, so a client that honours RFC 9074 does
-     * not greet it as a missed alarm. Not sooner: the stamp comes back on the
-     * next download and would silence the late reminder this device still owes.
-     */
-    fun toVAlarm(row: TaskAlarmEntity, task: TaskEntity, now: Instant): ICalComponent? {
-        val reference = when {
-            row.reference == AlarmReference.START && task.dtstart == null -> AlarmReference.DUE
-            row.reference == AlarmReference.DUE && task.due == null -> AlarmReference.START
-            else -> row.reference
-        }
-        val lead = Lead(row.minutesBefore, reference)
-        row.raw?.let(::parse)?.let { original ->
-            val read = resolve(original, task)
-            if (read == lead || read != null && readAsWholeDays(read, task) == lead) return original
-        }
-
-        val anchor = when (reference) {
-            AlarmReference.DUE -> task.due
-            AlarmReference.START -> task.dtstart
-        } ?: return null
-        val related = if (reference == AlarmReference.DUE) "END" else "START"
-        val minutes = row.minutesBefore.coerceAtLeast(if (task.isAllDay) MIN_ALL_DAY_LEAD else 0).toLong()
-        val seconds = -minutes * 60
-
-        val properties = mutableListOf(
-            ICalProperty("UID", value = row.uid),
-            ICalProperty("X-WR-ALARMUID", value = row.uid),
-            ICalProperty("ACTION", value = "DISPLAY"),
-            ICalProperty("DESCRIPTION", value = ICalValues.escapeText(row.message ?: "Reminder")),
-            ICalProperty("TRIGGER", listOf(ICalParam("RELATED", related)), ICalValues.formatDuration(seconds)),
-        )
-        val recurring = task.rrule != null || task.rdate != null
-        if (!recurring && anchor + seconds.seconds + ReminderPlanner.MISSED_GRACE_MS.milliseconds < now) {
-            properties += ICalProperty("ACKNOWLEDGED", value = ICalValues.formatDateTime(now, null))
-        }
-        return ICalComponent("VALARM", properties)
-    }
-
-    /**
-     * What [row] reads back as once it has been to the server and back — not
-     * always the row itself, because the wire is coarser: a lead past the end
-     * of its anchor is clamped, and a before-start row on a task without a
-     * start goes out before-due. A download that brings back exactly this has not changed the
-     * reminder, and the row's own lead must be kept rather than taken from it.
-     *
-     * ⚠️ As authored from the row, not re-emitted from [TaskAlarmEntity.raw]:
-     * a row rounded to whole days before 1.2 re-emits a time of day it does
-     * not hold, and would keep its rounded lead against the very alarm that
-     * carries it.
-     */
-    fun wireLead(row: TaskAlarmEntity, task: TaskEntity): Lead? =
-        toVAlarm(row.copy(raw = null), task, Instant.DISTANT_PAST)?.let { resolve(it, task) }
-
-    private fun parse(raw: String): ICalComponent? =
-        runCatching { ICalParser.parse(raw) }.getOrNull()?.takeIf { it.name.equals("VALARM", ignoreCase = true) }
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/ical/VTodoMapper.kt

@@ -1,6 +1,5 @@
 package de.jeanlucmakiola.agendula.data.tasks.ical
 
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
 import de.jeanlucmakiola.agendula.domain.PRIORITY_NONE
 import de.jeanlucmakiola.agendula.domain.TaskStatus
@@ -10,7 +9,6 @@ import de.jeanlucmakiola.agendula.domain.ical.ICalParser
 import de.jeanlucmakiola.agendula.domain.ical.ICalProperty
 import de.jeanlucmakiola.agendula.domain.ical.ICalSerializer
 import de.jeanlucmakiola.agendula.domain.ical.ICalValues
-import de.jeanlucmakiola.agendula.domain.normalizeTags
 import java.time.ZoneId
 import kotlin.time.Clock
 import kotlin.time.Instant
@@ -53,11 +51,10 @@ import kotlin.time.Instant
  *
  * ## Alarms
  *
- * A `VALARM` [AlarmCodec] can fire exactly as written is claimed into
+ * `VALARM`s round-trip in the residue and are never authored here. Local
- * [Mapped.alarms] — rows for `task_alarms`, carrying the original verbatim —
+ * reminders live in `task_alarms` and are never serialised. The two stores are
- * and [write] authors the task's rows back. Any other `VALARM` (Apple's default
+ * disjoint, so neither can destroy the other. Merging them is a later
- * and location alarms, repeating ones, snoozes) stays in the residue and is
+ * decision, not a silent one.
- * re-emitted untouched after the authored ones.
  */
 object VTodoMapper {
 
@@ -84,8 +81,6 @@ object VTodoMapper {
         // Parameterised copies stay in the residue verbatim; authoring the
         // column beside them would emit the same exclusions twice.
         "RDATE", "EXDATE",
-        // Several lines, or one the column would not re-serialise exactly.
-        "CATEGORIES",
     )
 
     /** What a VTODO yields. Row identity ([TaskEntity.id], `listId`) is the caller's. */
@@ -97,8 +92,6 @@ object VTodoMapper {
         val uidWasMissing: Boolean,
         /** Residue that exceeded [MAX_RESIDUE_BYTES] and had to be dropped. */
         val droppedResidue: Boolean,
-        /** The claimed `VALARM`s, `taskId` unset. Not counted against the residue cap. */
-        val alarms: List<TaskAlarmEntity> = emptyList(),
     )
 
     // ---------------------------------------------------------------- read
@@ -207,9 +200,6 @@ object VTodoMapper {
             CLASS_NAMES.indexOf(classProperty?.value?.trim()?.uppercase()).takeIf { it >= 0 },
         )
 
-        val (categories, categoriesProperty) = readCategories(vtodo)
-        claim(categoriesProperty)
-
         val sequenceProperty = vtodo.property("SEQUENCE")
         val sequence = take(
             sequenceProperty,
@@ -235,7 +225,6 @@ object VTodoMapper {
             title = take(vtodo.property("SUMMARY"), vtodo.property("SUMMARY")?.text()),
             description = take(vtodo.property("DESCRIPTION"), vtodo.property("DESCRIPTION")?.text()),
             location = take(vtodo.property("LOCATION"), vtodo.property("LOCATION")?.text()),
-            categories = categories,
             // URI, not TEXT — escaping it would corrupt a query string.
             url = take(vtodo.property("URL"), vtodo.property("URL")?.value?.trim()),
             status = status,
@@ -267,18 +256,8 @@ object VTodoMapper {
             .filterIndexed { index, _ -> index !in claimed }
             .filterNot { it.name.equals("DTSTAMP", ignoreCase = true) }
 
-        // Claimed against the entity as read, so the anchors are the ones the
-        // rows will be written back against.
-        val alarms = mutableListOf<TaskAlarmEntity>()
-        val residueComponents = vtodo.components.filter { component ->
-            if (!component.name.equals("VALARM", ignoreCase = true)) return@filter true
-            val row = AlarmCodec.fromVAlarm(component, entity) ?: return@filter true
-            alarms += row
-            false
-        }
-
         val residueText = ICalSerializer.serializeProperties(residueProperties) +
-            ICalSerializer.serializeAll(residueComponents)
+            ICalSerializer.serializeAll(vtodo.components)
         val tooLarge = residueText.toByteArray(Charsets.UTF_8).size > MAX_RESIDUE_BYTES
 
         return Mapped(
@@ -288,7 +267,6 @@ object VTodoMapper {
             parentUid = parentUid,
             uidWasMissing = uid.isEmpty(),
             droppedResidue = tooLarge,
-            alarms = alarms,
         )
     }
 
@@ -298,19 +276,16 @@ object VTodoMapper {
      * Serialises [entity] back to a VTODO.
      *
      * [parentUid] is the parent's `UID`, which the entity holds only as a row id.
-     * [now] is the `DTSTAMP`. [alarms] are the task's reminder rows; one whose
+     * [now] is the `DTSTAMP`.
-     * anchor the task no longer has is left out (see [AlarmCodec.toVAlarm]).
      */
     fun write(
         entity: TaskEntity,
         parentUid: String? = null,
         now: Instant = Clock.System.now(),
-        alarms: List<TaskAlarmEntity> = emptyList(),
     ): ICalComponent {
         val residue = parseResidue(entity.unknownProperties)
-        val residueCategories = normalizeTags(residue.properties("CATEGORIES").flatMap(::categoryValues))
         val keptResidue =
-            residue.properties.filterNot { contradictsResidue(it, residue, residueCategories, entity, parentUid) }
+            residue.properties.filterNot { contradictsResidue(it, residue, entity, parentUid) }
         val suppressed = keptResidue
             .map { it.name.uppercase() }
             .filterTo(mutableSetOf()) { it in SUPPRESSED_BY_RESIDUE }
@@ -332,7 +307,6 @@ object VTodoMapper {
         add("DESCRIPTION", entity.description?.let(ICalValues::escapeText))
         add("LOCATION", entity.location?.let(ICalValues::escapeText))
         add("URL", entity.url)
-        add("CATEGORIES", normalizeTags(entity.categories).takeIf { it.isNotEmpty() }?.let(ICalValues::formatTextList))
 
         add("STATUS", entity.status.toICalName())
         add("PERCENT-COMPLETE", entity.percentComplete?.toString())
@@ -366,7 +340,7 @@ object VTodoMapper {
         return ICalComponent(
             name = "VTODO",
             properties = properties + keptResidue,
-            components = alarms.mapNotNull { AlarmCodec.toVAlarm(it, entity, now) } + residue.components,
+            components = residue.components,
         )
     }
 
@@ -412,7 +386,6 @@ object VTodoMapper {
     private fun contradictsResidue(
         property: ICalProperty,
         residue: ICalComponent,
-        residueCategories: List<String>,
         entity: TaskEntity,
         parentUid: String?,
     ): Boolean {
@@ -460,7 +433,6 @@ object VTodoMapper {
             "PRIORITY" -> entity.priority != PRIORITY_NONE
             "PERCENT-COMPLETE" -> entity.percentComplete != null
             "CLASS" -> entity.classification != null
-            "CATEGORIES" -> entity.categories != residueCategories
             // Not SEQUENCE: it is the organiser's counter and never ours to bump,
             // so the column stays at its fallback and the residue always wins.
             else -> false
@@ -503,23 +475,6 @@ object VTodoMapper {
 
     // -------------------------------------------------------------- helpers
 
-    /**
-     * Every `CATEGORIES` copy's values, merged, and the one line to claim — only
-     * when it is the sole, parameterless copy and the column re-serialises it
-     * byte for byte. Anything else is read for display and stays in the residue.
-     */
-    private fun readCategories(vtodo: ICalComponent): Pair<List<String>, ICalProperty?> {
-        val copies = vtodo.properties("CATEGORIES")
-        val values = normalizeTags(copies.flatMap(::categoryValues))
-        val claimable = copies.singleOrNull()?.takeIf {
-            it.params.isEmpty() && values.isNotEmpty() && ICalValues.formatTextList(values) == it.value
-        }
-        return values to claimable
-    }
-
-    private fun categoryValues(property: ICalProperty): List<String> =
-        normalizeTags(ICalValues.parseTextList(property.value))
-
     private val CLASS_NAMES = listOf("PUBLIC", "PRIVATE", "CONFIDENTIAL")
 
     private class TimeRead(

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/legacy/OneShotImport.kt

@@ -15,7 +15,6 @@ import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TaskListEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
 import de.jeanlucmakiola.agendula.domain.PRIORITY_NONE
-import de.jeanlucmakiola.agendula.domain.normalizeTags
 import de.jeanlucmakiola.agendula.domain.statusFromInt
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
@@ -222,17 +221,12 @@ class OneShotImport @Inject constructor(
             }
 
         val alarms = mutableListOf<LegacyAlarm>()
-        val categories = mutableMapOf<Long, MutableList<String>>()
+        db.rawQuery("SELECT task_id, mimetype, data0, data1, data2 FROM Properties", null)
-        db.rawQuery("SELECT task_id, mimetype, data0, data1, data2 FROM Properties ORDER BY property_id", null)
             .use { cursor ->
                 val r = CursorColumnReader(cursor)
                 while (cursor.moveToNext()) {
-                    val taskId = r.getLong("task_id") ?: continue
-                    if (r.getString("mimetype") == CATEGORY_MIMETYPE) {
-                        r.getString("data1")?.let { categories.getOrPut(taskId, ::mutableListOf) += it }
-                        continue
-                    }
                     if (r.getString("mimetype") != ALARM_MIMETYPE) continue
+                    val taskId = r.getLong("task_id") ?: continue
                     val minutes = r.getString("data0")?.trim()?.toIntOrNull() ?: continue
                     alarms += LegacyAlarm(
                         taskId = taskId,
@@ -247,7 +241,7 @@ class OneShotImport @Inject constructor(
                 }
             }
 
-        return LegacySnapshot(lists, rows, alarms, categories.mapValues { normalizeTags(it.value) })
+        return LegacySnapshot(lists, rows, alarms)
     }
 
     // --- writing into Room ----------------------------------------------------
@@ -282,12 +276,7 @@ class OneShotImport @Inject constructor(
             // the unique index; a fresh uid costs the row nothing it still has.
             val uid = row.entity.uid.takeIf { seen.add(Triple(listId, it, recurrenceId)) }
                 ?: UUID.randomUUID().toString()
-            val entity = row.entity.copy(
+            val entity = row.entity.copy(listId = listId, uid = uid, recurrenceId = recurrenceId)
-                listId = listId,
-                uid = uid,
-                recurrenceId = recurrenceId,
-                categories = snapshot.categories[row.id].orEmpty(),
-            )
             val newId = taskDao.insert(entity)
             taskIds[row.id] = newId
             inserted += row to entity.copy(id = newId)
@@ -390,7 +379,6 @@ class OneShotImport @Inject constructor(
         const val ARCHIVE_NAME = "tasks.db.imported"
 
         private const val ALARM_MIMETYPE = "vnd.android.cursor.item/alarm"
-        private const val CATEGORY_MIMETYPE = "vnd.android.cursor.item/category"
         private const val REFERENCE_START = "2"
         private val SIDECARS = listOf("-journal", "-wal", "-shm")
         private val IMPORT_DONE = booleanPreferencesKey("legacy_import_done")
@@ -403,8 +391,6 @@ private class LegacySnapshot(
     val lists: List<LegacyList>,
     val tasks: List<LegacyTaskRow>,
     val alarms: List<LegacyAlarm>,
-    /** Tags by legacy task `_id`. */
-    val categories: Map<Long, List<String>>,
 )
 
 private class LegacyList(val id: Long, val entity: TaskListEntity)

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/provider/AgendulaTaskProvider.kt

@@ -1,99 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import android.content.ContentProvider
-import android.content.ContentProviderOperation
-import android.content.ContentProviderResult
-import android.content.ContentUris
-import android.content.ContentValues
-import android.content.UriMatcher
-import android.database.Cursor
-import android.net.Uri
-import dagger.hilt.EntryPoint
-import dagger.hilt.InstallIn
-import dagger.hilt.android.EntryPointAccessors
-import dagger.hilt.components.SingletonComponent
-
-/**
- * Agendula's own store, published under the OpenTasks contract (`tasklists`,
- * `tasks`, `instances`, `properties`) at `<applicationId>.tasks`, so an app that
- * already works with OpenTasks or tasks.org works with Agendula by swapping the
- * authority. Reads are guarded by `<applicationId>.permission.READ_TASKS`, writes
- * by `<applicationId>.permission.WRITE_TASKS`; [ProviderWriter] applies them. See
- * `docs/CONTENT_PROVIDER.md`.
- */
-class AgendulaTaskProvider : ContentProvider() {
-
-    @EntryPoint
-    @InstallIn(SingletonComponent::class)
-    interface ProviderEntryPoint {
-        fun snapshotSource(): ProviderSnapshotSource
-        fun writer(): ProviderWriter
-    }
-
-    private val entryPoint by lazy {
-        EntryPointAccessors.fromApplication(requireNotNull(context), ProviderEntryPoint::class.java)
-    }
-    private val source: ProviderSnapshotSource by lazy { entryPoint.snapshotSource() }
-    private val writer: ProviderWriter by lazy { entryPoint.writer() }
-
-    private val matcher by lazy {
-        UriMatcher(UriMatcher.NO_MATCH).apply {
-            ProviderTable.entries.forEach { table ->
-                addURI(source.authority, table.path, table.ordinal * 2)
-                addURI(source.authority, "${table.path}/#", table.ordinal * 2 + 1)
-            }
-        }
-    }
-
-    override fun onCreate(): Boolean = true
-
-    override fun query(
-        uri: Uri,
-        projection: Array<out String>?,
-        selection: String?,
-        selectionArgs: Array<out String>?,
-        sortOrder: String?,
-    ): Cursor {
-        val (table, id) = match(uri)
-        return source.query(table, projection, table.selectionFor(id, selection), selectionArgs, sortOrder).apply {
-            setNotificationUri(requireNotNull(context).contentResolver, uri)
-        }
-    }
-
-    override fun getType(uri: Uri): String {
-        val (table, id) = match(uri)
-        return table.mimeType(single = id != null)
-    }
-
-    override fun insert(uri: Uri, values: ContentValues?): Uri {
-        val (table, id) = match(uri)
-        require(id == null) { "Insert into ${table.path}, not into one of its rows" }
-        return ContentUris.withAppendedId(uri, writer.insert(table, values.toMap()))
-    }
-
-    override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array<out String>?): Int {
-        val (table, id) = match(uri)
-        return writer.update(table, values.toMap(), table.selectionFor(id, selection), selectionArgs)
-    }
-
-    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int {
-        val (table, id) = match(uri)
-        return writer.delete(table, table.selectionFor(id, selection), selectionArgs)
-    }
-
-    /** All or nothing, as against OpenTasks, and observers hear of it once. */
-    override fun applyBatch(operations: ArrayList<ContentProviderOperation>): Array<ContentProviderResult> =
-        writer.batch { super.applyBatch(operations) }
-
-    private fun match(uri: Uri): Pair<ProviderTable, Long?> {
-        val code = matcher.match(uri)
-        require(code != UriMatcher.NO_MATCH) { "Unknown URI $uri" }
-        val table = ProviderTable.entries[code / 2]
-        if (code % 2 == 0) return table to null
-        val id = requireNotNull(uri.lastPathSegment?.toLongOrNull()) { "Unknown URI $uri" }
-        return table to id
-    }
-
-    private fun ContentValues?.toMap(): ProviderValues =
-        this?.keySet()?.associateWith { get(it) }.orEmpty()
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/provider/ProviderSchema.kt

@@ -1,116 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Instances
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Lists
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Properties
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Tasks
-
-/** One table [AgendulaTaskProvider] serves, with its columns in cursor order. */
-enum class ProviderTable(val path: String, val columns: List<Pair<String, String>>) {
-    LISTS(
-        Lists.PATH,
-        listOf(
-            Lists.ID to "INTEGER PRIMARY KEY",
-            Lists.NAME to "TEXT",
-            Lists.COLOR to "INTEGER",
-            Lists.ACCESS_LEVEL to "INTEGER",
-            Lists.VISIBLE to "INTEGER",
-            Lists.SYNC_ENABLED to "INTEGER",
-            Lists.OWNER to "TEXT",
-            Lists.ACCOUNT_NAME to "TEXT",
-            Lists.ACCOUNT_TYPE to "TEXT",
-        ),
-    ),
-    TASKS(Tasks.PATH, listOf(Tasks.ID to "INTEGER PRIMARY KEY") + TASK_COLUMNS),
-    INSTANCES(
-        Instances.PATH,
-        listOf(
-            Tasks.ID to "INTEGER PRIMARY KEY",
-            Instances.TASK_ID to "INTEGER",
-            Instances.INSTANCE_START to "INTEGER",
-            Instances.INSTANCE_START_SORTING to "INTEGER",
-            Instances.INSTANCE_DUE to "INTEGER",
-            Instances.INSTANCE_DUE_SORTING to "INTEGER",
-            Instances.INSTANCE_DURATION to "INTEGER",
-            Instances.INSTANCE_ORIGINAL_TIME to "INTEGER",
-            Instances.DISTANCE_FROM_CURRENT to "INTEGER",
-            Instances.IS_RECURRING to "INTEGER",
-        ) + TASK_COLUMNS,
-    ),
-    PROPERTIES(
-        Properties.PATH,
-        listOf(
-            Properties.PROPERTY_ID to "INTEGER PRIMARY KEY",
-            Properties.TASK_ID to "INTEGER",
-            Properties.MIMETYPE to "TEXT",
-            Properties.DATA0 to "TEXT",
-            Properties.DATA1 to "TEXT",
-            Properties.DATA2 to "TEXT",
-            Properties.DATA3 to "TEXT",
-        ),
-    ),
-    ;
-
-    val idColumn: String get() = columns.first().first
-
-    /** [selection] narrowed to the row [id] names, for a `/<id>` URI. */
-    fun selectionFor(id: Long?, selection: String?): String? =
-        if (id == null) selection else listOfNotNull("$idColumn = $id", selection?.let { "($it)" }).joinToString(" AND ")
-
-    /** OpenTasks' MIME type for a whole table, or for one row of it. */
-    fun mimeType(single: Boolean): String =
-        "${if (single) "vnd.android.cursor.item" else "vnd.android.cursor.dir"}/org.dmfs.tasks.$path"
-}
-
-/** Every `tasks` column but `_id`; the instances view carries them too. */
-private val TASK_COLUMNS: List<Pair<String, String>>
-    get() = listOf(
-        Tasks.LIST_ID to "INTEGER",
-        Tasks.LIST_NAME to "TEXT",
-        Tasks.LIST_COLOR to "INTEGER",
-        Tasks.LIST_OWNER to "TEXT",
-        Tasks.LIST_ACCESS_LEVEL to "INTEGER",
-        Tasks.VISIBLE to "INTEGER",
-        Tasks.ACCOUNT_NAME to "TEXT",
-        Tasks.ACCOUNT_TYPE to "TEXT",
-        Tasks.UID to "TEXT",
-        Tasks.DELETED to "INTEGER",
-        Tasks.TITLE to "TEXT",
-        Tasks.DESCRIPTION to "TEXT",
-        Tasks.LOCATION to "TEXT",
-        Tasks.URL to "TEXT",
-        Tasks.PRIORITY to "INTEGER",
-        Tasks.CLASSIFICATION to "INTEGER",
-        Tasks.STATUS to "INTEGER",
-        Tasks.PERCENT_COMPLETE to "INTEGER",
-        Tasks.COMPLETED to "INTEGER",
-        Tasks.IS_CLOSED to "INTEGER",
-        Tasks.IS_NEW to "INTEGER",
-        Tasks.TASK_COLOR to "INTEGER",
-        Tasks.DTSTART to "INTEGER",
-        Tasks.DUE to "INTEGER",
-        Tasks.DURATION to "TEXT",
-        Tasks.IS_ALLDAY to "INTEGER",
-        Tasks.TZ to "TEXT",
-        Tasks.RRULE to "TEXT",
-        Tasks.RDATE to "TEXT",
-        Tasks.EXDATE to "TEXT",
-        Tasks.ORIGINAL_INSTANCE_ID to "INTEGER",
-        Tasks.ORIGINAL_INSTANCE_TIME to "INTEGER",
-        Tasks.ORIGINAL_INSTANCE_ALLDAY to "INTEGER",
-        Tasks.PARENT_ID to "INTEGER",
-        Tasks.SORTING to "INTEGER",
-        Tasks.HAS_ALARMS to "INTEGER",
-        Tasks.CREATED to "INTEGER",
-        Tasks.LAST_MODIFIED to "INTEGER",
-    ) + UNSUPPORTED_TASK_COLUMNS.map { it to "TEXT" }
-
-/**
- * OpenTasks columns Agendula has nothing for. Published as `NULL` so a client
- * that projects them reads nothing rather than failing the query.
- */
-private val UNSUPPORTED_TASK_COLUMNS = listOf(
-    "geo", "organizer", "pinned", "has_properties", "completed_is_allday", "original_instance_sync_id",
-    "version", "_dirty", "_sync_id", "sync_version",
-    "sync1", "sync2", "sync3", "sync4", "sync5", "sync6", "sync7", "sync8",
-)

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/provider/ProviderSnapshot.kt

@@ -1,267 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Alarm
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Category
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Instances
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Lists
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Properties
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Tasks
-import de.jeanlucmakiola.agendula.data.tasks.room.AlarmReference
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskListRow
-import de.jeanlucmakiola.agendula.data.tasks.room.seriesOccurrences
-import de.jeanlucmakiola.agendula.domain.TaskStatus
-import de.jeanlucmakiola.agendula.domain.toInt
-import java.time.ZoneId
-import kotlin.time.Instant
-
-typealias ProviderRow = Map<String, Any?>
-
-/**
- * Ids that stay put for as long as what they name exists, so a client can read
- * an id and write to it later, or several in one batch. The one exception is
- * two tags on one task whose spellings hash alike (about one in 2³¹): removing
- * the one that sorts first moves the other onto its id.
- *
- * An instance is its series and its original time; a plain task's one
- * instance has none. An alarm property is the alarm row; a tag property is its
- * task and its spelling. Alarms take even ids and tags odd ones, so the two
- * never meet.
- */
-object ProviderIds {
-
-    fun instance(seriesId: Long, originalTime: Instant?): Long =
-        (seriesId shl 32) or ((originalTime?.epochSeconds ?: 0L) and 0xFFFFFFFFL)
-
-    fun instanceSeries(instanceId: Long): Long = instanceId ushr 32
-
-    fun instanceSeconds(instanceId: Long): Long = instanceId and 0xFFFFFFFFL
-
-    fun alarm(alarmId: Long): Long = alarmId shl 1
-
-    fun isAlarm(propertyId: Long): Boolean = propertyId and 1L == 0L
-
-    fun alarmRow(propertyId: Long): Long = propertyId ushr 1
-
-    /** The property id of each of [taskId]'s [categories], by spelling. */
-    fun categories(taskId: Long, categories: List<String>): Map<String, Long> =
-        categories(taskId, categories, ::tagHash)
-
-    internal fun categories(taskId: Long, categories: List<String>, hash: (String) -> Long): Map<String, Long> {
-        val used = HashSet<Long>()
-        // Two spellings on one task with one hash: the one that sorts later takes
-        // the next free slot, wrapping inside the tag bits so it never reaches the
-        // task's. Sorting keeps that independent of the tags' order.
-        val ids = categories.sorted().associateWith { name ->
-            var bits = hash(name) and TAG_BITS
-            while (!used.add(bits)) bits = (bits + 1) and TAG_BITS
-            (((taskId shl 31) or bits) shl 1) or 1L
-        }
-        return categories.associateWith(ids::getValue)
-    }
-
-    fun categoryTask(propertyId: Long): Long = propertyId ushr 32
-
-    private const val TAG_BITS = 0x7FFFFFFFL
-
-    /** 64-bit FNV-1a over the spelling's UTF-8, folded to 31 bits. */
-    private fun tagHash(name: String): Long {
-        var hash = -0x340d631b7bdddcdbL
-        name.encodeToByteArray().forEach { byte ->
-            hash = (hash xor (byte.toLong() and 0xFF)) * 0x100000001b3L
-        }
-        return (hash xor (hash ushr 31) xor (hash ushr 62)) and TAG_BITS
-    }
-}
-
-/** The Room store laid out as OpenTasks' tables, ready to be queried. */
-class ProviderSnapshot(val rows: Map<ProviderTable, List<ProviderRow>>) {
-
-    companion object {
-        val EMPTY = ProviderSnapshot(ProviderTable.entries.associateWith { emptyList() })
-
-        /**
-         * Lays out the store. [tasks] must hold no tombstones. [accountType] is
-         * what a list attached to an account reports; a device-only list reports
-         * OpenTasks' local account so clients treat it the way they already do.
-         */
-        fun build(
-            lists: List<TaskListRow>,
-            tasks: List<TaskEntity>,
-            alarms: List<TaskAlarmEntity>,
-            accountType: String,
-            now: Instant,
-            zone: ZoneId = ZoneId.systemDefault(),
-        ): ProviderSnapshot {
-            val listsById = lists.associateBy { it.list.id }
-            val alarmsByTask = alarms.groupBy { it.taskId }
-            val taskRows = tasks.mapNotNull { task ->
-                val list = listsById[task.listId] ?: return@mapNotNull null
-                task.id to taskColumns(task, list, alarmsByTask[task.id].orEmpty().isNotEmpty(), accountType)
-            }.toMap()
-
-            val overrides = tasks.filter { it.masterId != null }.groupBy { it.masterId }
-            val instances = tasks.filter { it.masterId == null && it.id in taskRows }.flatMap { task ->
-                occurrences(task, overrides[task.id].orEmpty(), now).mapNotNull { occurrence ->
-                    val columns = taskRows[occurrence.row.id] ?: return@mapNotNull null
-                    columns + instanceColumns(ProviderIds.instance(task.id, occurrence.originalTime), occurrence, zone)
-                }
-            }
-
-            return ProviderSnapshot(
-                mapOf(
-                    ProviderTable.LISTS to lists.map { listColumns(it, accountType) },
-                    ProviderTable.TASKS to taskRows.map { (id, columns) -> columns + (Tasks.ID to id) },
-                    ProviderTable.INSTANCES to instances,
-                    ProviderTable.PROPERTIES to properties(tasks.filter { it.id in taskRows }, alarms),
-                ),
-            )
-        }
-
-        private fun listColumns(row: TaskListRow, accountType: String): ProviderRow = mapOf(
-            Lists.ID to row.list.id,
-            Lists.NAME to row.list.name,
-            Lists.COLOR to row.list.color,
-            Lists.ACCESS_LEVEL to 0,
-            Lists.VISIBLE to row.list.isVisible.bit,
-            Lists.SYNC_ENABLED to row.list.isSynced.bit,
-            Lists.OWNER to row.list.owner,
-            Lists.ACCOUNT_NAME to accountName(row),
-            Lists.ACCOUNT_TYPE to accountTypeOf(row, accountType),
-        )
-
-        private fun taskColumns(task: TaskEntity, list: TaskListRow, hasAlarms: Boolean, accountType: String) =
-            mapOf(
-                Tasks.LIST_ID to task.listId,
-                Tasks.LIST_NAME to list.list.name,
-                Tasks.LIST_COLOR to list.list.color,
-                Tasks.LIST_OWNER to list.list.owner,
-                Tasks.LIST_ACCESS_LEVEL to 0,
-                Tasks.VISIBLE to list.list.isVisible.bit,
-                Tasks.ACCOUNT_NAME to accountName(list),
-                Tasks.ACCOUNT_TYPE to accountTypeOf(list, accountType),
-                Tasks.UID to task.uid,
-                Tasks.DELETED to 0,
-                Tasks.TITLE to task.title,
-                Tasks.DESCRIPTION to task.description,
-                Tasks.LOCATION to task.location,
-                Tasks.URL to task.url,
-                Tasks.PRIORITY to task.priority,
-                Tasks.CLASSIFICATION to task.classification,
-                Tasks.STATUS to task.status.toInt(),
-                Tasks.PERCENT_COMPLETE to task.percentComplete,
-                Tasks.COMPLETED to task.completedAt?.toEpochMilliseconds(),
-                Tasks.IS_CLOSED to (task.status == TaskStatus.COMPLETED || task.status == TaskStatus.CANCELLED).bit,
-                Tasks.IS_NEW to (task.status == TaskStatus.NEEDS_ACTION && task.percentComplete == null).bit,
-                Tasks.TASK_COLOR to task.color,
-                Tasks.DTSTART to task.dtstart?.toEpochMilliseconds(),
-                Tasks.DUE to task.due?.toEpochMilliseconds(),
-                Tasks.DURATION to task.duration,
-                Tasks.IS_ALLDAY to task.isAllDay.bit,
-                Tasks.TZ to task.timezone,
-                Tasks.RRULE to task.rrule,
-                Tasks.RDATE to task.rdate,
-                Tasks.EXDATE to task.exdate,
-                Tasks.ORIGINAL_INSTANCE_ID to task.masterId,
-                Tasks.ORIGINAL_INSTANCE_TIME to task.recurrenceId?.toEpochMilliseconds(),
-                Tasks.ORIGINAL_INSTANCE_ALLDAY to task.masterId?.let { task.isAllDay.bit },
-                Tasks.PARENT_ID to task.parentId,
-                Tasks.SORTING to task.sortOrder,
-                Tasks.HAS_ALARMS to hasAlarms.bit,
-                Tasks.CREATED to task.createdAt?.toEpochMilliseconds(),
-                Tasks.LAST_MODIFIED to task.lastModified?.toEpochMilliseconds(),
-            )
-
-        /** One instance: the row it reads from, its times, and where it sits in its series. */
-        private class Occurrence(
-            val row: TaskEntity,
-            val start: Instant?,
-            val due: Instant?,
-            val originalTime: Instant?,
-            val distance: Int,
-            val recurring: Boolean,
-        )
-
-        private fun occurrences(master: TaskEntity, overrides: List<TaskEntity>, now: Instant): List<Occurrence> {
-            val series = seriesOccurrences(master, overrides, now)
-                ?: return listOf(Occurrence(master, master.dtstart, master.due, null, 0, recurring = false))
-            return series.mapIndexed { index, occurrence ->
-                Occurrence(
-                    row = occurrence.override ?: master,
-                    start = occurrence.start,
-                    due = occurrence.due,
-                    originalTime = occurrence.anchor,
-                    distance = occurrence.distance ?: index,
-                    recurring = true,
-                )
-            }
-        }
-
-        private fun instanceColumns(id: Long, occurrence: Occurrence, zone: ZoneId): ProviderRow {
-            val allDay = occurrence.row.isAllDay
-            val start = occurrence.start?.toEpochMilliseconds()
-            val due = occurrence.due?.toEpochMilliseconds()
-            return mapOf(
-                Tasks.ID to id,
-                Instances.TASK_ID to occurrence.row.id,
-                Instances.INSTANCE_START to start,
-                Instances.INSTANCE_START_SORTING to start?.let { sorting(it, allDay, zone) },
-                Instances.INSTANCE_DUE to due,
-                Instances.INSTANCE_DUE_SORTING to due?.let { sorting(it, allDay, zone) },
-                Instances.INSTANCE_DURATION to if (start != null && due != null) due - start else null,
-                Instances.INSTANCE_ORIGINAL_TIME to occurrence.originalTime?.toEpochMilliseconds(),
-                Instances.DISTANCE_FROM_CURRENT to occurrence.distance,
-                Instances.IS_RECURRING to occurrence.recurring.bit,
-            )
-        }
-
-        /**
-         * An all-day date is stored as UTC midnight; OpenTasks' sorting columns
-         * move it to local midnight so it sorts among the timed tasks of that day.
-         */
-        private fun sorting(millis: Long, allDay: Boolean, zone: ZoneId): Long {
-            if (!allDay) return millis
-            val offset = zone.rules.getOffset(java.time.Instant.ofEpochMilli(millis)).totalSeconds * 1000L
-            return millis - offset
-        }
-
-        private fun properties(tasks: List<TaskEntity>, alarms: List<TaskAlarmEntity>): List<ProviderRow> {
-            val live = tasks.mapTo(HashSet()) { it.id }
-            val alarmRows = alarms.filter { it.taskId in live }.map {
-                mapOf(
-                    Properties.PROPERTY_ID to ProviderIds.alarm(it.id),
-                    Properties.TASK_ID to it.taskId,
-                    Properties.MIMETYPE to Alarm.MIMETYPE,
-                    Alarm.MINUTES_BEFORE to it.minutesBefore.toString(),
-                    Alarm.REFERENCE to when (it.reference) {
-                        AlarmReference.DUE -> Alarm.REFERENCE_DUE
-                        AlarmReference.START -> Alarm.REFERENCE_START
-                    }.toString(),
-                    Alarm.MESSAGE to it.message,
-                    Alarm.ALARM_TYPE to Alarm.TYPE_MESSAGE.toString(),
-                )
-            }
-            val categoryRows = tasks.flatMap { task ->
-                ProviderIds.categories(task.id, task.categories).map { (name, id) ->
-                    mapOf(
-                        Properties.PROPERTY_ID to id,
-                        Properties.TASK_ID to task.id,
-                        Properties.MIMETYPE to Category.MIMETYPE,
-                        Category.NAME to name,
-                    )
-                }
-            }
-            return alarmRows + categoryRows
-        }
-
-        private fun accountName(row: TaskListRow): String =
-            row.accountDisplayName ?: TasksContract.LOCAL_ACCOUNT_NAME
-
-        private fun accountTypeOf(row: TaskListRow, accountType: String): String =
-            if (row.list.accountId == null) TasksContract.LOCAL_ACCOUNT_TYPE else accountType
-
-        private val Boolean.bit: Int get() = if (this) 1 else 0
-    }
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/provider/ProviderSnapshotSource.kt

@@ -1,182 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import android.content.Context
-import android.database.Cursor
-import android.os.Handler
-import android.os.Looper
-import androidx.room.InvalidationTracker
-import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.agendula.R
-import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
-import de.jeanlucmakiola.agendula.data.tasks.StartupGate
-import de.jeanlucmakiola.agendula.data.tasks.StorageMode
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract
-import de.jeanlucmakiola.agendula.data.tasks.room.OBSERVED_TABLES
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskListRow
-import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.withTimeoutOrNull
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.concurrent.atomic.AtomicLong
-import javax.inject.Inject
-import javax.inject.Singleton
-import kotlin.time.Clock
-import kotlin.time.Duration
-import kotlin.time.Duration.Companion.hours
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.Duration.Companion.seconds
-import kotlin.time.Instant
-
-/** Rebuilt at least this often, so the expansion window and `distance_from_current` follow the clock. */
-private val MAX_AGE = 1.hours
-
-private val STARTUP_WAIT = 10.seconds
-
-private val NOTIFY_DELAY = 500.milliseconds
-
-/**
- * Serves [AgendulaTaskProvider]: keeps a [SnapshotDatabase] of the Room store,
- * rebuilt lazily after a write or a storage-mode switch, and tells observers of
- * the provider's authority when either happens.
- *
- * Empty in [StorageMode.EXTERNAL]: the Room store is not the user's data then,
- * and clients should read OpenTasks or tasks.org directly.
- */
-@Singleton
-class ProviderSnapshotSource internal constructor(
-    private val context: Context,
-    private val database: TasksDatabase,
-    private val resolver: ProviderResolver,
-    private val awaitStartup: suspend () -> Unit,
-    private val clock: Clock = Clock.System,
-    private val startupWait: Duration = STARTUP_WAIT,
-) {
-
-    @Inject constructor(
-        @ApplicationContext context: Context,
-        database: TasksDatabase,
-        resolver: ProviderResolver,
-        startupGate: StartupGate,
-    ) : this(context, database, resolver, startupGate::awaitReady)
-
-    private val started = AtomicBoolean(false)
-    private val snapshot by lazy { SnapshotDatabase() }
-    private val generation = AtomicLong(1)
-    private var builtGeneration = 0L
-    private var builtAt: Instant? = null
-
-    private val handler = Handler(Looper.getMainLooper())
-    private val notify = Runnable {
-        context.contentResolver.notifyChange(TasksContract.authorityUri(authority), null)
-    }
-
-    val authority: String get() = "${context.packageName}.$AUTHORITY_SUFFIX"
-
-    /** Starts watching for changes. Idempotent; touches the database, so not from the main thread. */
-    fun start() {
-        if (!started.compareAndSet(false, true)) return
-        database.invalidationTracker.addObserver(
-            object : InvalidationTracker.Observer(OBSERVED_TABLES) {
-                override fun onInvalidated(tables: Set<String>) {
-                    if (resolver.mode() == StorageMode.OWN) changed()
-                }
-            },
-        )
-        resolver.onModeChanged(::changed)
-    }
-
-    @Synchronized
-    fun query(
-        table: ProviderTable,
-        projection: Array<out String>?,
-        selection: String?,
-        selectionArgs: Array<out String>?,
-        sortOrder: String?,
-    ): Cursor {
-        refresh()
-        return snapshot.query(table, projection, selection, selectionArgs, sortOrder)
-    }
-
-    /**
-     * Runs [block] holding the snapshot's lock, once startup has settled which
-     * store is the user's. A write refuses to run without that, where a read
-     * falls back to answering from whichever store autoMode() picks.
-     */
-    fun <T> locked(block: () -> T): T {
-        start()
-        checkNotNull(runBlocking { withTimeoutOrNull(startupWait) { awaitStartup() } }) {
-            "Agendula is still starting; try again"
-        }
-        return synchronized(this, block)
-    }
-
-    /** The [columns] of every row of [table] that [selection] matches, as of now. */
-    @Synchronized
-    fun rows(table: ProviderTable, columns: List<String>, selection: String?, selectionArgs: Array<out String>?): List<List<Any?>> =
-        query(table, columns.toTypedArray(), selection, selectionArgs, null).use { cursor ->
-            buildList {
-                while (cursor.moveToNext()) {
-                    add(
-                        List(cursor.columnCount) { column ->
-                            when (cursor.getType(column)) {
-                                Cursor.FIELD_TYPE_NULL -> null
-                                Cursor.FIELD_TYPE_INTEGER -> cursor.getLong(column)
-                                else -> cursor.getString(column)
-                            }
-                        },
-                    )
-                }
-            }
-        }
-
-    /**
-     * Marks the snapshot stale at once. A provider write calls this so the next
-     * operation of the same batch sees it, before Room's own invalidation lands.
-     */
-    fun invalidate() {
-        generation.incrementAndGet()
-    }
-
-    @Synchronized
-    private fun refresh() {
-        start()
-        runBlocking { withTimeoutOrNull(startupWait) { awaitStartup() } }
-        val now = clock.now()
-        val current = generation.get()
-        val expired = builtAt.let { it == null || now - it > MAX_AGE }
-        if (current != builtGeneration || expired) {
-            snapshot.load(build(now))
-            builtGeneration = current
-            // Instance ids and distances move with the clock, so a timed rebuild is a change too.
-            if (expired && builtAt != null) notifyObservers()
-            builtAt = now
-        }
-    }
-
-    private fun build(now: Instant): ProviderSnapshot {
-        if (resolver.mode() != StorageMode.OWN) return ProviderSnapshot.EMPTY
-        // Read consistently in one transaction; expand outside it, so the app's
-        // own writes do not wait on recurrence expansion.
-        val (lists, tasks, alarms) = database.runInTransaction<Triple<List<TaskListRow>, List<TaskEntity>, List<TaskAlarmEntity>>> {
-            Triple(database.taskLists().lists(), database.tasks().live(), database.alarms().all())
-        }
-        return ProviderSnapshot.build(lists, tasks, alarms, context.getString(R.string.account_type), now)
-    }
-
-    private fun changed() {
-        generation.incrementAndGet()
-        notifyObservers()
-    }
-
-    /** Coalesced, so a sync committing many small transactions wakes each client once. */
-    private fun notifyObservers() {
-        handler.removeCallbacks(notify)
-        handler.postDelayed(notify, NOTIFY_DELAY.inWholeMilliseconds)
-    }
-
-    companion object {
-        const val AUTHORITY_SUFFIX = "tasks"
-    }
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/provider/ProviderTaskWriter.kt

@@ -1,304 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Tasks
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.forAllDay
-import de.jeanlucmakiola.agendula.domain.TaskStatus
-import de.jeanlucmakiola.agendula.domain.statusFromInt
-import org.dmfs.rfc5545.recur.RecurrenceRule
-import java.time.ZoneId
-import kotlin.time.Instant
-
-/** A client's `ContentValues`, as plain Kotlin values. */
-typealias ProviderValues = Map<String, Any?>
-
-/** The `tasks` columns a client may write. Everything else the table publishes is ignored on a write. */
-val WRITABLE_TASK_COLUMNS: Set<String> = setOf(
-    Tasks.LIST_ID, Tasks.UID, Tasks.TITLE, Tasks.DESCRIPTION, Tasks.LOCATION, Tasks.URL, Tasks.PRIORITY,
-    Tasks.CLASSIFICATION, Tasks.STATUS, Tasks.PERCENT_COMPLETE, Tasks.COMPLETED, Tasks.TASK_COLOR, Tasks.DTSTART,
-    Tasks.DUE, Tasks.DURATION, Tasks.IS_ALLDAY, Tasks.TZ, Tasks.RRULE, Tasks.RDATE, Tasks.EXDATE, Tasks.PARENT_ID,
-    Tasks.SORTING,
-)
-
-/** The columns that say whether a task, or one occurrence of it, is done. */
-val COMPLETION_COLUMNS: Set<String> = setOf(Tasks.STATUS, Tasks.PERCENT_COMPLETE, Tasks.COMPLETED)
-
-/** The columns that place a task in time; one occurrence of a series cannot be moved through the provider. */
-val TIME_COLUMNS: Set<String> = setOf(
-    Tasks.DTSTART, Tasks.DUE, Tasks.DURATION, Tasks.IS_ALLDAY, Tasks.TZ, Tasks.RRULE, Tasks.RDATE, Tasks.EXDATE,
-)
-
-/** What a write to one occurrence of a series does to it. */
-enum class OccurrenceChange { COMPLETE, CANCEL, REOPEN }
-
-private val ICAL_DATE = Regex("""\d{8}(T\d{6}Z?)?""")
-
-private val ICAL_DURATION = Regex("""[+-]?P(\d+W|(\d+D)?(T(\d+H)?(\d+M)?(\d+S)?)?)""")
-
-/**
- * Turns a client's OpenTasks `ContentValues` into [TaskEntity] changes. Pure, so
- * the rules are testable on the JVM. A bad value throws [IllegalArgumentException],
- * which reaches the client as is.
- *
- * Only [WRITABLE_TASK_COLUMNS] change anything. The rest of what the provider
- * publishes is accepted and ignored, so a client can write back a row it read;
- * the fields Agendula keeps for CalDAV (`href`, `etag`, `sequence`, unknown
- * properties) are not published and so cannot be written at all.
- */
-object ProviderTaskWriter {
-
-    /**
-     * [values] narrowed to the columns in [writable]. A column [table] does not
-     * have at all is a client bug and throws.
-     */
-    fun writable(table: ProviderTable, values: ProviderValues, writable: Set<String>): ProviderValues {
-        val known = table.columns.mapTo(HashSet()) { it.first }
-        val unknown = values.keys - known
-        require(unknown.isEmpty()) { "Unknown column(s) for ${table.path}: ${unknown.sorted().joinToString()}" }
-        return values.filterKeys { it in writable }
-    }
-
-    /** A new task from [values], which must name its list. */
-    fun newTask(values: ProviderValues, uid: String, now: Instant, tzId: String): TaskEntity {
-        val v = Values(values)
-        val listId = requireNotNull(v.long(Tasks.LIST_ID)) { "A new task needs a ${Tasks.LIST_ID}" }
-        val base = TaskEntity(listId = listId, uid = v.string(Tasks.UID)?.trim()?.ifEmpty { null } ?: uid, createdAt = now)
-        // As in OpenTasks, a new task inserted without a zone is floating.
-        val zoned = if (Tasks.TZ in v) values else values + (Tasks.TZ to null)
-        return applied(base, zoned - Tasks.LIST_ID - Tasks.UID, now, tzId)
-    }
-
-    /**
-     * [current] with [values] applied. Identity and sync columns are left alone,
-     * and [current] itself comes back when nothing changed, so a write that
-     * changes nothing owes the server nothing.
-     */
-    fun patch(current: TaskEntity, values: ProviderValues, now: Instant, tzId: String): TaskEntity {
-        val edited = applied(current, values, now, tzId)
-        return if (edited.copy(lastModified = current.lastModified, isDirty = current.isDirty) == current) current else edited
-    }
-
-    /**
-     * The columns in [values] that would change [current] on their own. Writing
-     * back what a row published changes nothing, so a client that read a row can
-     * send all of it with the one value it meant to change.
-     */
-    fun changedColumns(current: TaskEntity, values: ProviderValues, tzId: String): Set<String> {
-        val stamp = current.lastModified ?: Instant.DISTANT_PAST
-        return values.keys.filterTo(HashSet()) { key ->
-            val edited = runCatching { applied(current, mapOf(key to values[key]), stamp, tzId) }.getOrNull()
-            edited == null || edited.copy(lastModified = current.lastModified, isDirty = current.isDirty) != current
-        }
-    }
-
-    private fun applied(current: TaskEntity, values: ProviderValues, now: Instant, tzId: String): TaskEntity {
-        val v = Values(values)
-        val isOverride = current.masterId != null
-        if (Tasks.UID in v) require(v.string(Tasks.UID)?.trim() == current.uid) { "A task's ${Tasks.UID} cannot change" }
-        if (isOverride) {
-            // NULL is what the row publishes, so writing it back is fine.
-            require(listOf(Tasks.RRULE, Tasks.RDATE, Tasks.EXDATE).none { it in v && v.text(it) != null }) {
-                "A modified occurrence carries no recurrence rule of its own"
-            }
-            if (Tasks.LIST_ID in v) require(v.long(Tasks.LIST_ID) == current.listId) { "A modified occurrence stays in its series' list" }
-            if (Tasks.PARENT_ID in v) require(v.long(Tasks.PARENT_ID) == current.parentId) { "A modified occurrence keeps its series' parent" }
-        }
-
-        val listId = if (Tasks.LIST_ID in v) requireNotNull(v.long(Tasks.LIST_ID)) { "${Tasks.LIST_ID} cannot be null" } else current.listId
-        val parentId = if (Tasks.PARENT_ID in v) v.long(Tasks.PARENT_ID)?.takeIf { it > 0 } else current.parentId
-        require(parentId == null || parentId != current.id || current.id == 0L) { "A task cannot be its own parent" }
-
-        val allDay = if (Tasks.IS_ALLDAY in v) v.boolean(Tasks.IS_ALLDAY) else current.isAllDay
-        val dtstart = (if (Tasks.DTSTART in v) v.instant(Tasks.DTSTART) else current.dtstart)?.forAllDay(allDay)
-        val due = (if (Tasks.DUE in v) v.instant(Tasks.DUE) else current.due)?.forAllDay(allDay)
-        val duration = when {
-            Tasks.DURATION in v -> v.string(Tasks.DURATION)?.trim()?.ifEmpty { null }
-                ?.also { require(ICAL_DURATION.matches(it)) { "Not an iCalendar duration: $it" } }
-            Tasks.DUE in v && due != null -> null
-            else -> current.duration
-        }
-        require(due == null || duration == null) { "${Tasks.DUE} and ${Tasks.DURATION} are mutually exclusive" }
-        require(dtstart == null || due == null || due >= dtstart) { "${Tasks.DUE} is before ${Tasks.DTSTART}" }
-        val timezone = when {
-            allDay -> null
-            Tasks.TZ in v -> v.string(Tasks.TZ)?.also { zone ->
-                require(runCatching { ZoneId.of(zone) }.isSuccess) { "Unknown time zone: $zone" }
-            }
-            dtstart == null && due == null -> null
-            // A timed task without a zone is floating (RFC 5545 §3.3.5) and stays so.
-            current.dtstart != null || current.due != null -> if (current.isAllDay) tzId else current.timezone
-            else -> current.timezone ?: tzId
-        }
-
-        val rrule = if (Tasks.RRULE in v) normalizedRule(v.string(Tasks.RRULE)) else current.rrule
-        val ruleDropped = Tasks.RRULE in v && rrule == null && current.rrule != null
-        val rdate = if (Tasks.RDATE in v) dateList(Tasks.RDATE, v, current.rdate) else current.rdate.takeUnless { ruleDropped }
-        val exdate = if (Tasks.EXDATE in v) dateList(Tasks.EXDATE, v, current.exdate) else current.exdate.takeUnless { ruleDropped }
-        require(rrule == null || dtstart != null || due != null) { "A recurring task needs a ${Tasks.DTSTART} or ${Tasks.DUE}" }
-
-        val (status, percent, completedAt) = completion(current, v, now)
-
-        return current.copy(
-            listId = listId,
-            title = if (Tasks.TITLE in v) v.string(Tasks.TITLE)?.trim() else current.title,
-            description = if (Tasks.DESCRIPTION in v) v.text(Tasks.DESCRIPTION) else current.description,
-            location = if (Tasks.LOCATION in v) v.text(Tasks.LOCATION) else current.location,
-            url = if (Tasks.URL in v) v.text(Tasks.URL) else current.url,
-            priority = if (Tasks.PRIORITY in v) v.int(Tasks.PRIORITY, 0..9) ?: TasksContract.PRIORITY_NONE else current.priority,
-            classification = if (Tasks.CLASSIFICATION in v) v.int(Tasks.CLASSIFICATION, 0..2) else current.classification,
-            color = if (Tasks.TASK_COLOR in v) v.int(Tasks.TASK_COLOR) else current.color,
-            sortOrder = if (Tasks.SORTING in v) v.int(Tasks.SORTING) ?: 0 else current.sortOrder,
-            status = status,
-            percentComplete = percent,
-            completedAt = completedAt,
-            dtstart = dtstart,
-            due = due,
-            duration = duration,
-            isAllDay = allDay,
-            timezone = timezone,
-            rrule = rrule,
-            rdate = rdate,
-            exdate = exdate,
-            parentId = parentId,
-            lastModified = now,
-            isDirty = true,
-        )
-    }
-
-    /**
-     * What [values] do to one occurrence of a series, or `null` when they say
-     * nothing about its completion. An occurrence is done, cancelled or open;
-     * partial progress belongs to a task, not to one of its occurrences.
-     */
-    fun occurrenceChange(values: ProviderValues): OccurrenceChange? {
-        val v = Values(values.filterKeys { it in COMPLETION_COLUMNS })
-        return when {
-            Tasks.STATUS in v -> when (v.int(Tasks.STATUS, 0..3)) {
-                TasksContract.STATUS_COMPLETED -> OccurrenceChange.COMPLETE
-                TasksContract.STATUS_CANCELLED -> OccurrenceChange.CANCEL
-                TasksContract.STATUS_NEEDS_ACTION, null -> OccurrenceChange.REOPEN
-                else -> throw IllegalArgumentException("An occurrence is completed, cancelled or open, not in process")
-            }
-            Tasks.PERCENT_COMPLETE in v -> when (v.int(Tasks.PERCENT_COMPLETE, 0..100)) {
-                100 -> OccurrenceChange.COMPLETE
-                0, null -> OccurrenceChange.REOPEN
-                else -> throw IllegalArgumentException("An occurrence is completed or open; partial progress belongs to its task")
-            }
-            Tasks.COMPLETED in v -> if (v.instant(Tasks.COMPLETED) != null) OccurrenceChange.COMPLETE else OccurrenceChange.REOPEN
-            else -> null
-        }
-    }
-
-    /**
-     * Status, progress and completion time after a write. They move together the
-     * way OpenTasks keeps them: a status implies its progress and time, progress
-     * implies a status, and a completion time alone completes the task. When a
-     * row is written back, the column that changed decides, not the ones it
-     * carries unchanged.
-     */
-    private fun completion(current: TaskEntity, values: Values, now: Instant): Triple<TaskStatus, Int?, Instant?> {
-        val v = Values(values.map.filterKeys { it !in COMPLETION_COLUMNS || it in completionChanged(current, values) })
-        val percent = if (Tasks.PERCENT_COMPLETE in v) v.int(Tasks.PERCENT_COMPLETE, 0..100) else current.percentComplete
-        val completed = if (Tasks.COMPLETED in v) v.instant(Tasks.COMPLETED) else current.completedAt
-        return when {
-            Tasks.STATUS in v -> when (val status = statusFromInt(v.int(Tasks.STATUS, 0..3))) {
-                TaskStatus.COMPLETED -> Triple(status, if (Tasks.PERCENT_COMPLETE in v) percent else 100, completed ?: now)
-                TaskStatus.NEEDS_ACTION ->
-                    Triple(status, if (Tasks.PERCENT_COMPLETE in v) percent?.takeIf { it < 100 } else null, null)
-                else -> Triple(status, percent, null)
-            }
-            Tasks.PERCENT_COMPLETE in v -> when {
-                percent == null -> Triple(current.status, null, current.completedAt)
-                percent >= 100 -> Triple(TaskStatus.COMPLETED, percent, completed ?: now)
-                percent > 0 -> Triple(TaskStatus.IN_PROCESS, percent, null)
-                else -> Triple(TaskStatus.NEEDS_ACTION, percent, null)
-            }
-            Tasks.COMPLETED in v -> when {
-                completed != null -> Triple(TaskStatus.COMPLETED, 100, completed)
-                // Clearing the time reopens a completed task; an open one has none to clear.
-                current.status == TaskStatus.COMPLETED -> Triple(TaskStatus.NEEDS_ACTION, null, null)
-                else -> Triple(current.status, current.percentComplete, null)
-            }
-            else -> Triple(current.status, current.percentComplete, current.completedAt)
-        }
-    }
-
-    /**
-     * The completion columns in [v] that differ from [current]. All of them when
-     * none does, so a write that only repeats the row still settles the rest.
-     */
-    private fun completionChanged(current: TaskEntity, v: Values): Set<String> {
-        val present = COMPLETION_COLUMNS.filterTo(HashSet()) { it in v }
-        val changed = present.filterTo(HashSet()) { column ->
-            when (column) {
-                Tasks.STATUS -> statusFromInt(v.int(Tasks.STATUS, 0..3)) != current.status
-                Tasks.PERCENT_COMPLETE -> v.int(Tasks.PERCENT_COMPLETE, 0..100) != current.percentComplete
-                else -> v.instant(Tasks.COMPLETED) != current.completedAt
-            }
-        }
-        return changed.ifEmpty { present }
-    }
-
-    /**
-     * An `RDATE`/`EXDATE` value: DATE or DATE-TIME values, comma-separated, of
-     * one kind. [stored] written back as is stays, whatever shape it synced in.
-     */
-    private fun dateList(column: String, v: Values, stored: String?): String? {
-        val raw = v.string(column)?.trim()?.ifEmpty { null } ?: return null
-        if (raw == stored?.trim()) return stored
-        val values = raw.split(',').map(String::trim)
-        require(values.all { ICAL_DATE.matches(it) }) { "$column takes iCalendar dates or date-times: $raw" }
-        // lib-recur reads the whole list or none of it, so it has to be one kind.
-        val kinds = values.map { if (it.length == 8) "date" else if (it.endsWith('Z')) "utc" else "local" }
-        require(kinds.distinct().size == 1) { "$column mixes value kinds: $raw" }
-        return values.joinToString(",")
-    }
-
-    private fun normalizedRule(raw: String?): String? {
-        val rule = raw?.trim()?.removePrefix("RRULE:")?.ifEmpty { null } ?: return null
-        require(runCatching { RecurrenceRule(rule) }.isSuccess) { "Not a recurrence rule: $rule" }
-        return rule
-    }
-}
-
-/** Lenient reads over [values]: a client may hand a number as a string or a flag as an integer. */
-internal class Values(private val values: ProviderValues) {
-
-    val keys: Set<String> get() = values.keys
-
-    val map: ProviderValues get() = values
-
-    operator fun contains(key: String) = key in values
-
-    fun string(key: String): String? = values[key]?.toString()
-
-    /** A free-text column: trimmed, blank stored as nothing. */
-    fun text(key: String): String? = string(key)?.trim()?.ifEmpty { null }
-
-    fun long(key: String): Long? = when (val value = values[key]) {
-        null -> null
-        is Number -> value.toLong()
-        is Boolean -> if (value) 1L else 0L
-        is String -> requireNotNull(value.trim().toLongOrNull()) { "$key is not a number: $value" }
-        else -> throw IllegalArgumentException("$key is not a number: $value")
-    }
-
-    fun int(key: String, range: IntRange? = null): Int? = long(key)?.let { value ->
-        require(value in Int.MIN_VALUE..Int.MAX_VALUE) { "$key is out of range: $value" }
-        value.toInt().also { require(range == null || it in range) { "$key must be in $range: $it" } }
-    }
-
-    fun boolean(key: String): Boolean = when (val value = values[key]) {
-        null -> false
-        is Boolean -> value
-        is String -> when (value.trim().lowercase()) {
-            "1", "true" -> true
-            "0", "false", "" -> false
-            else -> throw IllegalArgumentException("$key is not a flag: $value")
-        }
-        else -> long(key) != 0L
-    }
-
-    fun instant(key: String): Instant? = long(key)?.let(Instant::fromEpochMilliseconds)
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/provider/ProviderWriter.kt

@@ -1,441 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import android.database.sqlite.SQLiteConstraintException
-import de.jeanlucmakiola.agendula.data.di.ApplicationScope
-import de.jeanlucmakiola.agendula.data.reminders.ReminderScheduler
-import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
-import de.jeanlucmakiola.agendula.data.tasks.StorageMode
-import de.jeanlucmakiola.agendula.data.tasks.TaskWriteFailedException
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Alarm
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Category
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Instances
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Properties
-import de.jeanlucmakiola.agendula.data.tasks.TasksContract.Tasks
-import de.jeanlucmakiola.agendula.data.tasks.room.AlarmReference
-import de.jeanlucmakiola.agendula.data.tasks.room.RoomTasksDataSource
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
-import de.jeanlucmakiola.agendula.data.tasks.room.seriesOccurrences
-import de.jeanlucmakiola.agendula.domain.TaskStatus
-import de.jeanlucmakiola.agendula.domain.normalizeTags
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import java.time.ZoneId
-import java.util.UUID
-import javax.inject.Inject
-import javax.inject.Singleton
-import kotlin.time.Clock
-import kotlin.time.Instant
-
-/** One row by id, `<id column> = N` or `<id column> = ?`. */
-private val SINGLE_ROW = Regex("""\s*(\w+)\s*=\s*(\d+|\?)\s*""")
-
-/**
- * Applies another app's writes to the own store for [AgendulaTaskProvider].
- *
- * A write's selection runs against the published snapshot, so it matches the
- * rows the client can read, and each matched row is then written through
- * [RoomTasksDataSource] under the rules the app's own edits follow. `tasklists`
- * stays read-only. On `instances`, completion columns tick off that one
- * occurrence of a series; other content columns edit the series, and a changed
- * time column is refused, since one occurrence cannot be moved this way.
- *
- * Each call runs in one transaction, and a batch in one more around them.
- */
-@Singleton
-class ProviderWriter internal constructor(
-    private val database: TasksDatabase,
-    private val store: RoomTasksDataSource,
-    private val source: ProviderSnapshotSource,
-    private val resolver: ProviderResolver,
-    private val afterWrite: () -> Unit,
-    private val clock: Clock = Clock.System,
-) {
-
-    @Inject constructor(
-        database: TasksDatabase,
-        store: RoomTasksDataSource,
-        source: ProviderSnapshotSource,
-        resolver: ProviderResolver,
-        scheduler: ReminderScheduler,
-        @ApplicationScope scope: CoroutineScope,
-    ) : this(database, store, source, resolver, { scope.launch { runCatching { scheduler.sync() } } })
-
-    private var batchDepth = 0
-    private var batchWrote = false
-
-    /** Inserts one row and returns its published id. */
-    fun insert(table: ProviderTable, values: ProviderValues): Long = write {
-        when (table) {
-            ProviderTable.TASKS -> insertTask(values)
-            ProviderTable.PROPERTIES -> insertProperty(values)
-            else -> throw UnsupportedOperationException("${table.path} is read-only")
-        }
-    }
-
-    /** Updates every row [selection] matches and returns how many changed. */
-    fun update(table: ProviderTable, values: ProviderValues, selection: String?, args: Array<out String>?): Int = write {
-        when (table) {
-            ProviderTable.TASKS -> {
-                val writable = ProviderTaskWriter.writable(table, values, WRITABLE_TASK_COLUMNS)
-                val matched = ids(table, selection, args)
-                (if (Tasks.LIST_ID in writable) parentsFirst(matched) else matched).count { updateTask(it, writable) }
-            }
-            ProviderTable.INSTANCES -> {
-                val writable = ProviderTaskWriter.writable(table, values, WRITABLE_TASK_COLUMNS)
-                instances(selection, args).count { updateInstance(it, writable) }
-            }
-            ProviderTable.PROPERTIES -> ids(table, selection, args).count { updateProperty(it, values) }
-            else -> throw UnsupportedOperationException("${table.path} is read-only")
-        }
-    }
-
-    /** Deletes every row [selection] matches and returns how many went. */
-    fun delete(table: ProviderTable, selection: String?, args: Array<out String>?): Int = write {
-        when (table) {
-            ProviderTable.TASKS -> ids(table, selection, args).count { deleteTask(it) }
-            ProviderTable.INSTANCES -> instances(selection, args).count { deleteInstance(it) }
-            ProviderTable.PROPERTIES -> ids(table, selection, args).count { deleteProperty(it) }
-            else -> throw UnsupportedOperationException("${table.path} is read-only")
-        }
-    }
-
-    /** Runs a client's batch in one transaction, re-arming reminders once at the end. */
-    fun <T> batch(block: () -> T): T = source.locked {
-        batchDepth++
-        try {
-            database.runInTransaction<T> { block() }
-        } finally {
-            // A snapshot built mid-batch may hold rows a failure rolled back.
-            source.invalidate()
-            batchDepth--
-            if (batchDepth == 0 && batchWrote) {
-                batchWrote = false
-                afterWrite()
-            }
-        }
-    }
-
-    private fun <T> write(block: () -> T): T = source.locked {
-        check(resolver.mode() == StorageMode.OWN) {
-            "Agendula is working on top of an external tasks provider; write to that one instead"
-        }
-        val result = try {
-            database.runInTransaction<T> { block() }
-        } catch (e: TaskWriteFailedException) {
-            throw IllegalArgumentException(e.message, e)
-        } catch (e: SQLiteConstraintException) {
-            throw IllegalArgumentException(e.message, e)
-        } finally {
-            source.invalidate()
-        }
-        if (batchDepth == 0) afterWrite() else batchWrote = true
-        result
-    }
-
-    // --- tasks ------------------------------------------------------------------
-
-    private fun insertTask(values: ProviderValues): Long {
-        require(values[Tasks.ORIGINAL_INSTANCE_ID] == null && values[Tasks.ORIGINAL_INSTANCE_TIME] == null) {
-            "Modify an occurrence through ${Instances.PATH}, not by inserting one"
-        }
-        val writable = ProviderTaskWriter.writable(ProviderTable.TASKS, values, WRITABLE_TASK_COLUMNS)
-        val task = ProviderTaskWriter.newTask(writable, UUID.randomUUID().toString(), clock.now(), zone())
-        requireWritableList(task.listId)
-        // The unique index cannot catch this: SQLite treats the masters' NULL recurrence_id as distinct.
-        require(database.tasks().byUid(task.listId, task.uid) == null) { "List ${task.listId} already has a task ${task.uid}" }
-        requireParent(task)
-        return store.insertEntity(task)
-    }
-
-    private fun updateTask(taskId: Long, values: ProviderValues): Boolean {
-        val current = database.tasks().entity(taskId)?.takeUnless { it.isDeleted } ?: return false
-        requireWritableList(current.listId)
-        val edited = ProviderTaskWriter.patch(current, values, clock.now(), zone())
-        if (edited == current) return true
-        val moved = edited.listId != current.listId
-        if (moved) {
-            requireWritableList(edited.listId)
-            requireFreeUid(edited.listId, current.uid)
-        }
-        if (edited.parentId != current.parentId || moved) requireParent(edited)
-        store.replaceEntity(current, edited)
-        // A subtree moves as one: a subtask has to be in its parent's list.
-        if (moved) store.subtaskIds(taskId).forEach { moveSubtree(it, edited.listId, hashSetOf(taskId)) }
-        return true
-    }
-
-    private fun moveSubtree(taskId: Long, listId: Long, seen: MutableSet<Long> = HashSet()) {
-        if (!seen.add(taskId)) return
-        val current = database.tasks().entity(taskId)?.takeUnless { it.isDeleted } ?: return
-        if (current.listId != listId) {
-            requireFreeUid(listId, current.uid)
-            store.replaceEntity(current, current.copy(listId = listId, lastModified = clock.now(), isDirty = true))
-        }
-        store.subtaskIds(taskId).forEach { moveSubtree(it, listId, seen) }
-    }
-
-    /**
-     * [ids] with every parent before its subtasks, so a bulk move carries a
-     * subtree along before reaching its subtasks, whatever order they came in.
-     */
-    private fun parentsFirst(ids: List<Long>): List<Long> {
-        if (ids.size < 2) return ids
-        fun depth(id: Long): Int {
-            val seen = HashSet<Long>()
-            var parent = database.tasks().entity(id)?.parentId
-            while (parent != null && seen.add(parent)) parent = database.tasks().entity(parent)?.parentId
-            return seen.size
-        }
-        val depths = ids.associateWith(::depth)
-        return ids.sortedBy(depths::getValue)
-    }
-
-    private fun deleteTask(taskId: Long): Boolean {
-        val current = database.tasks().entity(taskId)?.takeUnless { it.isDeleted } ?: return false
-        requireWritableList(current.listId)
-        // An override deletes itself into an EXDATE on its master.
-        if (current.masterId != null) store.deleteTask(taskId) else store.deleteWithSubtasks(taskId)
-        return true
-    }
-
-    // --- instances --------------------------------------------------------------
-
-    /** One occurrence: the row it reads from, its series, and when it was due to happen. */
-    private class InstanceRow(val taskId: Long, val seriesId: Long, val originalTime: Instant?, val recurring: Boolean)
-
-    private fun instances(selection: String?, args: Array<out String>?): List<InstanceRow> {
-        singleId(ProviderTable.INSTANCES, selection, args)?.let { return listOfNotNull(instanceRow(it)) }
-        return source.rows(
-            ProviderTable.INSTANCES,
-            listOf(Tasks.ID, Instances.TASK_ID, Instances.INSTANCE_ORIGINAL_TIME, Instances.IS_RECURRING),
-            selection,
-            args,
-        ).map { (id, taskId, original, recurring) ->
-            InstanceRow(
-                taskId = taskId as Long,
-                seriesId = ProviderIds.instanceSeries(id as Long),
-                originalTime = (original as Long?)?.let(Instant::fromEpochMilliseconds),
-                recurring = recurring == 1L,
-            )
-        }
-    }
-
-    /** [instanceId] read straight from the store, without rebuilding the snapshot. */
-    private fun instanceRow(instanceId: Long): InstanceRow? {
-        val master = database.tasks().entity(ProviderIds.instanceSeries(instanceId))
-            ?.takeIf { !it.isDeleted && it.masterId == null } ?: return null
-        val occurrences = seriesOccurrences(master, database.tasks().overrides(master.id), clock.now())
-            ?: return InstanceRow(master.id, master.id, null, recurring = false)
-                .takeIf { ProviderIds.instanceSeconds(instanceId) == 0L }
-        val occurrence = occurrences.firstOrNull { ProviderIds.instance(master.id, it.anchor) == instanceId } ?: return null
-        return InstanceRow(occurrence.override?.id ?: master.id, master.id, occurrence.anchor, recurring = true)
-    }
-
-    private fun updateInstance(row: InstanceRow, values: ProviderValues): Boolean {
-        val occurrence = row.originalTime
-        if (!row.recurring || occurrence == null) return updateTask(row.taskId, values)
-        val shown = database.tasks().entity(row.taskId)?.takeUnless { it.isDeleted } ?: return false
-        requireWritableList(shown.listId)
-        // A row read back carries every column; only what differs from it is a write.
-        val changed = ProviderTaskWriter.changedColumns(shown, values, zone())
-        val moved = changed intersect TIME_COLUMNS
-        if (moved.isNotEmpty()) {
-            // A bad value reports itself rather than as a move.
-            ProviderTaskWriter.patch(shown, values.filterKeys { it in moved }, clock.now(), zone())
-            throw IllegalArgumentException(
-                "One occurrence of a recurring task cannot be moved (${moved.sorted().joinToString()}); write the series through ${Tasks.PATH}",
-            )
-        }
-        val content = values.filterKeys { it in changed && it !in COMPLETION_COLUMNS }
-        if (content.isNotEmpty()) {
-            updateTask(row.seriesId, content)
-            // A modified occurrence shows its own copy of the content, so it takes the write too.
-            if (row.taskId != row.seriesId) updateTask(row.taskId, content - Tasks.LIST_ID - Tasks.PARENT_ID)
-        }
-        if (changed.none { it in COMPLETION_COLUMNS }) return true
-        // The column the client changed decides, not the unchanged ones it carries along.
-        val change = ProviderTaskWriter.occurrenceChange(values.filterKeys { it in changed && it in COMPLETION_COLUMNS })
-            ?: return true
-        val status = database.tasks().entity(row.taskId)?.status
-        when (change) {
-            OccurrenceChange.COMPLETE ->
-                if (status != TaskStatus.COMPLETED) store.setCompletedInstance(row.taskId, occurrence, true)
-            OccurrenceChange.CANCEL ->
-                if (status != TaskStatus.CANCELLED) store.setCancelledInstance(row.taskId, occurrence, true)
-            OccurrenceChange.REOPEN ->
-                if (status != TaskStatus.NEEDS_ACTION) store.setCompletedInstance(row.taskId, occurrence, false)
-        }
-        return true
-    }
-
-    private fun deleteInstance(row: InstanceRow): Boolean {
-        val occurrence = row.originalTime
-        if (!row.recurring || occurrence == null) return deleteTask(row.taskId)
-        val task = database.tasks().entity(row.taskId)?.takeUnless { it.isDeleted } ?: return false
-        requireWritableList(task.listId)
-        if (task.masterId != null) store.deleteTask(task.id) else store.deleteOccurrence(task.id, occurrence)
-        return true
-    }
-
-    // --- properties -------------------------------------------------------------
-
-    /** What a published property id stands for, read from the store. */
-    private sealed interface PropertyRef {
-        val task: TaskEntity
-
-        class AlarmRow(val alarm: TaskAlarmEntity, override val task: TaskEntity) : PropertyRef
-        class CategoryRow(val name: String, override val task: TaskEntity) : PropertyRef
-    }
-
-    private fun propertyRef(propertyId: Long): PropertyRef? {
-        if (ProviderIds.isAlarm(propertyId)) {
-            val alarm = database.alarms().entity(ProviderIds.alarmRow(propertyId)) ?: return null
-            val task = database.tasks().entity(alarm.taskId)?.takeUnless { it.isDeleted } ?: return null
-            return PropertyRef.AlarmRow(alarm, task)
-        }
-        val task = database.tasks().entity(ProviderIds.categoryTask(propertyId))?.takeUnless { it.isDeleted } ?: return null
-        val name = ProviderIds.categories(task.id, task.categories).entries.firstOrNull { it.value == propertyId }?.key
-            ?: return null
-        return PropertyRef.CategoryRow(name, task)
-    }
-
-    private fun insertProperty(values: ProviderValues): Long {
-        val v = Values(ProviderTaskWriter.writable(ProviderTable.PROPERTIES, values, values.keys))
-        val taskId = requireNotNull(v.long(Properties.TASK_ID)) { "A property needs a ${Properties.TASK_ID}" }
-        val task = liveTask(taskId)
-        return when (v.string(Properties.MIMETYPE)) {
-            Alarm.MIMETYPE -> {
-                val alarm = alarm(TaskAlarmEntity(taskId = taskId, minutesBefore = 0), v, requireMinutes = true)
-                var id = 0L
-                store.writeAlarm(taskId) { id = database.alarms().insert(alarm) }
-                ProviderIds.alarm(id)
-            }
-            Category.MIMETYPE -> {
-                val name = requireNotNull(v.text(Category.NAME)) { "A category needs a ${Category.NAME}" }
-                setCategories(task, task.categories + name)
-                val categories = database.tasks().entity(taskId)!!.categories
-                ProviderIds.categories(taskId, categories).getValue(name)
-            }
-            else -> throw IllegalArgumentException("Only alarm and category properties can be written")
-        }
-    }
-
-    private fun updateProperty(propertyId: Long, values: ProviderValues): Boolean {
-        val v = Values(ProviderTaskWriter.writable(ProviderTable.PROPERTIES, values, values.keys - Properties.PROPERTY_ID))
-        val ref = propertyRef(propertyId) ?: return false
-        requireWritableList(ref.task.listId)
-        requireSame(v, Properties.TASK_ID, ref.task.id)
-        val mimetype = if (ref is PropertyRef.AlarmRow) Alarm.MIMETYPE else Category.MIMETYPE
-        if (Properties.MIMETYPE in v) require(v.string(Properties.MIMETYPE) == mimetype) { "A property's mimetype cannot change" }
-        when (ref) {
-            is PropertyRef.AlarmRow -> {
-                val edited = alarm(ref.alarm, v, requireMinutes = false)
-                if (edited != ref.alarm) store.writeAlarm(ref.task.id) { database.alarms().update(edited) }
-            }
-            is PropertyRef.CategoryRow -> if (Category.NAME in v) {
-                val name = requireNotNull(v.text(Category.NAME)) { "A category needs a ${Category.NAME}" }
-                setCategories(ref.task, ref.task.categories.map { if (it == ref.name) name else it })
-            }
-        }
-        return true
-    }
-
-    private fun deleteProperty(propertyId: Long): Boolean {
-        val ref = propertyRef(propertyId) ?: return false
-        requireWritableList(ref.task.listId)
-        when (ref) {
-            is PropertyRef.AlarmRow -> store.writeAlarm(ref.task.id) { database.alarms().delete(ref.alarm.id) }
-            is PropertyRef.CategoryRow -> setCategories(ref.task, ref.task.categories - ref.name)
-        }
-        return true
-    }
-
-    private fun alarm(base: TaskAlarmEntity, v: Values, requireMinutes: Boolean): TaskAlarmEntity {
-        if (requireMinutes) requireNotNull(v.int(Alarm.MINUTES_BEFORE)) { "An alarm needs ${Alarm.MINUTES_BEFORE}" }
-        val reference = when (if (Alarm.REFERENCE in v) v.int(Alarm.REFERENCE) else null) {
-            null -> base.reference
-            Alarm.REFERENCE_DUE -> AlarmReference.DUE
-            Alarm.REFERENCE_START -> AlarmReference.START
-            else -> throw IllegalArgumentException("${Alarm.REFERENCE} must be ${Alarm.REFERENCE_DUE} (due) or ${Alarm.REFERENCE_START} (start)")
-        }
-        return base.copy(
-            minutesBefore = if (Alarm.MINUTES_BEFORE in v) requireNotNull(v.int(Alarm.MINUTES_BEFORE)) {
-                "${Alarm.MINUTES_BEFORE} cannot be null"
-            } else base.minutesBefore,
-            reference = reference,
-            message = if (Alarm.MESSAGE in v) v.text(Alarm.MESSAGE) else base.message,
-        )
-    }
-
-    private fun setCategories(task: TaskEntity, categories: List<String>) {
-        val normalized = normalizeTags(categories)
-        if (normalized == task.categories) return
-        store.replaceEntity(task, task.copy(categories = normalized, lastModified = clock.now(), isDirty = true))
-    }
-
-    // --- checks -----------------------------------------------------------------
-
-    /**
-     * The ids [selection] matches. A row URI's plain `<id column> = N` is checked
-     * against the store directly; anything else runs against the snapshot.
-     */
-    private fun ids(table: ProviderTable, selection: String?, args: Array<out String>?): List<Long> {
-        singleId(table, selection, args)?.let { id ->
-            val exists = when (table) {
-                ProviderTable.TASKS -> database.tasks().entity(id)?.isDeleted == false
-                ProviderTable.PROPERTIES -> propertyRef(id) != null
-                else -> true
-            }
-            return listOfNotNull(id.takeIf { exists })
-        }
-        return source.rows(table, listOf(table.idColumn), selection, args).map { it.single() as Long }
-    }
-
-    private fun singleId(table: ProviderTable, selection: String?, args: Array<out String>?): Long? {
-        val match = SINGLE_ROW.matchEntire(selection ?: return null) ?: return null
-        if (match.groupValues[1] != table.idColumn) return null
-        val value = match.groupValues[2]
-        return when {
-            value == "?" -> args?.singleOrNull()?.trim()?.toLongOrNull()
-            args.isNullOrEmpty() -> value.toLongOrNull()
-            else -> null
-        }
-    }
-
-    private fun requireFreeUid(listId: Long, uid: String) {
-        require(database.tasks().byUid(listId, uid)?.isDeleted != false) { "List $listId already has a task $uid" }
-    }
-
-    private fun liveTask(taskId: Long): TaskEntity {
-        val task = requireNotNull(database.tasks().entity(taskId)?.takeUnless { it.isDeleted }) { "No task $taskId" }
-        requireWritableList(task.listId)
-        return task
-    }
-
-    private fun requireWritableList(listId: Long) {
-        val list = requireNotNull(database.taskLists().entity(listId)) { "No task list $listId" }
-        if (list.isReadOnly) throw UnsupportedOperationException("Task list $listId is read-only")
-    }
-
-    /** A parent has to be a live, top-level task in the same list, and not one of the task's own subtasks. */
-    private fun requireParent(task: TaskEntity) {
-        var parentId = task.parentId ?: return
-        val parent = database.tasks().entity(parentId)?.takeUnless { it.isDeleted }
-        require(parent != null && parent.masterId == null) { "No task $parentId to be a parent" }
-        require(parent.listId == task.listId) { "A subtask has to be in its parent's list" }
-        val seen = HashSet<Long>()
-        while (true) {
-            require(parentId != task.id) { "Task ${task.id} cannot be its own ancestor" }
-            if (!seen.add(parentId)) break
-            parentId = database.tasks().entity(parentId)?.parentId ?: break
-        }
-    }
-
-    private fun requireSame(v: Values, column: String, expected: Long) {
-        if (column in v) require(v.long(column) == expected) { "A property's $column cannot change" }
-    }
-
-    private fun zone(): String = ZoneId.systemDefault().id
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/provider/SnapshotDatabase.kt

@@ -1,88 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.provider
-
-import android.content.ContentValues
-import android.database.Cursor
-import android.database.MatrixCursor
-import android.database.sqlite.SQLiteDatabase
-import android.database.sqlite.SQLiteQueryBuilder
-import android.os.Build
-import androidx.core.database.sqlite.transaction
-
-/**
- * An in-memory SQLite copy of a [ProviderSnapshot], so a client's own
- * `selection`, `selectionArgs` and `sortOrder` run as SQL exactly as they would
- * against OpenTasks. Holds only what the caller may already read.
- *
- * Not thread-safe; [ProviderSnapshotSource] serialises access.
- */
-internal class SnapshotDatabase {
-
-    private val db: SQLiteDatabase = SQLiteDatabase.create(null).apply {
-        ProviderTable.entries.forEach { table ->
-            execSQL(
-                "CREATE TABLE ${table.path} (" +
-                    table.columns.joinToString { (name, type) -> "$name $type" } + ")",
-            )
-        }
-    }
-
-    fun load(snapshot: ProviderSnapshot) {
-        db.transaction {
-            ProviderTable.entries.forEach { table ->
-                delete(table.path, null, null)
-                snapshot.rows[table].orEmpty().forEach { insertOrThrow(table.path, null, it.toContentValues()) }
-            }
-        }
-    }
-
-    /**
-     * Runs the query and copies the result out, so the cursor a client holds
-     * survives the next [load].
-     */
-    fun query(
-        table: ProviderTable,
-        projection: Array<out String>?,
-        selection: String?,
-        selectionArgs: Array<out String>?,
-        sortOrder: String?,
-    ): Cursor {
-        val builder = SQLiteQueryBuilder().apply {
-            tables = table.path
-            isStrict = true
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-                isStrictColumns = true
-                isStrictGrammar = true
-            }
-            projectionMap = table.columns.associate { (name, _) -> name to name }
-        }
-        builder.query(db, projection, selection, selectionArgs, null, null, sortOrder).use { source ->
-            val copy = MatrixCursor(source.columnNames, source.count)
-            while (source.moveToNext()) {
-                copy.addRow(
-                    Array(source.columnCount) { column ->
-                        when (source.getType(column)) {
-                            Cursor.FIELD_TYPE_NULL -> null
-                            Cursor.FIELD_TYPE_INTEGER -> source.getLong(column)
-                            Cursor.FIELD_TYPE_FLOAT -> source.getDouble(column)
-                            Cursor.FIELD_TYPE_BLOB -> source.getBlob(column)
-                            else -> source.getString(column)
-                        }
-                    },
-                )
-            }
-            return copy
-        }
-    }
-
-    private fun ProviderRow.toContentValues() = ContentValues(size).also { values ->
-        forEach { (key, value) ->
-            when (value) {
-                null -> values.putNull(key)
-                is Long -> values.put(key, value)
-                is Int -> values.put(key, value)
-                is String -> values.put(key, value)
-                else -> values.put(key, value.toString())
-            }
-        }
-    }
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/room/AlarmLift.kt

@@ -1,101 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.room
-
-import de.jeanlucmakiola.agendula.domain.ical.ICalComponent
-import de.jeanlucmakiola.agendula.domain.ical.ICalParser
-import de.jeanlucmakiola.agendula.domain.ical.ICalProperty
-import de.jeanlucmakiola.agendula.domain.ical.ICalSerializer
-import de.jeanlucmakiola.agendula.domain.ical.ICalValues
-import kotlin.math.roundToLong
-import kotlin.time.Instant
-
-/**
- * Lifts claimable `VALARM`s out of a residue written before v3 synced them.
- *
- * ⚠️ Frozen with [TasksDatabase.MIGRATION_2_3]: a copy of `AlarmCodec`'s claim
- * rule as it stood then, not a call into it, so a later change to what the
- * codec claims cannot change what this migration produced for an earlier
- * upgrader.
- */
-internal object AlarmLift {
-
-    /** The task columns the claim rule reads. */
-    data class Task(
-        val dtstart: Instant?,
-        val due: Instant?,
-        val isAllDay: Boolean,
-        val recurring: Boolean,
-    )
-
-    data class Alarm(val minutesBefore: Int, val reference: AlarmReference, val uid: String?, val raw: String)
-
-    /** The lifted alarms and the residue without them, or `null` residue when nothing is left. */
-    data class Result(val alarms: List<Alarm>, val residue: String?)
-
-    private const val DAY_MINUTES = 24 * 60
-    private const val MAX_RAW_BYTES = 25 * 1024
-
-    fun lift(residue: String?, task: Task): Result {
-        val component = parse(residue) ?: return Result(emptyList(), residue)
-        val alarms = mutableListOf<Alarm>()
-        val kept = component.components.filter { sub ->
-            if (!sub.name.equals("VALARM", ignoreCase = true)) return@filter true
-            val alarm = claim(sub, task) ?: return@filter true
-            alarms += alarm
-            false
-        }
-        if (alarms.isEmpty()) return Result(emptyList(), residue)
-        val rest = ICalSerializer.serializeProperties(component.properties) + ICalSerializer.serializeAll(kept)
-        return Result(alarms, rest.ifEmpty { null })
-    }
-
-    private fun claim(alarm: ICalComponent, task: Task): Alarm? {
-        val action = alarm.property("ACTION")?.value?.trim()?.uppercase()
-        if (action != "DISPLAY" && action != "AUDIO") return null
-        if (alarm.property("X-APPLE-DEFAULT-ALARM")?.value?.trim().equals("TRUE", ignoreCase = true)) return null
-        if (listOf("X-APPLE-PROXIMITY", "PROXIMITY", "REPEAT", "DURATION", "RELATED-TO").any { alarm.property(it) != null }) {
-            return null
-        }
-        if (alarm.components.isNotEmpty()) return null
-        val trigger = alarm.properties("TRIGGER").singleOrNull() ?: return null
-        val value = trigger.value.trim()
-        if (value.startsWith("19760401T005545Z")) return null
-        val absolute = trigger.param("VALUE").equals("DATE-TIME", ignoreCase = true) ||
-            (!value.startsWith("P", ignoreCase = true) && !value.startsWith("-") && !value.startsWith("+"))
-        val (minutes, reference) = (if (absolute) absolute(trigger, task) else relative(trigger, task)) ?: return null
-        val raw = ICalSerializer.serialize(alarm)
-        if (raw.toByteArray(Charsets.UTF_8).size > MAX_RAW_BYTES) return null
-        val uid = (alarm.property("X-WR-ALARMUID") ?: alarm.property("UID"))?.value?.trim()?.takeIf { it.isNotEmpty() }
-        return Alarm(minutes, reference, uid, raw)
-    }
-
-    private fun relative(trigger: ICalProperty, task: Task): Pair<Int, AlarmReference>? {
-        val seconds = ICalValues.parseDuration(trigger.value) ?: return null
-        val reference = when {
-            trigger.param("RELATED").equals("END", ignoreCase = true) ->
-                if (task.due != null) AlarmReference.DUE else return null
-            task.dtstart != null && task.dtstart != task.due -> AlarmReference.START
-            task.due != null -> AlarmReference.DUE
-            else -> return null
-        }
-        val before = -seconds
-        val minutes = if (task.isAllDay) days(before) else if (before % 60 != 0L) return null else before / 60
-        return minutes.takeIf { it in 0..Int.MAX_VALUE }?.let { it.toInt() to reference }
-    }
-
-    private fun absolute(trigger: ICalProperty, task: Task): Pair<Int, AlarmReference>? {
-        if (task.recurring) return null
-        val due = task.due ?: return null
-        val at = (ICalValues.parseTime(trigger) as? ICalValues.TimeValue.Timed)
-            ?.takeIf { it.tzid == null }?.instant ?: return null
-        val before = (due - at).inWholeSeconds
-        val minutes = if (task.isAllDay) days(before) else Math.floorDiv(before, 60L)
-        return minutes.takeIf { it in 0..Int.MAX_VALUE }?.let { it.toInt() to AlarmReference.DUE }
-    }
-
-    private fun days(seconds: Long): Long = (seconds / 86_400.0).roundToLong() * DAY_MINUTES
-
-    private fun parse(text: String?): ICalComponent? {
-        if (text.isNullOrEmpty()) return null
-        return runCatching { ICalParser.parse("BEGIN:VTODO\r\n$text\r\nEND:VTODO\r\n") }.getOrNull()
-    }
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/room/CategoriesLift.kt

@@ -1,44 +0,0 @@
-package de.jeanlucmakiola.agendula.data.tasks.room
-
-import de.jeanlucmakiola.agendula.domain.ical.ICalComponent
-import de.jeanlucmakiola.agendula.domain.ical.ICalParser
-import de.jeanlucmakiola.agendula.domain.ical.ICalProperty
-import de.jeanlucmakiola.agendula.domain.ical.ICalSerializer
-import de.jeanlucmakiola.agendula.domain.ical.ICalValues
-
-/**
- * Lifts `CATEGORIES` out of a residue written before v2 claimed it.
- *
- * ⚠️ Frozen with [TasksDatabase.MIGRATION_1_2]. The claim rule is copied here
- * rather than shared with the mapper, so a later change to what the mapper
- * claims cannot change what this migration produced for an earlier upgrader.
- */
-internal object CategoriesLift {
-
-    /**
-     * Every copy's values merged, and the residue with the one claimed line
-     * removed — or `null` for the residue when nothing was claimed, so the caller
-     * leaves the stored one alone.
-     */
-    data class Result(val categories: List<String>, val residue: String?, val claimed: Boolean)
-
-    fun lift(residue: String?): Result {
-        val component = parse(residue) ?: return Result(emptyList(), residue, claimed = false)
-        val copies = component.properties.filter { it.name.equals("CATEGORIES", ignoreCase = true) }
-        val values = copies.flatMap(::values)
-        val claim = copies.singleOrNull()?.takeIf {
-            it.params.isEmpty() && values.isNotEmpty() && ICalValues.formatTextList(values) == it.value
-        } ?: return Result(values, residue, claimed = false)
-        val rest = ICalSerializer.serializeProperties(component.properties.filterNot { it === claim }) +
-            ICalSerializer.serializeAll(component.components)
-        return Result(values, rest.ifEmpty { null }, claimed = true)
-    }
-
-    private fun values(property: ICalProperty): List<String> =
-        ICalValues.parseTextList(property.value).map(String::trim).filter(String::isNotEmpty).distinct()
-
-    private fun parse(text: String?): ICalComponent? {
-        if (text.isNullOrEmpty()) return null
-        return runCatching { ICalParser.parse("BEGIN:VTODO\r\n$text\r\nEND:VTODO\r\n") }.getOrNull()
-    }
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/room/Converters.kt

@@ -2,8 +2,6 @@ package de.jeanlucmakiola.agendula.data.tasks.room
 
 import androidx.room.TypeConverter
 import de.jeanlucmakiola.agendula.domain.TaskStatus
-import de.jeanlucmakiola.agendula.domain.ical.ICalValues
-import de.jeanlucmakiola.agendula.domain.normalizeTags
 import de.jeanlucmakiola.agendula.domain.statusFromInt
 import de.jeanlucmakiola.agendula.domain.toInt
 import kotlin.time.Instant
@@ -38,17 +36,3 @@ object Converters {
     fun alarmReferenceFrom(value: String): AlarmReference =
         runCatching { AlarmReference.valueOf(value) }.getOrDefault(AlarmReference.DUE)
 }
-
-/**
- * [TaskEntity.categories] stored as a `CATEGORIES` value, so escaping has one
- * home; empty when there are none. Scoped to that field rather than the
- * database, so no other `List<String>` picks up iCalendar escaping by accident.
- */
-object CategoriesConverter {
-    @TypeConverter
-    fun toText(value: List<String>): String = ICalValues.formatTextList(normalizeTags(value))
-
-    @TypeConverter
-    fun fromText(value: String): List<String> =
-        if (value.isEmpty()) emptyList() else normalizeTags(ICalValues.parseTextList(value))
-}

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/room/Entities.kt

@@ -5,10 +5,8 @@ import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.Index
 import androidx.room.PrimaryKey
-import androidx.room.TypeConverters
 import de.jeanlucmakiola.agendula.domain.PRIORITY_NONE
 import de.jeanlucmakiola.agendula.domain.TaskStatus
-import java.util.UUID
 import kotlin.time.Instant
 
 /**
@@ -145,10 +143,6 @@ data class TaskEntity(
     @ColumnInfo(name = "url") val url: String? = null,
     /** ARGB override for the list colour. */
     @ColumnInfo(name = "color") val color: Int? = null,
-    /** RFC 5545 `CATEGORIES` — the tags — in the spelling each task carries them. */
-    @ColumnInfo(name = "categories", defaultValue = "")
-    @field:TypeConverters(CategoriesConverter::class)
-    val categories: List<String> = emptyList(),
 
     // state
     @ColumnInfo(name = "status", defaultValue = "0") val status: TaskStatus = TaskStatus.NEEDS_ACTION,
@@ -200,31 +194,12 @@ data class TaskEntity(
      * verbatim on write so a round-trip cannot silently lose a field.
      */
     @ColumnInfo(name = "unknown_properties") val unknownProperties: String? = null,
-
-    // reminders
-    /**
-     * Another client removed this task's last alarm, so it has none — not "use
-     * the default". A task without reminder rows normally takes the list's or
-     * the app's default, which is right for one that never had any (a client
-     * that does not write alarms), and wrong for one whose alarms were turned
-     * off elsewhere: it would keep ringing here. Set by a download that takes
-     * the last row away; cleared as soon as the task has a reminder again.
-     */
-    @ColumnInfo(name = "reminders_off", defaultValue = "0") val remindersOff: Boolean = false,
 )
 
 /** What [TaskAlarmEntity.minutesBefore] counts back from. */
 enum class AlarmReference { DUE, START }
 
-/**
+/** A reminder lead on a task. Positive [minutesBefore] is *before* [reference]. */
- * A reminder lead on a task. Positive [minutesBefore] is *before* [reference].
- *
- * Synced as a `VALARM` (see `AlarmCodec`). [uid] is the alarm's identity on the
- * wire — `X-WR-ALARMUID` / RFC 9074 `UID` — minted when the row is created, so
- * every upload of the same alarm names it the same way. [raw] is the `VALARM`
- * this row was read from, re-emitted verbatim while the row still means what
- * it did, so another client's `ACKNOWLEDGED`, `X-*` and trigger form survive.
- */
 @Entity(
     tableName = "task_alarms",
     foreignKeys = [
@@ -244,6 +219,4 @@ data class TaskAlarmEntity(
     @ColumnInfo(name = "minutes_before") val minutesBefore: Int,
     @ColumnInfo(name = "reference", defaultValue = "DUE") val reference: AlarmReference = AlarmReference.DUE,
     @ColumnInfo(name = "message") val message: String? = null,
-    @ColumnInfo(name = "uid", defaultValue = "") val uid: String = UUID.randomUUID().toString(),
-    @ColumnInfo(name = "raw") val raw: String? = null,
 )

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/room/RoomTaskMapper.kt

@@ -49,7 +49,6 @@ object RoomTaskMapper {
         description = row.task.description,
         location = row.task.location,
         url = row.task.url,
-        tags = row.task.categories,
         priority = priorityFromICal(row.task.priority),
         status = row.task.status,
         percentComplete = row.task.percentComplete,
@@ -80,7 +79,6 @@ object RoomTaskMapper {
         description = task.description,
         location = task.location,
         url = task.url,
-        tags = task.categories,
         priority = priorityFromICal(task.priority),
         status = task.status,
         percentComplete = task.percentComplete,

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/room/RoomTasksDataSource.kt

@@ -2,8 +2,8 @@ package de.jeanlucmakiola.agendula.data.tasks.room
 
 import androidx.room.InvalidationTracker
 import de.jeanlucmakiola.agendula.data.tasks.TaskQuery
-import de.jeanlucmakiola.agendula.domain.TaskReminder
+import de.jeanlucmakiola.agendula.data.tasks.TaskReminder
-import de.jeanlucmakiola.agendula.domain.TaskReminderOrder
+import de.jeanlucmakiola.agendula.data.tasks.editable
 import de.jeanlucmakiola.agendula.data.tasks.TaskWriteFailedException
 import de.jeanlucmakiola.agendula.data.tasks.TasksDataSource
 import de.jeanlucmakiola.agendula.domain.Task
@@ -31,54 +31,7 @@ private val SERIES_LINES = listOf("EXDATE", "RDATE", "RRULE", "RECURRENCE-ID", "
 /** Enough to count every occurrence before a split point without bounding a real series. */
 internal const val SPLIT_COUNT_CEILING = 100_000
 
-/** The window every read of the store expands a series over. */
+private val OBSERVED_TABLES = arrayOf("tasks", "task_lists", "task_alarms", "accounts")
-internal fun expansionWindow(now: Instant) = ExpansionWindow(
-    from = now - WINDOW_BACK,
-    until = now + WINDOW_FORWARD,
-    pivot = now,
-)
-
-/**
- * One occurrence's resolved start and due. A timed series keeps each
- * occurrence's duration; a due-anchored one has no start to offset from, so
- * the anchor *is* the due date.
- */
-internal fun occurrenceTimes(master: TaskEntity, anchor: Instant): Pair<Instant?, Instant?> {
-    if (master.dtstart == null) return null to anchor
-    val length = master.due?.let { it - master.dtstart }
-    return anchor to length?.let { anchor + it }
-}
-
-/** One occurrence of a series: its anchor, the override replacing it if any, and its resolved times. */
-internal class SeriesOccurrence(
-    val anchor: Instant,
-    val override: TaskEntity?,
-    val start: Instant?,
-    val due: Instant?,
-    val distance: Int?,
-)
-
-/**
- * Every occurrence of [master] inside the expansion window, with any
- * `RECURRENCE-ID` override substituted for the occurrence it replaces, or
- * `null` when [master] does not recur.
- */
-internal fun seriesOccurrences(master: TaskEntity, overrides: List<TaskEntity>, now: Instant): List<SeriesOccurrence>? {
-    val spec = master.recurrenceSpec() ?: return null
-    val anchors = RecurrenceExpander.expand(spec, expansionWindow(now))
-    val distances = RecurrenceExpander.distancesFromCurrent(anchors, now)
-    val byAnchor = overrides.associateBy { it.recurrenceId }
-    return anchors.mapIndexed { index, anchor ->
-        val override = byAnchor[anchor]
-        val (start, due) = if (override != null) override.dtstart to override.due else occurrenceTimes(master, anchor)
-        SeriesOccurrence(anchor, override, start, due, distances.getOrNull(index))
-    }
-}
-
-internal val OBSERVED_TABLES = arrayOf("tasks", "task_lists", "task_alarms", "accounts")
-
-/** Distinct alarm texts whose `ACKNOWLEDGED` is remembered between scheduler passes. */
-private const val ACK_CACHE_SIZE = 512
 
 /**
  * [TasksDataSource] over Agendula's own Room store.
@@ -148,32 +101,19 @@ class RoomTasksDataSource @Inject constructor(
             .flatMap { occurrencesOf(it, tasks.overrides(it.task.id), now) }
     }
 
-    /** One transaction, so a failure part-way leaves the subtree whole. */
-    override fun deleteWithSubtasks(taskId: Long) = tx { super.deleteWithSubtasks(taskId) }
-
-    override fun subtaskIds(parentTaskId: Long): List<Long> =
-        tasks.subtasks(parentTaskId).map { it.task.id }.filter { it != parentTaskId }
-
     override fun exportTasks(listId: Long): List<ExportTask> =
         tasks.exportTasks(listId).map(RoomTaskMapper::exportTask)
 
-    override fun reminders(): Map<Long, List<TaskReminder>> {
+    override fun reminders(): Map<Long, List<TaskReminder>> =
-        val stored = alarms.all().groupBy({ it.taskId }) { it.asReminder().copy(acknowledgedAt = acknowledged(it)) }
+        alarms.all().groupBy({ it.taskId }) {
-        // Turned off elsewhere: present and empty, so nothing falls back to a default.
+            TaskReminder(
-        return stored + alarms.remindersOff().filterNot(stored::containsKey).associateWith { emptyList() }
+                minutesBefore = it.minutesBefore,
-    }
+                fromStart = it.reference == AlarmReference.START,
-
+            )
-    /** `raw` → its `ACKNOWLEDGED`, so a scheduler pass does not re-parse every alarm. */
-    private val acknowledgements = object : LinkedHashMap<String, Instant?>(64, 0.75f, true) {
-        override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, Instant?>) = size > ACK_CACHE_SIZE
-    }
-
-    private fun acknowledged(row: TaskAlarmEntity): Instant? {
-        val raw = row.raw ?: return null
-        return synchronized(acknowledgements) {
-            if (raw in acknowledgements) acknowledgements[raw] else row.acknowledgedAt().also { acknowledgements[raw] = it }
         }
-    }
+
+    override fun alarms(): Map<Long, TaskReminder> =
+        reminders().mapNotNull { (id, list) -> list.editable()?.let { id to it } }.toMap()
 
     /**
      * Every occurrence of [row] inside the expansion window, with any
@@ -183,69 +123,70 @@ class RoomTasksDataSource @Inject constructor(
      * [Task.occurrenceStart], so it keys and edits by task id exactly as before.
      */
     private fun occurrencesOf(row: TaskRow, overrides: List<TaskEntity>, now: Instant): List<Task> {
-        val occurrences = seriesOccurrences(row.task, overrides, now) ?: return listOf(RoomTaskMapper.task(row))
+        val spec = row.task.recurrenceSpec() ?: return listOf(RoomTaskMapper.task(row))
-        return occurrences.map { occurrence ->
+        val window = ExpansionWindow(
-            val override = occurrence.override
+            from = now - WINDOW_BACK,
+            until = now + WINDOW_FORWARD,
+            pivot = now,
+        )
+        val anchors = RecurrenceExpander.expand(spec, window)
+        if (anchors.isEmpty()) return emptyList()
+
+        val distances = RecurrenceExpander.distancesFromCurrent(anchors, now)
+        val byAnchor = overrides.associateBy { it.recurrenceId }
+
+        return anchors.mapIndexedNotNull { index, anchor ->
+            val override = byAnchor[anchor]
             if (override != null) {
                 RoomTaskMapper.task(
                     row = row.copy(task = override),
-                    occurrenceStart = occurrence.anchor,
+                    occurrenceStart = anchor,
-                    start = occurrence.start,
+                    start = override.dtstart,
-                    due = occurrence.due,
+                    due = override.due,
-                    distanceFromCurrent = occurrence.distance,
+                    distanceFromCurrent = distances[index],
                     seriesId = row.task.id,
                     recurrenceRule = row.task.rrule,
                 )
             } else {
+                val (start, due) = occurrenceTimes(row.task, anchor)
                 RoomTaskMapper.task(
                     row = row,
-                    occurrenceStart = occurrence.anchor,
+                    occurrenceStart = anchor,
-                    start = occurrence.start,
+                    start = start,
-                    due = occurrence.due,
+                    due = due,
-                    distanceFromCurrent = occurrence.distance,
+                    distanceFromCurrent = distances[index],
                 )
             }
         }
     }
 
+    /**
+     * One occurrence's resolved start and due. A timed series keeps each
+     * occurrence's duration; a due-anchored one has no start to offset from, so
+     * the anchor *is* the due date.
+     */
+    private fun occurrenceTimes(master: TaskEntity, anchor: Instant): Pair<Instant?, Instant?> {
+        if (master.dtstart == null) return null to anchor
+        val length = master.due?.let { it - master.dtstart }
+        return anchor to length?.let { anchor + it }
+    }
+
     // --- writes ---------------------------------------------------------------
 
-    override fun insertTask(form: TaskForm, reminders: List<TaskReminder>?): Long {
+    override fun insertTask(form: TaskForm): Long {
         if (lists.exists(form.listId) == 0) throw TaskWriteFailedException("insert task: no list ${form.listId}")
         val entity = TaskFormWriter.newTask(form, uid = UUID.randomUUID().toString(), now = clock.now(), tzId = zone())
-        var id = 0L
+        return tasks.insert(TaskFormWriter.withRule(entity, form.rrule)).also { writes.onWritten(setOf(form.listId)) }
-        tx {
-            id = tasks.insert(TaskFormWriter.withRule(entity, form.rrule))
-            reminders?.let { alarms.syncForTask(id, it) }
-            writes.onWritten(setOf(form.listId))
-        }
-        return id
     }
 
-    /**
+    override fun updateTask(taskId: Long, form: TaskForm) {
-     * [reminders] as [taskId]'s own, inside the caller's transaction.
-     *
-     * ⚠️ Part of the task write rather than a second call after it. Once
-     * reminders sync, a sync landing between the two would upload the task
-     * without them, or with the ones it is about to lose.
-     */
-    private fun writeReminders(taskId: Long, reminders: List<TaskReminder>?) {
-        if (reminders == null) return
-        alarms.syncForTask(taskId, reminders)
-    }
-
-    private fun storedReminders(taskId: Long): List<TaskReminder> =
-        alarms.forTask(taskId).map { it.asReminder() }.sortedWith(TaskReminderOrder)
-
-    override fun updateTask(taskId: Long, form: TaskForm, reminders: List<TaskReminder>?) = tx {
         val current = tasks.entity(taskId) ?: throw TaskWriteFailedException("update task $taskId")
         val edited = TaskFormWriter.apply(current, form, clock.now(), zone())
-        writeReminders(taskId, reminders)
         if (current.masterId == null && edited.listId != current.listId) {
             if (lists.exists(edited.listId) == 0) throw TaskWriteFailedException("move task: no list ${edited.listId}")
-            move(current, TaskFormWriter.withRule(edited, form.rrule))
+            database.runInTransaction { move(current, TaskFormWriter.withRule(edited, form.rrule)) }
             writes.onWritten(setOf(current.listId, edited.listId))
-            return@tx
+            return
         }
         // ⚠️ An override's list and parent are the master's, the rule
         // [updateInstance] states and this path has to keep. An overridden
@@ -279,23 +220,8 @@ class RoomTasksDataSource @Inject constructor(
         plan.tombstone?.let { tasks.insert(it) }
     }
 
-    override fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?) = tx {
+    override fun updateSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm) = tx {
         val master = seriesMaster(seriesId)
-        // ⚠️ The overrides too, where they still carry the series' reminders.
-        // A fork copies them as a snapshot — completing one occurrence is
-        // enough — and each override uploads its own VALARMs, so leaving them
-        // would keep ringing those occurrences at the old lead everywhere. One
-        // whose reminders were set for that occurrence alone keeps them.
-        if (reminders != null) {
-            val before = storedReminders(master.id)
-            tasks.overrides(master.id)
-                .filter { storedReminders(it.id) == before }
-                .forEach {
-                    writeReminders(it.id, reminders)
-                    if (form.remindersChosen && reminders.isEmpty()) alarms.setRemindersOff(it.id, true)
-                }
-        }
-        writeReminders(master.id, reminders)
         val (start, due) = resolvedTimes(master, occurrenceStart)
         val edited = TaskFormWriter.seriesEdit(master, start, due, form, clock.now(), zone())
         // A moved or re-ruled series no longer generates the anchors its
@@ -311,14 +237,14 @@ class RoomTasksDataSource @Inject constructor(
         writes.onWritten(setOf(master.listId, edited.listId))
     }
 
-    override fun splitSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?): Long {
+    override fun splitSeries(seriesId: Long, occurrenceStart: Instant, form: TaskForm): Long {
         var created = seriesId
         tx {
             val master = seriesMaster(seriesId)
             val spec = master.recurrenceSpec()
             val anchor = master.recurrenceAnchor
             if (spec == null || anchor == null || occurrenceStart <= anchor) {
-                updateSeries(seriesId, occurrenceStart, form, reminders)
+                updateSeries(seriesId, occurrenceStart, form)
                 return@tx
             }
             val now = clock.now()
@@ -361,9 +287,7 @@ class RoomTasksDataSource @Inject constructor(
             else TaskFormWriter.shiftValues(laterExceptions, delta, master.timezone ?: zone())
             val fresh = TaskFormWriter.withRule(applied, rule).let { if (it.rrule != null) it.copy(exdate = exceptions) else it }
             val newId = tasks.insert(fresh)
-            // A new UID, so a new resource: the alarms are copies, not the same ones.
+            alarms.forTask(master.id).forEach { alarms.insert(it.copy(id = 0, taskId = newId)) }
-            alarms.copyToTask(master.id, newId, sameResource = false)
-            writeReminders(newId, reminders)
 
             val unmoved = fresh.dtstart == start && fresh.due == due && sameRule
             tasks.overrides(master.id)
@@ -398,7 +322,8 @@ class RoomTasksDataSource @Inject constructor(
         val master = tasks.entity(seriesId) ?: return@tx
         val anchor = master.recurrenceAnchor
         if (anchor == null || occurrenceStart <= anchor) {
-            deleteWithSubtasks(seriesId)
+            tasks.subtasks(seriesId).forEach { deleteTask(it.task.id) }
+            deleteTask(seriesId)
             return@tx
         }
         tasks.update(TaskFormWriter.endedBefore(master, occurrenceStart, clock.now(), zone()))
@@ -427,7 +352,7 @@ class RoomTasksDataSource @Inject constructor(
      * which is the model least compatible with sync; the override shares its
      * master's UID, which is exactly what makes it an override.
      */
-    override fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm, reminders: List<TaskReminder>?) = tx {
+    override fun updateInstance(taskId: Long, occurrenceStart: Instant, form: TaskForm) {
         val master = tasks.entity(taskId) ?: throw TaskWriteFailedException("update instance $taskId")
         val now = clock.now()
         val existing = tasks.override(taskId, occurrenceStart)
@@ -436,9 +361,8 @@ class RoomTasksDataSource @Inject constructor(
             // master's, whatever the form was carrying.
             val edited = TaskFormWriter.apply(existing, form, now, zone())
             tasks.update(edited.copy(listId = master.listId, parentId = master.parentId))
-            writeReminders(existing.id, reminders)
             writes.onWritten(setOf(master.listId))
-            return@tx
+            return
         }
         val (start, due) = occurrenceTimes(master, occurrenceStart)
         val fork = TaskFormWriter.apply(
@@ -450,19 +374,28 @@ class RoomTasksDataSource @Inject constructor(
         // The list and parent come from the master: moving one occurrence between
         // lists or parents is not something the override model expresses.
         val id = tasks.insert(fork.copy(listId = master.listId, parentId = master.parentId))
-        // The occurrence starts out with the series' reminders and then takes
+        alarms.replaceAllForTask(id, alarms.forTask(taskId))
-        // the form's — the master's own are never touched.
-        alarms.copyToTask(taskId, id, sameResource = true)
-        writeReminders(id, reminders)
         writes.onWritten(setOf(master.listId))
     }
 
-    override fun setReminders(taskId: Long, reminders: List<TaskReminder>) = tx {
+    override fun setAlarm(taskId: Long, minutesBeforeDue: Int?) {
-        if (!alarms.syncForTask(taskId, reminders)) return@tx
+        alarms.replaceEditable(
-        // The reminders are part of the VTODO now, so changing them is an edit.
+            taskId,
-        val current = tasks.entity(taskId) ?: return@tx
+            minutesBeforeDue?.let { TaskAlarmEntity(taskId = taskId, minutesBefore = it) },
-        tasks.update(current.copy(isDirty = true, lastModified = clock.now()))
+        )
-        writes.onWritten(setOf(current.listId))
+    }
+
+    override fun setReminders(taskId: Long, reminders: List<TaskReminder>) {
+        alarms.replaceAllForTask(
+            taskId,
+            reminders.map {
+                TaskAlarmEntity(
+                    taskId = taskId,
+                    minutesBefore = it.minutesBefore,
+                    reference = if (it.fromStart) AlarmReference.START else AlarmReference.DUE,
+                )
+            },
+        )
     }
 
     override fun setCancelled(taskId: Long, cancelled: Boolean) {
@@ -514,7 +447,7 @@ class RoomTasksDataSource @Inject constructor(
         }
         val (start, due) = occurrenceTimes(master, occurrenceStart)
         val id = tasks.insert(write(newOverride(master, taskId, occurrenceStart, start, due)))
-        alarms.copyToTask(taskId, id, sameResource = true)
+        alarms.replaceAllForTask(id, alarms.forTask(taskId))
         writes.onWritten(setOf(master.listId))
     }
 
@@ -582,47 +515,6 @@ class RoomTasksDataSource @Inject constructor(
         writes.onWritten(setOf(current.listId))
     }
 
-    // --- whole-row writes, for the published provider --------------------------
-
-    /** Inserts [entity] as it stands, for a client that wrote the row itself. */
-    internal fun insertEntity(entity: TaskEntity): Long {
-        if (lists.exists(entity.listId) == 0) throw TaskWriteFailedException("insert task: no list ${entity.listId}")
-        return tasks.insert(entity).also { writes.onWritten(setOf(entity.listId)) }
-    }
-
-    /**
-     * Writes [edited] over [current] under the rules [updateTask] and
-     * [updateSeries] keep: a task moves lists through [TaskMove], an override
-     * keeps its master's list and parent, and a series whose anchor or rule
-     * changed drops the overrides it no longer generates.
-     */
-    internal fun replaceEntity(current: TaskEntity, edited: TaskEntity) {
-        tx {
-            val reshaped = current.masterId == null && current.recurrenceSpec() != null &&
-                (edited.dtstart != current.dtstart || edited.due != current.due || edited.rrule != current.rrule)
-            if (reshaped) tasks.overrides(current.id).forEach { tasks.delete(it.id) }
-            when {
-                current.masterId != null -> tasks.update(edited.copy(listId = current.listId, parentId = current.parentId))
-                edited.listId != current.listId -> {
-                    if (lists.exists(edited.listId) == 0) throw TaskWriteFailedException("move task: no list ${edited.listId}")
-                    move(current, edited)
-                }
-                else -> tasks.update(edited)
-            }
-        }
-        writes.onWritten(setOf(current.listId, edited.listId))
-    }
-
-    /** Adds, changes or removes one reminder, and marks its task changed so the reminder syncs. */
-    internal fun writeAlarm(taskId: Long, write: () -> Unit) {
-        val task = tasks.entity(taskId) ?: throw TaskWriteFailedException("alarm on task $taskId")
-        tx {
-            write()
-            tasks.update(task.copy(lastModified = clock.now(), isDirty = true))
-        }
-        writes.onWritten(setOf(task.listId))
-    }
-
     override fun createLocalList(name: String, color: Int): Long =
         lists.insert(TaskListEntity(name = name.trim(), color = color))
 

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/room/TaskAlarmDao.kt

@@ -4,11 +4,6 @@ import androidx.room.Dao
 import androidx.room.Insert
 import androidx.room.Query
 import androidx.room.Transaction
-import androidx.room.Update
-import de.jeanlucmakiola.agendula.domain.TaskReminder
-import de.jeanlucmakiola.agendula.domain.ical.ICalParser
-import de.jeanlucmakiola.agendula.domain.ical.ICalValues
-import kotlin.time.Instant
 
 /** Reads and writes over `task_alarms`. */
 @Dao
@@ -21,137 +16,37 @@ interface TaskAlarmDao {
     @Query("SELECT * FROM task_alarms WHERE task_id = :taskId ORDER BY id")
     fun forTask(taskId: Long): List<TaskAlarmEntity>
 
-    /** The reminders of several tasks in one query — one resource's rows, for an upload. */
-    @Query("SELECT * FROM task_alarms WHERE task_id IN (:taskIds) ORDER BY id")
-    fun forTasks(taskIds: List<Long>): List<TaskAlarmEntity>
-
-    @Query("SELECT * FROM task_alarms WHERE id = :id")
-    fun entity(id: Long): TaskAlarmEntity?
-
     @Insert
     fun insert(alarm: TaskAlarmEntity): Long
 
-    @Update
-    fun update(alarm: TaskAlarmEntity): Int
-
     @Query("DELETE FROM task_alarms WHERE id = :id")
     fun delete(id: Long): Int
 
     @Query("DELETE FROM task_alarms WHERE task_id = :taskId")
     fun deleteForTask(taskId: Long): Int
 
-    /** See [TaskEntity.remindersOff]. */
-    @Query("UPDATE tasks SET reminders_off = :off WHERE id = :taskId")
-    fun setRemindersOff(taskId: Long, off: Boolean): Int
-
-    /** The tasks whose alarms were turned off elsewhere — "none", not "the default". */
-    @Query("SELECT id FROM tasks WHERE reminders_off = 1")
-    fun remindersOff(): List<Long>
-
     /** Set the task's only reminder, or clear every one with `null`. */
     @Transaction
-    fun replaceForTask(taskId: Long, alarm: TaskAlarmEntity?) {
+    fun replaceForTask(taskId: Long, alarm: TaskAlarmEntity?) = replaceAllForTask(taskId, listOfNotNull(alarm))
+
+    /**
+     * Replace every reminder on the task. The rows that land are always new ones —
+     * ids are cleared so alarms lifted off another task (forking an occurrence
+     * copies the master's) insert instead of colliding.
+     */
+    @Transaction
+    fun replaceAllForTask(taskId: Long, alarms: List<TaskAlarmEntity>) {
         deleteForTask(taskId)
+        alarms.forEach { insert(it.copy(id = 0, taskId = taskId)) }
+    }
+
+    /**
+     * Set the task's editable reminder — its last before-due one — or clear it
+     * with `null`. Start-relative and additional reminders stay as they are.
+     */
+    @Transaction
+    fun replaceEditable(taskId: Long, alarm: TaskAlarmEntity?) {
+        forTask(taskId).lastOrNull { it.reference == AlarmReference.DUE }?.let { delete(it.id) }
         alarm?.let { insert(it.copy(id = 0, taskId = taskId)) }
     }
-
-    /**
-     * Make the task's reminders [wanted], touching only what differs.
-     *
-     * ⚠️ A diff, not a delete-and-reinsert. A row that is still wanted keeps its
-     * [TaskAlarmEntity.uid] and its [TaskAlarmEntity.raw] — which [TaskReminder]
-     * carries neither of, so a rewrite from it would give every save a new
-     * alarm identity on the server and throw away another client's `VALARM` the
-     * user never touched.
-     *
-     * Duplicates count: two identical leads are two rows.
-     *
-     * @return whether anything changed.
-     */
-    @Transaction
-    fun syncForTask(taskId: Long, wanted: List<TaskReminder>): Boolean {
-        val unmatched = wanted.map { it.lead }.toMutableList()
-        var changed = false
-        forTask(taskId).forEach { row ->
-            if (!unmatched.remove(row.asReminder())) {
-                delete(row.id)
-                changed = true
-            }
-        }
-        unmatched.forEach {
-            insert(it.toAlarmEntity(taskId))
-            changed = true
-        }
-        // A reminder of its own again, so the "turned off elsewhere" no longer holds.
-        if (wanted.isNotEmpty()) setRemindersOff(taskId, false)
-        return changed
-    }
-
-    /**
-     * Replace the task's reminders with what a download carried.
-     *
-     * Incoming alarms are matched to the rows already here by uid first, then by
-     * lead, so a reminder the server merely re-described keeps its row rather
-     * than being churned into a new one.
-     *
-     * A download that takes away every alarm the task had marks it
-     * [TaskEntity.remindersOff]; one that carries alarms clears that.
-     */
-    @Transaction
-    fun replaceFromServer(taskId: Long, incoming: List<TaskAlarmEntity>) {
-        val existing = forTask(taskId).toMutableList()
-        val hadAny = existing.isNotEmpty()
-        val placed = incoming.map { alarm ->
-            val match = existing.firstOrNull { it.uid == alarm.uid }
-                ?: existing.firstOrNull { it.asReminder() == alarm.asReminder() }
-            match?.let(existing::remove)
-            alarm.copy(id = match?.id ?: 0, taskId = taskId)
-        }
-        existing.forEach { delete(it.id) }
-        placed.forEach { if (it.id == 0L) insert(it) else update(it) }
-        when {
-            incoming.isNotEmpty() -> setRemindersOff(taskId, false)
-            hadAny -> setRemindersOff(taskId, true)
-        }
-    }
-
-    /**
-     * Copy [fromTaskId]'s reminders onto [toTaskId].
-     *
-     * [sameResource] is for an override forked inside the same series — the
-     * same `VTODO` UID, so the alarms keep their identity. Anything else is a
-     * different task on the server and gets fresh uids: two tasks naming one
-     * alarm is an identity no other client expects.
-     */
-    @Transaction
-    fun copyToTask(fromTaskId: Long, toTaskId: Long, sameResource: Boolean) {
-        forTask(fromTaskId).forEach { insert(if (sameResource) it.copy(id = 0, taskId = toTaskId) else it.freshCopy(toTaskId)) }
-    }
-}
-
-/** What the row means to the scheduler and the editor, without its identity. */
-fun TaskAlarmEntity.asReminder() = TaskReminder(minutesBefore, reference == AlarmReference.START)
-
-/** The inverse of [asReminder]: a new row, with an identity of its own. */
-fun TaskReminder.toAlarmEntity(taskId: Long) = TaskAlarmEntity(
-    taskId = taskId,
-    minutesBefore = minutesBefore,
-    reference = if (fromStart) AlarmReference.START else AlarmReference.DUE,
-)
-
-/** The same reminder on another task: what it means, never who it is on the server. */
-fun TaskAlarmEntity.freshCopy(taskId: Long) =
-    TaskAlarmEntity(taskId = taskId, minutesBefore = minutesBefore, reference = reference, message = message)
-
-/**
- * The `ACKNOWLEDGED` stamp of the `VALARM` the row was read from, if any.
- *
- * Read off [TaskAlarmEntity.raw] rather than kept in a column: it is the other
- * client's bookkeeping, and it changes only when a download replaces the row.
- */
-fun TaskAlarmEntity.acknowledgedAt(): Instant? {
-    val text = raw ?: return null
-    if (!text.contains("ACKNOWLEDGED", ignoreCase = true)) return null
-    val property = runCatching { ICalParser.parse(text) }.getOrNull()?.property("ACKNOWLEDGED") ?: return null
-    return (ICalValues.parseTime(property) as? ICalValues.TimeValue.Timed)?.instant
 }

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/room/TaskDao.kt

@@ -105,10 +105,6 @@ interface TaskDao {
     @Query("SELECT * FROM tasks WHERE list_id = :listId AND is_deleted = 0 AND master_id IS NULL")
     fun exportTasks(listId: Long): List<TaskEntity>
 
-    /** Every row but the tombstones, overrides included — what the published provider lays out. */
-    @Query("SELECT * FROM tasks WHERE is_deleted = 0")
-    fun live(): List<TaskEntity>
-
     @Query("SELECT * FROM tasks WHERE is_dirty = 1")
     fun dirty(): List<TaskEntity>
 

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/room/TaskFormWriter.kt

@@ -3,7 +3,6 @@ package de.jeanlucmakiola.agendula.data.tasks.room
 import de.jeanlucmakiola.agendula.domain.TaskForm
 import de.jeanlucmakiola.agendula.domain.TaskStatus
 import de.jeanlucmakiola.agendula.domain.ical.ICalValues
-import de.jeanlucmakiola.agendula.domain.normalizeTags
 import de.jeanlucmakiola.agendula.domain.toICal
 import kotlin.time.Duration.Companion.days
 import kotlin.time.Duration.Companion.seconds
@@ -51,7 +50,6 @@ object TaskFormWriter {
             description = form.description?.trim()?.ifBlank { null },
             location = form.location?.trim()?.ifBlank { null },
             url = form.url?.trim()?.ifBlank { null },
-            categories = normalizeTags(form.tags),
             priority = form.priority.toICal(),
             percentComplete = percent,
             status = statusFor(percent, current.status),
@@ -63,7 +61,6 @@ object TaskFormWriter {
             isAllDay = form.isAllDay,
             timezone = if (timed) tzId else null,
             parentId = form.parentId?.takeIf { it > 0 },
-            remindersOff = if (form.remindersChosen) form.reminders.isEmpty() else current.remindersOff,
             lastModified = now,
             isDirty = true,
         )

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/room/TasksDatabase.kt

@@ -3,10 +3,6 @@ package de.jeanlucmakiola.agendula.data.tasks.room
 import androidx.room.Database
 import androidx.room.RoomDatabase
 import androidx.room.TypeConverters
-import androidx.room.migration.Migration
-import androidx.sqlite.db.SupportSQLiteDatabase
-import java.util.UUID
-import kotlin.time.Instant
 
 /**
  * Agendula's own task store. Four tables, designed from
@@ -22,7 +18,7 @@ import kotlin.time.Instant
         TaskEntity::class,
         TaskAlarmEntity::class,
     ],
-    version = 3,
+    version = 1,
     exportSchema = true,
 )
 @TypeConverters(Converters::class)
@@ -34,144 +30,5 @@ abstract class TasksDatabase : RoomDatabase() {
 
     companion object {
         const val NAME = "agendula-tasks.db"
-
-        /**
-         * v2 adds `categories`. Until then `CATEGORIES` lived in the residue, and
-         * an unchanged task is never downloaded again, so the values are lifted
-         * out here. Not marked dirty: nothing changed on the server's side.
-         */
-        val MIGRATION_1_2 = object : Migration(1, 2) {
-            override fun migrate(db: SupportSQLiteDatabase) {
-                db.execSQL("ALTER TABLE tasks ADD COLUMN categories TEXT NOT NULL DEFAULT ''")
-                val lifted = mutableListOf<Pair<Long, CategoriesLift.Result>>()
-                db.query(
-                    "SELECT id, unknown_properties FROM tasks WHERE unknown_properties LIKE '%CATEGORIES%'",
-                ).use { cursor ->
-                    while (cursor.moveToNext()) {
-                        val result = CategoriesLift.lift(cursor.getString(1))
-                        if (result.categories.isNotEmpty()) lifted += cursor.getLong(0) to result
-                    }
-                }
-                lifted.forEach { (id, result) ->
-                    val categories = CategoriesConverter.toText(result.categories)
-                    if (result.claimed) {
-                        db.execSQL(
-                            "UPDATE tasks SET categories = ?, unknown_properties = ? WHERE id = ?",
-                            arrayOf<Any?>(categories, result.residue, id),
-                        )
-                    } else {
-                        db.execSQL("UPDATE tasks SET categories = ? WHERE id = ?", arrayOf<Any?>(categories, id))
-                    }
-                }
-            }
-        }
-
-        /**
-         * v3 syncs reminders as `VALARM`s, which takes two things the rows did not
-         * have: an identity on the wire (`uid`) and the original text (`raw`).
-         *
-         * Claimable `VALARM`s are lifted out of the residue for every row, synced
-         * or not — an unchanged task is never downloaded again, and an imported
-         * one never was. Not marked dirty: the server already has them. Where a
-         * task held the same lead in both stores (an override forked before v3
-         * copies the master's alarms *and* carries its `VALARM`s), the lifted
-         * one wins: it is the one with an identity.
-         *
-         * Reminders that so far lived only on this device are pushed once, by
-         * marking their tasks dirty — bounded to open tasks in synced lists whose
-         * reminder can still fire, so the upgrade is not a burst of PUTs landing
-         * on other clients as long-missed alarms.
-         *
-         * `tasks.reminders_off` starts at 0 everywhere: until now nothing could
-         * have turned a synced task's alarms off.
-         */
-        val MIGRATION_2_3 = object : Migration(2, 3) {
-            override fun migrate(db: SupportSQLiteDatabase) {
-                db.execSQL("ALTER TABLE task_alarms ADD COLUMN uid TEXT NOT NULL DEFAULT ''")
-                db.execSQL("ALTER TABLE task_alarms ADD COLUMN raw TEXT")
-                db.execSQL("ALTER TABLE tasks ADD COLUMN reminders_off INTEGER NOT NULL DEFAULT 0")
-                // A version-4 UUID per row, in one statement: `randomblob` is
-                // evaluated per row, and the upgrade runs on app start.
-                db.execSQL(
-                    """
-                    UPDATE task_alarms SET uid =
-                        lower(hex(randomblob(4))) || '-' || lower(hex(randomblob(2))) || '-4' ||
-                        substr(lower(hex(randomblob(2))), 2) || '-' ||
-                        substr('89ab', 1 + (abs(random()) % 4), 1) || substr(lower(hex(randomblob(2))), 2) || '-' ||
-                        lower(hex(randomblob(6)))
-                    """.trimIndent(),
-                )
-
-                data class Lifted(val taskId: Long, val result: AlarmLift.Result)
-                val lifted = mutableListOf<Lifted>()
-                db.query(
-                    "SELECT id, dtstart, due, is_all_day, rrule, rdate, unknown_properties FROM tasks " +
-                        "WHERE unknown_properties LIKE '%VALARM%'",
-                ).use { c ->
-                    while (c.moveToNext()) {
-                        val task = AlarmLift.Task(
-                            dtstart = if (c.isNull(1)) null else Instant.fromEpochMilliseconds(c.getLong(1)),
-                            due = if (c.isNull(2)) null else Instant.fromEpochMilliseconds(c.getLong(2)),
-                            isAllDay = c.getInt(3) != 0,
-                            recurring = !c.isNull(4) || !c.isNull(5),
-                        )
-                        val result = AlarmLift.lift(c.getString(6), task)
-                        if (result.alarms.isNotEmpty()) lifted += Lifted(c.getLong(0), result)
-                    }
-                }
-                lifted.forEach { (taskId, result) ->
-                    val local = mutableListOf<Triple<Long, Int, String>>()
-                    db.query(
-                        "SELECT id, minutes_before, reference FROM task_alarms WHERE task_id = ?",
-                        arrayOf<Any?>(taskId),
-                    ).use { c -> while (c.moveToNext()) local += Triple(c.getLong(0), c.getInt(1), c.getString(2)) }
-                    result.alarms.forEach { alarm ->
-                        local.firstOrNull { it.second == alarm.minutesBefore && it.third == alarm.reference.name }
-                            ?.let { duplicate ->
-                                local.remove(duplicate)
-                                db.execSQL("DELETE FROM task_alarms WHERE id = ?", arrayOf<Any?>(duplicate.first))
-                            }
-                        db.execSQL(
-                            "INSERT INTO task_alarms (task_id, minutes_before, reference, uid, raw) VALUES (?, ?, ?, ?, ?)",
-                            arrayOf<Any?>(
-                                taskId,
-                                alarm.minutesBefore,
-                                alarm.reference.name,
-                                alarm.uid ?: UUID.randomUUID().toString(),
-                                alarm.raw,
-                            ),
-                        )
-                    }
-                    db.execSQL("UPDATE tasks SET unknown_properties = ? WHERE id = ?", arrayOf<Any?>(result.residue, taskId))
-                }
-
-                // ⚠️ `raw IS NULL` is "never on the server": everything lifted
-                // above carries its original. Status 0/1 are NEEDS-ACTION and
-                // IN-PROCESS (`ICalStatus`).
-                //
-                // ⚠️ Never a list the upload cannot write to. A dirty row is
-                // also one the download will not overwrite, so marking a task in
-                // a read-only share — or a confidential one, which the upload
-                // skips in a shared collection — would freeze it for good: never
-                // sent, and the owner's edits never taken. Classification 2 is
-                // CONFIDENTIAL.
-                //
-                // LAST-MODIFIED moves with it: the body changes, and a client
-                // reconciling by that stamp would otherwise keep its stale copy.
-                val now = System.currentTimeMillis()
-                db.execSQL(
-                    """
-                    UPDATE tasks SET is_dirty = 1, last_modified = ?
-                    WHERE is_deleted = 0
-                      AND status IN (0, 1)
-                      AND (classification IS NULL OR classification != 2)
-                      AND list_id IN (SELECT id FROM task_lists WHERE account_id IS NOT NULL AND is_read_only = 0)
-                      AND (rrule IS NOT NULL OR rdate IS NOT NULL OR due > ?)
-                      AND id IN (SELECT task_id FROM task_alarms WHERE raw IS NULL)
-                    """.trimIndent(),
-                    arrayOf<Any?>(now, now),
-                )
-            }
-        }
     }
 }

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/transfer/ExternalImport.kt

@@ -7,15 +7,15 @@ import androidx.datastore.preferences.core.edit
 import de.jeanlucmakiola.agendula.data.di.ExternalStore
 import de.jeanlucmakiola.agendula.data.di.IoDispatcher
 import de.jeanlucmakiola.agendula.data.tasks.ProviderResolver
-import de.jeanlucmakiola.agendula.domain.TaskReminder
+import de.jeanlucmakiola.agendula.data.tasks.TaskReminder
 import de.jeanlucmakiola.agendula.data.tasks.TasksDataSource
-import de.jeanlucmakiola.agendula.data.tasks.room.toAlarmEntity
+import de.jeanlucmakiola.agendula.data.tasks.room.AlarmReference
+import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TaskListEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
 import de.jeanlucmakiola.agendula.domain.TaskList
 import de.jeanlucmakiola.agendula.domain.export.ExportTask
-import de.jeanlucmakiola.agendula.domain.normalizeTags
 import de.jeanlucmakiola.agendula.domain.toICal
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
@@ -199,7 +199,7 @@ class ExternalImport @Inject constructor(
         var alarmCount = 0
         for ((sourceTaskId, reminders) in snapshot.alarms) {
             val taskId = taskIds[sourceTaskId] ?: continue
-            reminders.forEach { alarmDao.insert(it.toAlarmEntity(taskId)) }
+            reminders.forEach { alarmDao.insert(it.toEntity(taskId)) }
             alarmCount += reminders.size
         }
 
@@ -213,7 +213,6 @@ class ExternalImport @Inject constructor(
         description = description,
         location = location,
         url = url,
-        categories = normalizeTags(tags),
         status = status,
         percentComplete = percentComplete,
         completedAt = completedAt,
@@ -227,6 +226,12 @@ class ExternalImport @Inject constructor(
         lastModified = lastModified,
     )
 
+    private fun TaskReminder.toEntity(taskId: Long) = TaskAlarmEntity(
+        taskId = taskId,
+        minutesBefore = minutesBefore,
+        reference = if (fromStart) AlarmReference.START else AlarmReference.DUE,
+    )
+
     private fun verify(written: TransferCounts, before: TransferCounts) {
         val after = tableCounts()
         check(after.lists - before.lists == written.lists) {

app/src/main/java/de/jeanlucmakiola/agendula/data/tasks/transfer/IcsImport.kt

@@ -7,9 +7,7 @@ import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.agendula.data.di.IoDispatcher
 import de.jeanlucmakiola.agendula.data.tasks.ical.CalendarResource
 import de.jeanlucmakiola.agendula.data.tasks.ical.VTodoMapper
-import de.jeanlucmakiola.agendula.data.tasks.room.TaskAlarmEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TaskEntity
-import de.jeanlucmakiola.agendula.data.tasks.room.freshCopy
 import de.jeanlucmakiola.agendula.data.tasks.room.TaskListEntity
 import de.jeanlucmakiola.agendula.data.tasks.room.TasksDatabase
 import kotlinx.coroutines.CoroutineDispatcher
@@ -67,11 +65,7 @@ interface IcsImportStore {
     fun <T> transaction(block: () -> T): T
     fun createList(name: String, color: Int): Long
     fun hasUid(listId: Long, uid: String): Boolean
-
-    /** Whether any list holds [uid] — the same file imported somewhere else before. */
-    fun hasUidAnywhere(uid: String): Boolean
     fun insert(row: TaskEntity): Long
-    fun insertAlarms(taskId: Long, alarms: List<TaskAlarmEntity>)
     fun masterByUid(listId: Long, uid: String): TaskEntity?
     fun setParent(taskId: Long, parentId: Long?)
 }
@@ -82,9 +76,9 @@ interface IcsImportStore {
  *
  * Goes through the same [CalendarResource] / [VTodoMapper] path CalDAV sync
  * uses, so recurrence, `RECURRENCE-ID` overrides, `RELATED-TO` parents and every
- * property the mapper does not claim survive as they would on a download. A
+ * property the mapper does not claim (`VALARM`s included) survive as they would
- * `VALARM` the mapper claims becomes a reminder on the task, exactly as a
+ * on a download. `VALARM`s stay in the residue: like sync, the import does not
- * download does; the rest stay in the residue.
+ * turn them into local reminders.
  *
  * Tasks whose UID the target list already holds are skipped, so importing the
  * same file twice is harmless.
@@ -206,17 +200,8 @@ class IcsImport @Inject constructor(
                         skipped++
                         continue
                     }
-                    // ⚠️ The same file in a second list is a second task carrying
-                    // the first one's alarm identities. Those are what clients
-                    // track a dismissal by, so the copy's alarms are new ones.
-                    val copied = store.hasUidAnywhere(task.uid)
-                    fun alarmsOf(mapped: VTodoMapper.Mapped) =
-                        if (copied) mapped.alarms.map { it.freshCopy(0) } else mapped.alarms
                     val masterId = store.insert(task.master.entity.forImport(listId, masterId = null))
-                    store.insertAlarms(masterId, alarmsOf(task.master))
+                    task.overrides.forEach { store.insert(it.entity.forImport(listId, masterId)) }
-                    task.overrides.forEach {
-                        store.insertAlarms(store.insert(it.entity.forImport(listId, masterId)), alarmsOf(it))
-                    }
                     task.master.parentUid?.let { parents += masterId to it }
                     imported++
                 }
@@ -285,15 +270,8 @@ class RoomIcsImportStore(private val database: TasksDatabase) : IcsImportStore {
             arrayOf<Any?>(listId, uid),
         ).use { it.moveToFirst() }
 
-    override fun hasUidAnywhere(uid: String): Boolean =
-        database.query("SELECT 1 FROM tasks WHERE uid = ? LIMIT 1", arrayOf<Any?>(uid)).use { it.moveToFirst() }
-
     override fun insert(row: TaskEntity): Long = database.tasks().insert(row)
 
-    override fun insertAlarms(taskId: Long, alarms: List<TaskAlarmEntity>) {
-        alarms.forEach { database.alarms().insert(it.copy(id = 0, taskId = taskId)) }
-    }
-
     override fun masterByUid(listId: Long, uid: String): TaskEntity? = database.tasks().byUid(listId, uid)
 
     override fun setParent(taskId: Long, parentId: Long?) {

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

@@ -52,8 +52,6 @@ data class Task(
     val description: String?,
     val location: String?,
     val url: String?,
-    /** `CATEGORIES`, as the task spells them. */
-    val tags: List<String> = emptyList(),
     val priority: Priority,
     val status: TaskStatus,
     val percentComplete: Int?,
@@ -163,10 +161,3 @@ fun TaskStatus.toInt(): Int = when (this) {
     TaskStatus.COMPLETED -> ICalStatus.COMPLETED
     TaskStatus.CANCELLED -> ICalStatus.CANCELLED
 }
-
-/** Tags as every writer stores them: trimmed, no blanks, each spelling once, order kept. */
-fun normalizeTags(tags: List<String>): List<String> = tags.map(String::trim).filter(String::isNotEmpty).distinct()
-
-/** Every tag on [tasks], each spelling once, alphabetically ignoring case. */
-fun tagsInUse(tasks: Iterable<Task>): List<String> =
-    tasks.flatMap { it.tags }.distinct().sortedWith(String.CASE_INSENSITIVE_ORDER)

app/src/main/java/de/jeanlucmakiola/agendula/domain/SavedFilter.kt

@@ -1,96 +0,0 @@
-package de.jeanlucmakiola.agendula.domain
-
-import java.time.LocalDate
-import java.time.ZoneId
-import kotlin.time.Instant
-
-/** Where an open task's due date falls, relative to today. */
-enum class DueWindow { OVERDUE, TODAY, UPCOMING, NO_DATE }
-
-/** How a [SavedFilter] with several tags reads them. */
-enum class TagMatch { ANY, ALL }
-
-/**
- * A user-made view over the open tasks. An empty criterion doesn't narrow:
- * no [due] windows means any due date, no [listIds] any list, no [tags] any tag.
- * [minPriority] [Priority.NONE] lets every priority through.
- *
- * [listsElsewhere] is set when the filter also has lists in another task store.
- * With none of its lists here it then matches nothing rather than every list.
- */
-data class SavedFilter(
-    val id: Long,
-    val name: String,
-    val due: Set<DueWindow> = emptySet(),
-    val listIds: Set<Long> = emptySet(),
-    val tags: Set<String> = emptySet(),
-    val tagMatch: TagMatch = TagMatch.ANY,
-    val minPriority: Priority = Priority.NONE,
-    val listsElsewhere: Boolean = false,
-) {
-    /** Whether the filter narrows by list at all. */
-    val anyList: Boolean get() = listIds.isEmpty() && !listsElsewhere
-
-    /** This filter without the list ids missing from [existing], e.g. lists since deleted. */
-    fun withListsIn(existing: Set<Long>): SavedFilter = copy(listIds = listIds intersect existing)
-
-    fun matches(task: Task, todayStart: Instant, todayEnd: Instant): Boolean {
-        if (task.isClosed) return false
-        if (listsElsewhere && listIds.isEmpty()) return false
-        if (listIds.isNotEmpty() && task.listId !in listIds) return false
-        if (task.priority < minPriority) return false
-        if (due.isNotEmpty() && dueWindowOf(task, todayStart, todayEnd) !in due) return false
-        return when {
-            tags.isEmpty() -> true
-            tagMatch == TagMatch.ALL -> task.tags.containsAll(tags)
-            else -> task.tags.any { it in tags }
-        }
-    }
-}
-
-/**
- * Where [task]'s due falls against local today ([todayStart] to [todayEnd], from
- * [DayWindow] in [zone]). An all-day due is stored as UTC midnight, so it is read
- * as its calendar date first rather than compared as a raw instant.
- */
-fun dueWindowOf(
-    task: Task,
-    todayStart: Instant,
-    todayEnd: Instant,
-    zone: ZoneId = ZoneId.systemDefault(),
-): DueWindow {
-    val due = task.due?.let { if (task.isAllDay) it.rebasedForAllDay(allDay = false, zone = zone) else it }
-    return when {
-        due == null -> DueWindow.NO_DATE
-        due < todayStart -> DueWindow.OVERDUE
-        due < todayEnd -> DueWindow.TODAY
-        else -> DueWindow.UPCOMING
-    }
-}
-
-/** What a task created from a [SavedFilter] starts with, so it lands in that filter. */
-data class NewTaskPreset(
-    val listIds: Set<Long> = emptySet(),
-    val tags: List<String> = emptyList(),
-    val dueDate: LocalDate? = null,
-    val priority: Priority = Priority.NONE,
-)
-
-/**
- * The preset for a new task in this filter. Due prefers today, then tomorrow;
- * a filter that admits undated tasks, or only overdue ones, leaves it empty.
- */
-fun SavedFilter.newTaskPreset(today: LocalDate): NewTaskPreset = NewTaskPreset(
-    listIds = listIds,
-    tags = when {
-        tagMatch == TagMatch.ALL -> tags.sorted()
-        else -> listOfNotNull(tags.minOrNull())
-    },
-    dueDate = when {
-        due.isEmpty() || DueWindow.NO_DATE in due -> null
-        DueWindow.TODAY in due -> today
-        DueWindow.UPCOMING in due -> today.plusDays(1)
-        else -> null
-    },
-    priority = minPriority,
-)

app/src/main/java/de/jeanlucmakiola/agendula/domain/TaskFilter.kt

@@ -5,16 +5,12 @@ import kotlin.time.Instant
 /** The built-in "smart" lists, computed from due dates rather than membership. */
 enum class SmartList { ALL, TODAY, UPCOMING, OVERDUE, NO_DATE, COMPLETED }
 
-/** What a task screen is showing: one real list, a smart list, or a tag. */
+/** What a task screen is showing: one real list, or a smart list. */
 sealed interface TaskFilter {
     data class OfList(val listId: Long) : TaskFilter
     /** Several lists shown together, e.g. one widget covering more than one list. */
     data class OfLists(val listIds: Set<Long>) : TaskFilter
     data class Smart(val list: SmartList) : TaskFilter
-    /** Every task carrying [tag], open and completed, across all lists. */
-    data class Tagged(val tag: String) : TaskFilter
-    /** A [SavedFilter] by id; the repository resolves it to its definition. */
-    data class Saved(val id: Long) : TaskFilter
 }
 
 /**
@@ -24,32 +20,22 @@ sealed interface TaskFilter {
  */
 object TaskFiltering {
 
-    /** [saved] is the definition behind a [TaskFilter.Saved]; without one it matches nothing. */
+    fun matches(task: Task, filter: TaskFilter, todayStart: Instant, todayEnd: Instant): Boolean =
-    fun matches(
-        task: Task,
-        filter: TaskFilter,
-        todayStart: Instant,
-        todayEnd: Instant,
-        saved: SavedFilter? = null,
-    ): Boolean =
         when (filter) {
             is TaskFilter.OfList -> task.listId == filter.listId
             is TaskFilter.OfLists -> task.listId in filter.listIds
             is TaskFilter.Smart -> matchesSmart(task, filter.list, todayStart, todayEnd)
-            is TaskFilter.Tagged -> filter.tag in task.tags
-            is TaskFilter.Saved -> saved?.takeIf { it.id == filter.id }?.matches(task, todayStart, todayEnd) ?: false
         }
 
-    /** Whether [task] carries every one of [tags]; an empty set matches everything. */
+    private fun matchesSmart(task: Task, list: SmartList, todayStart: Instant, todayEnd: Instant): Boolean {
-    fun hasAllTags(task: Task, tags: Set<String>): Boolean = task.tags.containsAll(tags)
+        val due = task.due
-
+        return when (list) {
-    private fun matchesSmart(task: Task, list: SmartList, todayStart: Instant, todayEnd: Instant): Boolean =
-        when (list) {
             SmartList.COMPLETED -> task.isCompleted
             SmartList.ALL -> !task.isClosed
-            SmartList.NO_DATE -> !task.isClosed && dueWindowOf(task, todayStart, todayEnd) == DueWindow.NO_DATE
+            SmartList.NO_DATE -> !task.isClosed && due == null
-            SmartList.OVERDUE -> !task.isClosed && dueWindowOf(task, todayStart, todayEnd) == DueWindow.OVERDUE
+            SmartList.OVERDUE -> !task.isClosed && due != null && due < todayStart
-            SmartList.TODAY -> !task.isClosed && dueWindowOf(task, todayStart, todayEnd) == DueWindow.TODAY
+            SmartList.TODAY -> !task.isClosed && due != null && due >= todayStart && due < todayEnd
-            SmartList.UPCOMING -> !task.isClosed && dueWindowOf(task, todayStart, todayEnd) == DueWindow.UPCOMING
+            SmartList.UPCOMING -> !task.isClosed && due != null && due >= todayEnd
         }
+    }
 }

app/src/main/java/de/jeanlucmakiola/agendula/domain/TaskForm.kt

@@ -18,13 +18,10 @@ data class TaskForm(
     val parentId: Long? = null,
     /** 0..100 progress; `null` leaves it unset (cleared). */
     val percentComplete: Int? = null,
-    /** The task's own reminders; empty = the list's or app default applies, unless [remindersChosen]. */
+    /** The task's own reminders, in minutes before [due]; empty = the list's or app default applies. */
-    val reminders: List<TaskReminder> = emptyList(),
+    val reminders: List<Int> = emptyList(),
-    /** Whether [reminders] are exactly the task's, as the editor showed them: empty is then none. */
-    val remindersChosen: Boolean = false,
     val location: String? = null,
     val url: String? = null,
-    val tags: List<String> = emptyList(),
     /** The series' `RRULE` value; `null` = does not repeat. Ignored for a single-occurrence edit. */
     val rrule: String? = null,
 ) {
@@ -32,14 +29,14 @@ data class TaskForm(
         if (title.isBlank()) add(TaskFormError.BLANK_TITLE)
         if (listId <= 0L) add(TaskFormError.NO_LIST)
         if (start != null && due != null && due < start) add(TaskFormError.DUE_BEFORE_START)
-        if (reminders.isNotEmpty() && start == null && due == null) add(TaskFormError.REMINDER_WITHOUT_DATE)
+        if (reminders.isNotEmpty() && due == null) add(TaskFormError.REMINDER_WITHOUT_DUE)
         if (rrule != null && start == null && due == null) add(TaskFormError.RECURRENCE_WITHOUT_DATE)
     }
 
     val isValid: Boolean get() = validate().isEmpty()
 }
 
-enum class TaskFormError { BLANK_TITLE, NO_LIST, DUE_BEFORE_START, REMINDER_WITHOUT_DATE, RECURRENCE_WITHOUT_DATE }
+enum class TaskFormError { BLANK_TITLE, NO_LIST, DUE_BEFORE_START, REMINDER_WITHOUT_DUE, RECURRENCE_WITHOUT_DATE }
 
 /**
  * Optional edit-form sections that can be shown or tucked behind "More fields"
@@ -47,7 +44,7 @@ enum class TaskFormError { BLANK_TITLE, NO_LIST, DUE_BEFORE_START, REMINDER_WITH
  * a setting; the rest unfold on demand. Declaring these as an enum keeps the
  * disclosure generic, so adding a field later is one entry plus its card.
  */
-enum class TaskFormField { Description, Recurrence, Priority, Progress, Parent, Reminder, Location, Url, Tags }
+enum class TaskFormField { Description, Recurrence, Priority, Progress, Parent, Reminder, Location, Url }
 
 /** The optional fields that already carry a value — auto-revealed when editing. */
 fun TaskForm.populatedFields(): Set<TaskFormField> = buildSet {
@@ -59,5 +56,4 @@ fun TaskForm.populatedFields(): Set<TaskFormField> = buildSet {
     if (rrule != null) add(TaskFormField.Recurrence)
     if (!location.isNullOrBlank()) add(TaskFormField.Location)
     if (!url.isNullOrBlank()) add(TaskFormField.Url)
-    if (tags.isNotEmpty()) add(TaskFormField.Tags)
 }

app/src/main/java/de/jeanlucmakiola/agendula/domain/TaskReminder.kt

@@ -1,85 +0,0 @@
-package de.jeanlucmakiola.agendula.domain
-
-import de.jeanlucmakiola.floret.reminders.ReminderLead
-import kotlin.time.Instant
-
-const val DAY_MINUTES = 24 * 60
-
-/**
- * The earliest lead an all-day reminder can have: 00:01 on the day. On an
- * all-day task a lead that is not whole days counts back from the date's
- * midnight, so `-540` is 09:00 on the day — see [TaskReminder.allDay].
- */
-const val MIN_ALL_DAY_LEAD = -(DAY_MINUTES - 1)
-
-/** A stored reminder: how long before the start ([fromStart]) or the due date. */
-data class TaskReminder(
-    val minutesBefore: Int,
-    val fromStart: Boolean = false,
-    /**
-     * When another client last dismissed this alarm (RFC 9074 `ACKNOWLEDGED`):
-     * a trigger at or before it has been dealt with and is not fired here.
-     * Never part of what a reminder *is* — see [lead].
-     */
-    val acknowledgedAt: Instant? = null,
-) {
-    /** The reminder without its bookkeeping, for comparing two of them. */
-    val lead: TaskReminder get() = if (acknowledgedAt == null) this else copy(acknowledgedAt = null)
-
-    /** This reminder read as an all-day one. */
-    val allDay: AllDayReminder get() = AllDayReminder.of(minutesBefore)
-
-    /** This reminder's lead rounded to the nearest whole day, as the earlier all-day leads were. */
-    fun inWholeDays(): TaskReminder =
-        copy(minutesBefore = (minutesBefore.coerceAtLeast(0) + DAY_MINUTES / 2) / DAY_MINUTES * DAY_MINUTES)
-
-    companion object {
-        /**
-         * The all-day reminder [daysBefore] the date at [minuteOfDay], or at the
-         * device's all-day time when that is null. Midnight would read back as
-         * the latter, so it is 00:01 — see [allDayMinuteOfDay].
-         */
-        fun allDay(daysBefore: Int, minuteOfDay: Int?, fromStart: Boolean = false) =
-            TaskReminder(daysBefore * DAY_MINUTES - (minuteOfDay?.let(::allDayMinuteOfDay) ?: 0), fromStart)
-
-        /** The time an all-day reminder can name: any but midnight, which is a whole-day lead. */
-        fun allDayMinuteOfDay(minuteOfDay: Int): Int = minuteOfDay.coerceAtLeast(1)
-    }
-}
-
-/** An all-day reminder as the day it rings on and, when it names one, its time. */
-data class AllDayReminder(val daysBefore: Int, val minuteOfDay: Int?) {
-    companion object {
-        /** [minutesBefore] on an all-day task; anything after the day is clamped to its last minute. */
-        fun of(minutesBefore: Int): AllDayReminder {
-            val minutes = minutesBefore.coerceAtLeast(MIN_ALL_DAY_LEAD)
-            if (minutes % DAY_MINUTES == 0) return AllDayReminder(minutes / DAY_MINUTES, minuteOfDay = null)
-            val days = Math.floorDiv(minutes, DAY_MINUTES) + 1
-            return AllDayReminder(days, minuteOfDay = days * DAY_MINUTES - minutes)
-        }
-    }
-}
-
-/** A canonical order, for comparing two sets of reminders. */
-val TaskReminderOrder: Comparator<TaskReminder> =
-    compareBy<TaskReminder>({ !it.fromStart }, { -it.minutesBefore })
-
-/**
- * The order the editor and the detail screen list reminders in: start's first,
- * then earliest first. An all-day reminder without a time rings at [allDayMinuteOfDay].
- */
-fun taskReminderDisplayOrder(allDay: Boolean, allDayMinuteOfDay: Int): Comparator<TaskReminder> =
-    compareBy<TaskReminder>({ !it.fromStart }, { reminder ->
-        if (!allDay) {
-            -reminder.minutesBefore
-        } else {
-            val (days, minuteOfDay) = reminder.allDay
-            (minuteOfDay ?: allDayMinuteOfDay) - days * DAY_MINUTES
-        }
-    })
-
-/** A default reminder's lead as a reminder of the task's own. */
-fun ReminderLead.asTaskReminder(): TaskReminder = TaskReminder(minutes, fromStart)
-
-/** This reminder's lead, as default reminders are kept. */
-fun TaskReminder.asReminderLead(): ReminderLead = ReminderLead(minutesBefore, fromStart)

app/src/main/java/de/jeanlucmakiola/agendula/domain/TaskSections.kt

@@ -29,11 +29,11 @@ object TaskSections {
 
     fun sectionOf(task: Task, todayStart: Instant, todayEnd: Instant): TaskSection {
         if (task.isCompleted) return TaskSection.COMPLETED
-        return when (dueWindowOf(task, todayStart, todayEnd)) {
+        val due = task.due ?: return TaskSection.NO_DATE
-            DueWindow.OVERDUE -> TaskSection.OVERDUE
+        return when {
-            DueWindow.TODAY -> TaskSection.TODAY
+            due < todayStart -> TaskSection.OVERDUE
-            DueWindow.UPCOMING -> TaskSection.UPCOMING
+            due < todayEnd -> TaskSection.TODAY
-            DueWindow.NO_DATE -> TaskSection.NO_DATE
+            else -> TaskSection.UPCOMING
         }
     }
 }

app/src/main/java/de/jeanlucmakiola/agendula/domain/export/ExportModels.kt

@@ -42,7 +42,6 @@ data class ExportTask(
     val rdate: String?,
     /** `tasks._id` of the parent, for `RELATED-TO;RELTYPE=PARENT`. */
     val parentId: Long?,
-    val tags: List<String> = emptyList(),
 )
 
 /** A task list and everything in it, ready to become one `.ics` document. */

app/src/main/java/de/jeanlucmakiola/agendula/domain/export/ICalendarWriter.kt

@@ -88,7 +88,6 @@ object ICalendarWriter {
         task.location?.takeIf { it.isNotBlank() }?.let { property("LOCATION", it) }
         // URL is a URI, not TEXT: it must not be escaped like one.
         task.url?.takeIf { it.isNotBlank() }?.let { rawProperty("URL", it) }
-        task.tags.takeIf { it.isNotEmpty() }?.let { rawProperty("CATEGORIES", ICalValues.formatTextList(it)) }
 
         task.start?.let { dateProperty("DTSTART", it, task.isAllDay) }
         task.due?.let { dateProperty("DUE", it, task.isAllDay) }

app/src/main/java/de/jeanlucmakiola/agendula/domain/ical/ICalValues.kt

@@ -49,37 +49,6 @@ object ICalValues {
         return out.toString()
     }
 
-    /**
-     * A multi-valued TEXT property (`CATEGORIES`, §3.8.1.2): split on the
-     * commas that are not escaped, then unescape each value.
-     */
-    fun parseTextList(value: String): List<String> {
-        val values = mutableListOf<String>()
-        val current = StringBuilder()
-        var i = 0
-        while (i < value.length) {
-            val c = value[i]
-            when {
-                c == '\\' && i + 1 < value.length -> {
-                    current.append(c).append(value[i + 1])
-                    i += 2
-                    continue
-                }
-                c == ',' -> {
-                    values += unescapeText(current.toString())
-                    current.clear()
-                }
-                else -> current.append(c)
-            }
-            i++
-        }
-        values += unescapeText(current.toString())
-        return values
-    }
-
-    /** The inverse of [parseTextList]. */
-    fun formatTextList(values: List<String>): String = values.joinToString(",", transform = ::escapeText)
-
     /** How a DATE / DATE-TIME property was written, and whether we can reproduce it. */
     sealed interface TimeValue {
         /** `VALUE=DATE` — date-only. */
@@ -161,57 +130,6 @@ object ICalValues {
         }
     }
 
-    private val DURATION = Regex(
-        "([+-])?P(?:(\\d+)W|(?:(\\d+)D)?(?:T(?:(\\d+)H)?(?:(\\d+)M)?(?:(\\d+)S)?)?)",
-        RegexOption.IGNORE_CASE,
-    )
-
-    /**
-     * RFC 5545 §3.3.6 `dur-value` in signed seconds: `-PT15M` → -900, `P1W` →
-     * 604800, `-P1DT2H` → -93600. Null when it does not parse.
-     *
-     * A little more lenient than the grammar — `PT1H5S` skips the minutes the
-     * grammar would require — because a stricter reader would leave another
-     * client's alarm unread over a form nobody misreads.
-     */
-    fun parseDuration(value: String): Long? {
-        val match = DURATION.matchEntire(value.trim()) ?: return null
-        val (sign, weeks, days, hours, minutes, seconds) = match.destructured
-        // "P" and "PT" alone match the pattern and mean nothing.
-        if (listOf(weeks, days, hours, minutes, seconds).all(String::isEmpty)) return null
-        if (value.trim().endsWith("T", ignoreCase = true)) return null
-        fun part(text: String, scale: Long): Long =
-            if (text.isEmpty()) 0L else Math.multiplyExact(text.toLong(), scale)
-        val total = runCatching {
-            listOf(
-                part(weeks, 7 * 86_400L), part(days, 86_400L),
-                part(hours, 3_600L), part(minutes, 60L), part(seconds, 1L),
-            ).reduce(Math::addExact)
-        }.getOrNull() ?: return null
-        return if (sign == "-") -total else total
-    }
-
-    /** The inverse of [parseDuration], in days and time, never weeks: `-PT15M`, `-P1D`, `PT0S`. */
-    fun formatDuration(seconds: Long): String {
-        if (seconds == 0L) return "PT0S"
-        val magnitude = kotlin.math.abs(seconds)
-        val days = magnitude / 86_400
-        val hours = magnitude % 86_400 / 3_600
-        val minutes = magnitude % 3_600 / 60
-        val rest = magnitude % 60
-        return buildString {
-            if (seconds < 0) append('-')
-            append('P')
-            if (days > 0) append(days).append('D')
-            if (hours > 0 || minutes > 0 || rest > 0) {
-                append('T')
-                if (hours > 0) append(hours).append('H')
-                if (minutes > 0) append(minutes).append('M')
-                if (rest > 0) append(rest).append('S')
-            }
-        }
-    }
-
     private fun java.time.Instant.toKotlin(): Instant =
         Instant.fromEpochMilliseconds(toEpochMilli())
 }

app/src/main/java/de/jeanlucmakiola/agendula/ui/common/FormFieldVisuals.kt

@@ -9,7 +9,6 @@ import androidx.compose.material.icons.rounded.LocationOn
 import androidx.compose.material.icons.rounded.Notifications
 import androidx.compose.material.icons.rounded.Percent
 import androidx.compose.material.icons.rounded.Repeat
-import androidx.compose.material.icons.rounded.Sell
 import androidx.compose.ui.graphics.vector.ImageVector
 import de.jeanlucmakiola.agendula.R
 import de.jeanlucmakiola.agendula.domain.TaskFormField
@@ -24,7 +23,6 @@ fun TaskFormField.labelRes(): Int = when (this) {
     TaskFormField.Reminder -> R.string.edit_reminder_label
     TaskFormField.Location -> R.string.edit_location_label
     TaskFormField.Url -> R.string.edit_url_label
-    TaskFormField.Tags -> R.string.edit_tags_label
 }
 
 fun TaskFormField.icon(): ImageVector = when (this) {
@@ -36,5 +34,4 @@ fun TaskFormField.icon(): ImageVector = when (this) {
     TaskFormField.Reminder -> Icons.Rounded.Notifications
     TaskFormField.Location -> Icons.Rounded.LocationOn
     TaskFormField.Url -> Icons.Rounded.Link
-    TaskFormField.Tags -> Icons.Rounded.Sell
 }

app/src/main/java/de/jeanlucmakiola/agendula/ui/common/NameField.kt

@@ -1,51 +0,0 @@
-package de.jeanlucmakiola.agendula.ui.common
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.padding
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.floret.components.GroupedListInset
-import de.jeanlucmakiola.floret.components.GroupedSurface
-import de.jeanlucmakiola.floret.components.InlineTextField
-import de.jeanlucmakiola.floret.components.Position
-
-/** A lone grouped card holding a name, for the list and filter editors. */
-@Composable
-internal fun NameField(
-    name: String,
-    placeholder: String,
-    autoFocus: Boolean,
-    onNameChange: (String) -> Unit,
-    onImeAction: () -> Unit,
-    leading: (@Composable () -> Unit)? = null,
-) {
-    val focusRequester = remember { FocusRequester() }
-    LaunchedEffect(autoFocus) { if (autoFocus) focusRequester.requestFocus() }
-    GroupedSurface(position = Position.Alone, modifier = Modifier.padding(horizontal = GroupedListInset)) {
-        Row(
-            modifier = Modifier.fillMaxWidth().heightIn(min = 72.dp).padding(horizontal = 16.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.spacedBy(16.dp),
-        ) {
-            leading?.invoke()
-            InlineTextField(
-                value = name,
-                onValueChange = onNameChange,
-                placeholder = placeholder,
-                imeAction = ImeAction.Done,
-                onImeAction = onImeAction,
-                modifier = Modifier.fillMaxWidth().focusRequester(focusRequester),
-            )
-        }
-    }
-}

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

@@ -5,8 +5,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import de.jeanlucmakiola.agendula.R
-import de.jeanlucmakiola.agendula.domain.DAY_MINUTES
-import de.jeanlucmakiola.agendula.domain.TaskReminder
 import de.jeanlucmakiola.floret.reminders.ReminderUnit
 
 /** Common reminder lead times offered as quick picks in the reminder pickers. */
@@ -35,57 +33,9 @@ fun reminderLeadTimeLabel(minutes: Int, allDay: Boolean = false): String = when
     minutes <= 0 -> stringResource(R.string.reminder_at_due)
     minutes % 10_080 == 0 ->
         pluralStringResource(R.plurals.reminder_weeks, minutes / 10_080, minutes / 10_080)
-    minutes % DAY_MINUTES == 0 ->
+    minutes % 1_440 == 0 ->
-        pluralStringResource(R.plurals.reminder_days, minutes / DAY_MINUTES, minutes / DAY_MINUTES)
+        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)
 }
-
-/**
- * [reminderLeadTimeLabel] naming the date the lead counts from, for a task
- * that has both: "15 minutes before the start", "On the due date".
- */
-@Composable
-fun anchoredLeadTimeLabel(minutes: Int, allDay: Boolean, fromStart: Boolean): String {
-    @Composable
-    fun plural(start: Int, due: Int, count: Int) =
-        pluralStringResource(if (fromStart) start else due, count, count)
-    return when {
-        minutes <= 0 && allDay ->
-            stringResource(if (fromStart) R.string.reminder_on_start_date else R.string.reminder_on_due_date)
-        minutes <= 0 -> stringResource(if (fromStart) R.string.reminder_at_start else R.string.reminder_at_due_time)
-        minutes % 10_080 == 0 ->
-            plural(R.plurals.reminder_weeks_before_start, R.plurals.reminder_weeks_before_due, minutes / 10_080)
-        minutes % DAY_MINUTES == 0 ->
-            plural(R.plurals.reminder_days_before_start, R.plurals.reminder_days_before_due, minutes / DAY_MINUTES)
-        minutes % 60 == 0 ->
-            plural(R.plurals.reminder_hours_before_start, R.plurals.reminder_hours_before_due, minutes / 60)
-        else -> plural(R.plurals.reminder_minutes_before_start, R.plurals.reminder_minutes_before_due, minutes)
-    }
-}
-
-/** A lead's label, naming its date when [anchored]. */
-@Composable
-fun reminderLabel(minutes: Int, allDay: Boolean, fromStart: Boolean, anchored: Boolean): String =
-    if (anchored) anchoredLeadTimeLabel(minutes, allDay, fromStart) else reminderLeadTimeLabel(minutes, allDay)
-
-/**
- * One of a task's own reminders in one line, naming its date when [anchored].
- * An all-day one names its day and the time it rings at — its own, or
- * [allDayMinuteOfDay] when it has none.
- */
-@Composable
-fun taskReminderLabel(reminder: TaskReminder, allDay: Boolean, allDayMinuteOfDay: Int, anchored: Boolean): String {
-    if (!allDay) return reminderLabel(reminder.minutesBefore, false, reminder.fromStart, anchored)
-    val (days, minuteOfDay) = reminder.allDay
-    return stringResource(
-        R.string.reminder_at_time,
-        reminderLabel(days * DAY_MINUTES, true, reminder.fromStart, anchored),
-        formatMinuteOfDay(minuteOfDay ?: allDayMinuteOfDay, LocalUse24HourFormat.current),
-    )
-}
-
-@StringRes
-fun reminderAnchorLabel(fromStart: Boolean): Int =
-    if (fromStart) R.string.reminder_anchor_start else R.string.reminder_anchor_due

app/src/main/java/de/jeanlucmakiola/agendula/ui/common/ReminderLeadPicker.kt

@@ -1,13 +1,12 @@
 package de.jeanlucmakiola.agendula.ui.common
 
-import de.jeanlucmakiola.floret.components.CustomAmountEditor
 import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.floret.components.positionOf
+import de.jeanlucmakiola.floret.components.DialogAmountField
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.SelectedCheck
-import de.jeanlucmakiola.floret.reminders.ReminderLead
+import de.jeanlucmakiola.floret.reminders.reminderOverrideForMinutes
-import de.jeanlucmakiola.floret.reminders.reminderOverrideForLeads
 import androidx.compose.foundation.layout.height
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.remember
@@ -17,19 +16,27 @@ import de.jeanlucmakiola.floret.reminders.decomposeReminderMinutes
 import androidx.compose.animation.AnimatedVisibility
 import de.jeanlucmakiola.floret.identity.collapseExit
 import de.jeanlucmakiola.floret.identity.expandEnter
-import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.FilledTonalButton
+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 androidx.compose.runtime.Composable
 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.res.stringResource
 import androidx.compose.ui.unit.dp
@@ -39,10 +46,8 @@ import de.jeanlucmakiola.agendula.R
  * Reminder lead-time picker, full-screen: the grouped list of preset lead times
  * plus a "Custom" row that expands an inline amount field + unit selector.
  * [allowInherit] adds a "Use default" row (per-list overrides); [allowNone] adds
- * a "None" row; [allDay] switches to day-scale presets and wording, and its
+ * a "None" row; [allDay] switches to day-scale presets and wording. Returns the
- * custom amounts to days and weeks. [header] sits above the rows, for whatever
+ * choice as a [ReminderOverride]. Ported from Calendula's ReminderDefaultPicker.
- * else the caller's reminder carries. Returns the choice as a
- * [ReminderOverride]. Ported from Calendula's ReminderDefaultPicker.
  */
 @Composable
 fun ReminderLeadPicker(
@@ -54,7 +59,6 @@ fun ReminderLeadPicker(
     onDismiss: () -> Unit,
     allDay: Boolean = false,
     presets: List<Int> = if (allDay) ALLDAY_REMINDER_PRESETS else REMINDER_PRESETS,
-    header: (@Composable ColumnScope.() -> Unit)? = null,
 ) {
     // Agendula is single-reminder: an override carries a one-element list, so
     // take the single value for this single-select picker.
@@ -64,7 +68,7 @@ fun ReminderLeadPicker(
 
     var customExpanded by rememberSaveable { mutableStateOf(false) }
     var amountText by rememberSaveable { mutableStateOf(seed.amount?.toString() ?: "") }
-    var unit by rememberSaveable { mutableStateOf(seed.unit.takeIf { it in reminderUnits(allDay) } ?: reminderUnits(allDay).first()) }
+    var unit by rememberSaveable { mutableStateOf(seed.unit) }
 
     val options = buildList {
         if (allowInherit) add(ReminderOverride.Inherit)
@@ -74,7 +78,6 @@ fun ReminderLeadPicker(
     val rowCount = options.size + 1 // + the custom row
 
     FullScreenPicker(title = title, onDismiss = onDismiss) {
-        header?.invoke(this)
         options.forEachIndexed { index, option ->
             val isSelected = option == selected
             GroupedRow(
@@ -109,8 +112,6 @@ fun ReminderLeadPicker(
                 onAmountChange = { amountText = it },
                 unit = unit,
                 onUnitChange = { unit = it },
-                units = reminderUnits(allDay),
-                allDay = allDay,
                 onConfirm = { minutes ->
                     onSelect(ReminderOverride.Minutes(listOf(minutes)))
                     onDismiss()
@@ -128,9 +129,7 @@ fun ReminderLeadPicker(
  * Clearing the last time falls back to "Use default" on a per-list picker and to
  * "No reminder" on the global one. Changes apply live; the user leaves via back.
  * [allDay] switches to day-scale presets, and [leadTimeSummary] adds a second
- * line to each lead-time row. A start / due toggle picks which date the rows
+ * line to each lead-time row. Ported from Calendula's ReminderDefaultPicker.
- * count from, and the choice carries it ([ReminderOverride.Minutes.fromStart]).
- * Ported from Calendula's ReminderDefaultPicker.
  */
 @Composable
 fun ReminderDefaultPicker(
@@ -150,27 +149,24 @@ fun ReminderDefaultPicker(
     LaunchedEffect(selected) { if (!userEdited) current = selected }
     val inherits = current is ReminderOverride.Inherit
     val isNone = current is ReminderOverride.None
-    val selectedLeads = (current as? ReminderOverride.Minutes)?.leads.orEmpty()
+    val selectedMinutes = (current as? ReminderOverride.Minutes)?.minutes.orEmpty()
-    var fromStart by rememberSaveable { mutableStateOf(true) }
-    val selectedMinutes = selectedLeads.filter { it.fromStart == fromStart }.map { it.minutes }
     // Custom values seen this session keep their row once unchecked.
-    val seenCustom = remember { mutableSetOf<ReminderLead>() }
+    val seenCustom = remember { mutableSetOf<Int>() }
-    seenCustom += selectedLeads.filter { it.minutes !in presets }
+    seenCustom += selectedMinutes.filter { it !in presets }
-    val rows = presets + seenCustom.filter { it.fromStart == fromStart }.map { it.minutes }.sorted()
+    val rows = presets + seenCustom.sorted()
 
     var customExpanded by rememberSaveable { mutableStateOf(false) }
     var amountText by rememberSaveable { mutableStateOf("") }
-    var unit by rememberSaveable { mutableStateOf(reminderUnits(allDay).first()) }
+    var unit by rememberSaveable { mutableStateOf(ReminderUnit.Minutes) }
 
     fun apply(override: ReminderOverride) {
         userEdited = true
         current = override
         onSelect(override)
     }
-    fun emit(leads: List<ReminderLead>) = apply(reminderOverrideForLeads(leads, allowInherit))
+    fun emit(minutes: List<Int>) = apply(reminderOverrideForMinutes(minutes, allowInherit))
-    fun lead(minute: Int) = ReminderLead(minute, fromStart)
     fun toggle(minute: Int) =
-        emit(if (minute in selectedMinutes) selectedLeads - lead(minute) else selectedLeads + lead(minute))
+        emit(if (minute in selectedMinutes) selectedMinutes - minute else selectedMinutes + minute)
 
     FullScreenPicker(title = title, onDismiss = onDismiss) {
         if (allowInherit) {
@@ -190,8 +186,6 @@ fun ReminderDefaultPicker(
             onClick = { apply(ReminderOverride.None) },
         )
         Spacer(Modifier.height(24.dp))
-        ReminderAnchorToggle(fromStart = fromStart, onChange = { fromStart = it })
-        Spacer(Modifier.height(16.dp))
         val rowCount = rows.size + 1 // + the custom row
         rows.forEachIndexed { index, minute ->
             val checked = minute in selectedMinutes
@@ -219,10 +213,8 @@ fun ReminderDefaultPicker(
                 onAmountChange = { amountText = it },
                 unit = unit,
                 onUnitChange = { unit = it },
-                units = reminderUnits(allDay),
-                allDay = allDay,
                 onConfirm = { minutes ->
-                    emit(selectedLeads + lead(minutes))
+                    emit(selectedMinutes + minutes)
                     amountText = ""
                     customExpanded = false
                 },
@@ -231,54 +223,57 @@ fun ReminderDefaultPicker(
     }
 }
 
-/** Which date a reminder counts back from. */
-@Composable
-fun ReminderAnchorToggle(fromStart: Boolean, onChange: (Boolean) -> Unit) {
-    SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp)) {
-        listOf(true, false).forEachIndexed { index, start ->
-            SegmentedButton(
-                selected = fromStart == start,
-                onClick = { onChange(start) },
-                shape = SegmentedButtonDefaults.itemShape(index, 2),
-                label = { Text(stringResource(reminderAnchorLabel(start))) },
-            )
-        }
-    }
-}
-
 @Composable
 private fun CustomReminderEditor(
     amountText: String,
     onAmountChange: (String) -> Unit,
     unit: ReminderUnit,
     onUnitChange: (ReminderUnit) -> Unit,
-    units: List<ReminderUnit>,
-    allDay: Boolean,
     onConfirm: (Int) -> Unit,
 ) {
     val amount = amountText.toIntOrNull()?.takeIf { it in 1..999 }
-    CustomAmountEditor(
+    Surface(
-        amountText = amountText,
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
-        onAmountChange = onAmountChange,
+        // A Position.Bottom shape: tight top corners meeting the row, full bottom.
-        preview = amount?.let { reminderLeadTimeLabel(it * unit.minutesFactor, allDay) }
+        shape = RoundedCornerShape(topStart = 6.dp, topEnd = 6.dp, bottomStart = 22.dp, bottomEnd = 22.dp),
-            ?: stringResource(R.string.reminder_custom_amount),
+        modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp),
-        setLabel = stringResource(R.string.reminder_custom_set),
+    ) {
-        confirmEnabled = amount != null,
+        Column(
-        onConfirm = { amount?.let { onConfirm(it * unit.minutesFactor) } },
+            modifier = Modifier.padding(16.dp),
-        unitLabels = units.map { stringResource(reminderUnitLabel(it)) },
+            verticalArrangement = Arrangement.spacedBy(16.dp),
-        selectedUnit = units.indexOf(unit),
+        ) {
-        onUnitChange = { onUnitChange(units[it]) },
+            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))) },
+                    )
+                }
+            }
+            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))
+                }
+            }
+        }
+    }
 }
 
-/**
- * The units a custom lead is entered in. An all-day reminder's time of day is
- * set on its own, so its lead is whole days: an hour count would read back as a
- * time of day.
- */
-private fun reminderUnits(allDay: Boolean): List<ReminderUnit> =
-    if (allDay) listOf(ReminderUnit.Days, ReminderUnit.Weeks) else ReminderUnit.entries
-
 @Composable
 private fun reminderOverrideLabel(override: ReminderOverride, allDay: Boolean): String = when (override) {
     ReminderOverride.Inherit -> stringResource(R.string.reminder_use_default)

app/src/main/java/de/jeanlucmakiola/agendula/ui/common/TagChip.kt

@@ -1,57 +0,0 @@
-package de.jeanlucmakiola.agendula.ui.common
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.dp
-
-/**
- * A pill naming one tag. Solid secondary by default so it reads against any card;
- * [muted] is the quieter tonal look for something not yet applied, like a suggestion.
- */
-@Composable
-fun TagChip(
-    name: String,
-    modifier: Modifier = Modifier,
-    muted: Boolean = false,
-    icon: ImageVector? = null,
-    iconContentDescription: String? = null,
-    onClick: (() -> Unit)? = null,
-) {
-    val container = if (muted) MaterialTheme.colorScheme.secondaryContainer else MaterialTheme.colorScheme.secondary
-    val content = if (muted) MaterialTheme.colorScheme.onSecondaryContainer else MaterialTheme.colorScheme.onSecondary
-    val shape = RoundedCornerShape(50)
-    val body: @Composable () -> Unit = {
-        Row(
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.spacedBy(4.dp),
-            modifier = Modifier.padding(start = 12.dp, end = if (icon != null) 8.dp else 12.dp, top = 6.dp, bottom = 6.dp),
-        ) {
-            Text(
-                text = name,
-                style = MaterialTheme.typography.labelLarge,
-                maxLines = 1,
-                overflow = TextOverflow.Ellipsis,
-            )
-            if (icon != null) {
-                Icon(icon, contentDescription = iconContentDescription, modifier = Modifier.size(16.dp))
-            }
-        }
-    }
-    if (onClick != null) {
-        Surface(onClick = onClick, color = container, contentColor = content, shape = shape, modifier = modifier) { body() }
-    } else {
-        Surface(color = container, contentColor = content, shape = shape, modifier = modifier) { body() }
-    }
-}

app/src/main/java/de/jeanlucmakiola/agendula/ui/detail/TaskDetailScreen.kt

@@ -7,8 +7,6 @@ import androidx.compose.foundation.text.BasicTextField
 import androidx.compose.foundation.text.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
@@ -44,7 +42,6 @@ import android.net.Uri
 import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.material.icons.rounded.Info
 import androidx.compose.material.icons.rounded.Link
-import androidx.compose.material.icons.rounded.Sell
 import androidx.compose.material.icons.rounded.LocationOn
 import androidx.compose.material.icons.rounded.Notifications
 import androidx.compose.material.icons.rounded.Repeat
@@ -58,15 +55,14 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.res.pluralStringResource
 import androidx.core.net.toUri
-import de.jeanlucmakiola.agendula.domain.TaskReminder
+import de.jeanlucmakiola.agendula.data.tasks.TaskReminder
 import de.jeanlucmakiola.agendula.domain.TaskStatus
 import de.jeanlucmakiola.agendula.domain.recurrence.RecurringScope
 import de.jeanlucmakiola.agendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.agendula.ui.common.RecurringScopeDialog
-import de.jeanlucmakiola.agendula.ui.common.TagChip
 import de.jeanlucmakiola.agendula.ui.common.linkified
 import de.jeanlucmakiola.agendula.ui.common.recurrenceText
-import de.jeanlucmakiola.agendula.ui.common.taskReminderLabel
+import de.jeanlucmakiola.agendula.ui.common.reminderLeadTimeLabel
 import de.jeanlucmakiola.floret.locale.currentLocale
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
@@ -101,7 +97,6 @@ import de.jeanlucmakiola.agendula.R
 import de.jeanlucmakiola.agendula.domain.readableDescription
 import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskDetail
-import de.jeanlucmakiola.floret.components.revealOnFocus
 import de.jeanlucmakiola.floret.components.GroupedSurface
 import de.jeanlucmakiola.agendula.ui.common.PriorityChip
 import de.jeanlucmakiola.floret.time.formatDate
@@ -198,7 +193,6 @@ fun TaskDetailScreen(
                 detail = s.detail,
                 inner = inner,
                 reminders = s.reminders,
-                allDayMinuteOfDay = s.allDayMinuteOfDay,
                 onToggle = { viewModel.toggleComplete(s.detail.task) },
                 onToggleSubtask = { viewModel.toggleComplete(it) },
                 onAddSubtask = { viewModel.addSubtask(it) },
@@ -246,13 +240,11 @@ fun TaskDetailScreen(
     }
 }
 
-@OptIn(ExperimentalLayoutApi::class)
 @Composable
 private fun DetailBody(
     detail: TaskDetail,
     inner: androidx.compose.foundation.layout.PaddingValues,
     reminders: List<TaskReminder>,
-    allDayMinuteOfDay: Int,
     onToggle: () -> Unit,
     onToggleSubtask: (Task) -> Unit,
     onAddSubtask: (String) -> Unit,
@@ -354,12 +346,8 @@ private fun DetailBody(
                     DetailCard(icon = Icons.Rounded.Notifications, iconContentDescription = stringResource(R.string.edit_reminder_label)) {
                         reminders.forEach { reminder ->
                             Text(
-                                taskReminderLabel(
+                                if (reminder.fromStart) stringResource(R.string.detail_reminder_before_start, reminderLeadTimeLabel(reminder.minutesBefore))
-                                    reminder,
+                                else reminderLeadTimeLabel(reminder.minutesBefore, task.isAllDay),
-                                    task.isAllDay,
-                                    allDayMinuteOfDay,
-                                    anchored = task.start != null && task.due != null,
-                                ),
                                 style = MaterialTheme.typography.titleMedium,
                             )
                         }
@@ -465,19 +453,6 @@ private fun DetailBody(
                 }
             }
 
-            if (task.tags.isNotEmpty()) {
-                add {
-                    DetailCard(icon = Icons.Rounded.Sell, iconContentDescription = stringResource(R.string.edit_tags_label)) {
-                        FlowRow(
-                            horizontalArrangement = Arrangement.spacedBy(6.dp),
-                            verticalArrangement = Arrangement.spacedBy(6.dp),
-                        ) {
-                            task.tags.forEach { TagChip(it) }
-                        }
-                    }
-                }
-            }
-
             // Description — selectable, with its links tappable.
             task.description?.readableDescription()?.takeIf { it.isNotBlank() }?.let { description ->
                 add {
@@ -631,7 +606,7 @@ private fun AddSubtaskField(onAdd: (String) -> Unit) {
     }
     val accentOn = MaterialTheme.colorScheme.onPrimaryContainer
     Row(
-        modifier = Modifier.fillMaxWidth().heightIn(min = 56.dp).revealOnFocus().padding(start = 8.dp, end = 8.dp),
+        modifier = Modifier.fillMaxWidth().heightIn(min = 56.dp).padding(start = 8.dp, end = 8.dp),
         verticalAlignment = Alignment.CenterVertically,
     ) {
         Box(modifier = Modifier.size(48.dp), contentAlignment = Alignment.Center) {

app/src/main/java/de/jeanlucmakiola/agendula/ui/detail/TaskDetailViewModel.kt

@@ -18,11 +18,6 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.distinctUntilChanged
-import de.jeanlucmakiola.agendula.data.prefs.DEFAULT_ALL_DAY_REMINDER_MINUTE
-import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.agendula.domain.taskReminderDisplayOrder
 import de.jeanlucmakiola.agendula.domain.recurrence.RecurringScope
 import de.jeanlucmakiola.agendula.data.di.ApplicationScope
 import kotlinx.coroutines.CoroutineScope
@@ -35,9 +30,7 @@ sealed interface TaskDetailUiState {
     data class Content(
         val detail: TaskDetail,
         /** The task's own reminders; empty when the list's or app default applies. */
-        val reminders: List<de.jeanlucmakiola.agendula.domain.TaskReminder> = emptyList(),
+        val reminders: List<de.jeanlucmakiola.agendula.data.tasks.TaskReminder> = emptyList(),
-        /** The time an all-day reminder without one of its own rings at. */
-        val allDayMinuteOfDay: Int = DEFAULT_ALL_DAY_REMINDER_MINUTE,
     ) : TaskDetailUiState
 }
 
@@ -45,7 +38,6 @@ sealed interface TaskDetailUiState {
 @HiltViewModel
 class TaskDetailViewModel @Inject constructor(
     private val repository: TasksRepository,
-    private val settingsPrefs: SettingsPrefs,
     @ApplicationScope private val appScope: CoroutineScope,
 ) : ViewModel() {
 
@@ -54,18 +46,14 @@ class TaskDetailViewModel @Inject constructor(
     val state: StateFlow<TaskDetailUiState> =
         target.filterNotNull()
             .flatMapLatest { (id, occurrence) ->
-                val allDayMinute = settingsPrefs.settings.map { it.allDayReminderMinuteOfDay }.distinctUntilChanged()
                 repository.taskDetail(id, occurrence)
-                    .map { detail -> detail?.let { it to repository.remindersFor(it.task.taskId) } }
+                    .map<TaskDetail?, TaskDetailUiState> { detail ->
-                    .combine(allDayMinute) { loaded, minute ->
+                        if (detail == null) {
-                        if (loaded == null) {
                             TaskDetailUiState.NotFound
                         } else {
-                            val (detail, reminders) = loaded
                             TaskDetailUiState.Content(
                                 detail = detail,
-                                reminders = reminders.sortedWith(taskReminderDisplayOrder(detail.task.isAllDay, minute)),
+                                reminders = repository.remindersFor(detail.task.taskId),
-                                allDayMinuteOfDay = minute,
                             )
                         }
                     }

app/src/main/java/de/jeanlucmakiola/agendula/ui/edit/TaskEditScreen.kt

@@ -1,40 +1,20 @@
 package de.jeanlucmakiola.agendula.ui.edit
 
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.slideOutVertically
-import androidx.compose.foundation.ScrollState
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.ui.layout.onPlaced
-import androidx.compose.ui.layout.positionInParent
-import androidx.compose.ui.text.style.TextOverflow
-import de.jeanlucmakiola.agendula.ui.common.TagChip
 import de.jeanlucmakiola.agendula.ui.common.LocalFirstDayOfWeek
 import de.jeanlucmakiola.agendula.ui.common.LocalUse24HourFormat
 import androidx.activity.compose.BackHandler
 import androidx.compose.material.icons.rounded.Link
-import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.FlowRow
-import androidx.compose.material.icons.rounded.Sell
-import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.material.icons.rounded.LocationOn
 import androidx.compose.material.icons.rounded.Repeat
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.input.KeyboardType
 import de.jeanlucmakiola.agendula.ui.common.RecurringScopeDialog
-import de.jeanlucmakiola.agendula.ui.common.ReminderAnchorToggle
 import de.jeanlucmakiola.agendula.ui.common.ReminderLeadPicker
 import de.jeanlucmakiola.agendula.ui.common.icon
 import de.jeanlucmakiola.agendula.ui.common.labelRes
 import de.jeanlucmakiola.agendula.ui.common.recurrenceText
-import de.jeanlucmakiola.agendula.ui.common.TimePickerAlert
+import de.jeanlucmakiola.agendula.ui.common.reminderLeadTimeLabel
-import de.jeanlucmakiola.agendula.ui.common.formatMinuteOfDay
-import de.jeanlucmakiola.agendula.ui.common.taskReminderLabel
-import de.jeanlucmakiola.floret.components.revealOnFocus
 import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedListInset
 import de.jeanlucmakiola.floret.components.GroupedSectionHeader
@@ -126,8 +106,6 @@ import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskFormError
 import de.jeanlucmakiola.agendula.domain.TaskFormField
 import de.jeanlucmakiola.agendula.domain.TaskList
-import de.jeanlucmakiola.agendula.domain.TaskReminder
-import de.jeanlucmakiola.agendula.domain.DAY_MINUTES
 import de.jeanlucmakiola.agendula.domain.TaskSection
 import de.jeanlucmakiola.agendula.domain.TaskSections
 import de.jeanlucmakiola.floret.components.GroupedRow
@@ -175,25 +153,11 @@ fun TaskEditScreen(
     val requestBack = { if (state.isDirty && !state.saved) showDiscard = true else onBack() }
     BackHandler(enabled = state.isDirty && !state.saved) { showDiscard = true }
 
-    // Once the title field scrolls away it rides in the bar, so a long form never
-    // loses track of which task is being edited.
-    val scroll = rememberScrollState()
-    var titleBottom by remember { mutableIntStateOf(Int.MAX_VALUE) }
-    val titleInBar by remember { derivedStateOf { scroll.value > titleBottom } }
-
     Scaffold(
         modifier = modifier,
         topBar = {
             TopAppBar(
-                title = {
+                title = {},
-                    AnimatedVisibility(
-                        visible = titleInBar && state.title.isNotBlank(),
-                        enter = fadeIn() + slideInVertically { it / 2 },
-                        exit = fadeOut() + slideOutVertically { it / 2 },
-                    ) {
-                        Text(state.title, maxLines = 1, overflow = TextOverflow.Ellipsis)
-                    }
-                },
                 navigationIcon = {
                     IconButton(onClick = requestBack) {
                         Icon(Icons.Rounded.Close, contentDescription = stringResource(R.string.close))
@@ -216,8 +180,6 @@ fun TaskEditScreen(
         EditContent(
             state = state,
             viewModel = viewModel,
-            scroll = scroll,
-            onTitleBottom = { titleBottom = it },
             modifier = Modifier.padding(inner),
         )
     }
@@ -258,8 +220,6 @@ private enum class PickerTarget { Start, Due }
 private fun EditContent(
     state: TaskEditUiState,
     viewModel: TaskEditViewModel,
-    scroll: ScrollState,
-    onTitleBottom: (Int) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val dark = isSystemInDarkTheme()
@@ -268,8 +228,6 @@ private fun EditContent(
     // the title takes the target list's colour.
     val accent = selectedList?.let { pastelize(it.color, dark) } ?: MaterialTheme.colorScheme.primary
     val gap = 12.dp
-    // A reminder's anchor only says something when the task has both to choose from.
-    val bothDates = state.start != null && state.due != null
 
     var pickerTarget by rememberSaveable { mutableStateOf<PickerTarget?>(null) }
     var showListPicker by rememberSaveable { mutableStateOf(false) }
@@ -292,7 +250,7 @@ private fun EditContent(
             // Shrink the scroll viewport by the keyboard so the focused field
             // scrolls into view above the IME instead of being hidden.
             .imePadding()
-            .verticalScroll(scroll)
+            .verticalScroll(rememberScrollState())
             .padding(start = 24.dp, end = 24.dp, top = 8.dp, bottom = 40.dp),
     ) {
         // Title: borderless headline + accent bar, mirroring the detail screen.
@@ -301,9 +259,7 @@ private fun EditContent(
             onValueChange = viewModel::onTitleChange,
             placeholder = stringResource(R.string.edit_title_hint),
             textStyle = MaterialTheme.typography.headlineMedium.copy(fontWeight = FontWeight.SemiBold),
-            modifier = Modifier
+            modifier = Modifier.focusRequester(titleFocus),
-                .focusRequester(titleFocus)
-                .onPlaced { onTitleBottom(it.positionInParent().y.toInt() + it.size.height) },
         )
         Spacer(Modifier.height(10.dp))
         Box(
@@ -566,25 +522,23 @@ private fun EditContent(
             Spacer(Modifier.height(gap))
             // One card per reminder, connected, the last row adding another.
             val rows = state.reminders.size + 1
-            state.reminders.forEachIndexed { index, reminder ->
+            state.reminders.forEachIndexed { index, minutes ->
                 ReminderItemCard(
                     position = positionOf(index, rows),
-                    title = taskReminderLabel(reminder, state.isAllDay, state.allDayMinuteOfDay, anchored = bothDates),
+                    title = reminderLeadTimeLabel(minutes, state.isAllDay),
-                    onRemove = { viewModel.removeReminder(reminder) },
+                    onRemove = { viewModel.removeReminder(minutes) },
                 )
             }
             AddReminderCard(
                 position = positionOf(state.reminders.size, rows),
                 label = stringResource(
-                    // Only a set the user has not chosen still falls back to the default.
+                    if (state.reminders.isEmpty()) R.string.edit_reminder_add_first else R.string.edit_reminder_add,
-                    if (state.reminders.isEmpty() && !state.remindersChosen) R.string.edit_reminder_add_first
-                    else R.string.edit_reminder_add,
                 ),
                 onClick = { showReminderPicker = true },
             )
-            if (TaskFormError.REMINDER_WITHOUT_DATE in state.errors) {
+            if (TaskFormError.REMINDER_WITHOUT_DUE in state.errors) {
                 Spacer(Modifier.height(4.dp))
-                FieldError(R.string.error_reminder_without_date)
+                FieldError(R.string.error_reminder_without_due)
             }
         }
 
@@ -618,19 +572,6 @@ private fun EditContent(
             }
         }
 
-        OptionalFormSection(visible = TaskFormField.Tags in state.visibleFields) {
-            Spacer(Modifier.height(gap))
-            TagsCard(
-                tags = state.tags,
-                draft = state.tagDraft,
-                suggestions = state.tagSuggestions,
-                onDraftChange = viewModel::onTagDraftChange,
-                onCommitDraft = viewModel::commitTagDraft,
-                onAdd = viewModel::addTag,
-                onRemove = viewModel::removeTag,
-            )
-        }
-
         OptionalFormSection(visible = state.hiddenFields.isNotEmpty()) {
             Spacer(Modifier.height(20.dp))
             TextButton(
@@ -697,73 +638,18 @@ private fun EditContent(
     }
 
     if (showReminderPicker) {
-        var fromStart by rememberSaveable { mutableStateOf(state.start != null) }
-        var minuteOfDay by rememberSaveable { mutableIntStateOf(state.allDayMinuteOfDay) }
-        var pickingTime by rememberSaveable { mutableStateOf(false) }
         ReminderLeadPicker(
             title = stringResource(R.string.edit_reminder_add),
             selected = ReminderOverride.Inherit,
             allowInherit = false,
             allowNone = false,
             allDay = state.isAllDay,
-            header = if (bothDates || state.isAllDay) {
-                {
-                    if (bothDates) {
-                        ReminderAnchorToggle(fromStart = fromStart, onChange = { fromStart = it })
-                        Spacer(Modifier.height(16.dp))
-                    }
-                    if (state.isAllDay) {
-                        GroupedRow(
-                            title = stringResource(R.string.reminder_time),
-                            position = Position.Alone,
-                            trailing = {
-                                Text(
-                                    formatMinuteOfDay(minuteOfDay, LocalUse24HourFormat.current),
-                                    style = MaterialTheme.typography.titleMedium,
-                                    color = MaterialTheme.colorScheme.primary,
-                                )
-                            },
-                            onClick = { pickingTime = true },
-                        )
-                        Spacer(Modifier.height(24.dp))
-                    }
-                }
-            } else {
-                null
-            },
             onSelect = { choice ->
-                (choice as? ReminderOverride.Minutes)?.minutes?.firstOrNull()?.let { minutes ->
+                (choice as? ReminderOverride.Minutes)?.minutes?.firstOrNull()?.let(viewModel::addReminder)
-                    // A task with one date counts from that one, whatever the toggle said.
-                    val anchorStart = if (bothDates) fromStart else state.due == null
-                    viewModel.addReminder(
-                        if (state.isAllDay) {
-                            // The default time is left unnamed, so the reminder follows the setting.
-                            TaskReminder.allDay(
-                                daysBefore = minutes / DAY_MINUTES,
-                                minuteOfDay = minuteOfDay.takeIf { it != state.allDayMinuteOfDay },
-                                fromStart = anchorStart,
-                            )
-                        } else {
-                            TaskReminder(minutes, fromStart = anchorStart)
-                        },
-                    )
-                }
                 showReminderPicker = false
             },
             onDismiss = { showReminderPicker = false },
         )
-        if (pickingTime) {
-            TimePickerAlert(
-                initial = LocalTime.of(minuteOfDay / 60, minuteOfDay % 60),
-                onConfirm = {
-                    val picked = it.hour * 60 + it.minute
-                    // The default time stays unnamed; any other is one an all-day reminder can name.
-                    minuteOfDay = if (picked == state.allDayMinuteOfDay) picked else TaskReminder.allDayMinuteOfDay(picked)
-                    pickingTime = false
-                },
-                onDismiss = { pickingTime = false },
-            )
-        }
     }
 
     if (showRecurrencePicker) {
@@ -841,9 +727,9 @@ private fun EditCard(
         }
     }
     if (onClick != null) {
-        Surface(onClick = onClick, color = color, shape = shape, modifier = Modifier.fillMaxWidth().revealOnFocus()) { inner() }
+        Surface(onClick = onClick, color = color, shape = shape, modifier = Modifier.fillMaxWidth()) { inner() }
     } else {
-        Surface(color = color, shape = shape, modifier = Modifier.fillMaxWidth().revealOnFocus()) { inner() }
+        Surface(color = color, shape = shape, modifier = Modifier.fillMaxWidth()) { inner() }
     }
 }
 
@@ -1154,77 +1040,6 @@ private fun AddReminderCard(position: Position, label: String, onClick: () -> Un
     }
 }
 
-/** The input sits beside the icon; the tags and any suggestions run below it. */
-@OptIn(ExperimentalLayoutApi::class)
-@Composable
-private fun TagsCard(
-    tags: List<String>,
-    draft: String,
-    suggestions: List<String>,
-    onDraftChange: (String) -> Unit,
-    onCommitDraft: () -> Unit,
-    onAdd: (String) -> Unit,
-    onRemove: (String) -> Unit,
-) {
-    val query = draft.trim()
-    val matches = if (query.isEmpty()) {
-        emptyList()
-    } else {
-        suggestions.filter { it.contains(query, ignoreCase = true) && it !in tags }.take(MAX_TAG_SUGGESTIONS)
-    }
-    EditCard(
-        icon = Icons.Rounded.Sell,
-        iconContentDescription = stringResource(R.string.edit_tags_label),
-        header = {
-            InlineTextField(
-                value = draft,
-                onValueChange = onDraftChange,
-                placeholder = stringResource(R.string.edit_tags_hint),
-                capitalization = KeyboardCapitalization.None,
-                imeAction = ImeAction.Done,
-                onImeAction = onCommitDraft,
-            )
-        },
-    ) {
-        if (matches.isNotEmpty()) {
-            TagFlow(modifier = Modifier.padding(top = 8.dp)) {
-                matches.forEach { match ->
-                    TagChip(
-                        name = match,
-                        muted = true,
-                        icon = Icons.Rounded.Add,
-                        onClick = { onAdd(match) },
-                    )
-                }
-            }
-        }
-        if (tags.isNotEmpty()) {
-            TagFlow(modifier = Modifier.padding(top = 8.dp)) {
-                tags.forEach { tag ->
-                    TagChip(
-                        name = tag,
-                        icon = Icons.Rounded.Close,
-                        iconContentDescription = stringResource(R.string.edit_tag_remove, tag),
-                        onClick = { onRemove(tag) },
-                    )
-                }
-            }
-        }
-    }
-}
-
-@OptIn(ExperimentalLayoutApi::class)
-@Composable
-private fun TagFlow(modifier: Modifier = Modifier, content: @Composable () -> Unit) {
-    FlowRow(
-        modifier = modifier,
-        horizontalArrangement = Arrangement.spacedBy(8.dp),
-        verticalArrangement = Arrangement.spacedBy(8.dp),
-    ) { content() }
-}
-
-private const val MAX_TAG_SUGGESTIONS = 8
-
 /** Picks one hidden optional section to add to the form. */
 @Composable
 private fun FieldPickerDialog(

app/src/main/java/de/jeanlucmakiola/agendula/ui/edit/TaskEditViewModel.kt

@@ -3,31 +3,20 @@ package de.jeanlucmakiola.agendula.ui.edit
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
-import de.jeanlucmakiola.agendula.data.prefs.DEFAULT_ALL_DAY_REMINDER_MINUTE
-import de.jeanlucmakiola.agendula.data.prefs.Settings
 import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.agendula.data.reminders.ReminderScheduler
 import de.jeanlucmakiola.agendula.data.tasks.TaskConflictException
 import de.jeanlucmakiola.agendula.data.tasks.TasksRepository
 import de.jeanlucmakiola.agendula.domain.Priority
-import de.jeanlucmakiola.agendula.domain.SmartList
 import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskFilter
 import de.jeanlucmakiola.agendula.domain.TaskForm
 import de.jeanlucmakiola.agendula.domain.TaskFormError
 import de.jeanlucmakiola.agendula.domain.TaskFormField
-import de.jeanlucmakiola.agendula.domain.allDayInstantOf
 import de.jeanlucmakiola.agendula.domain.TaskList
-import de.jeanlucmakiola.agendula.domain.TaskReminder
-import de.jeanlucmakiola.agendula.domain.taskReminderDisplayOrder
-import de.jeanlucmakiola.agendula.data.tasks.StoredReminders
-import java.time.ZoneId
 import de.jeanlucmakiola.agendula.domain.populatedFields
 import de.jeanlucmakiola.agendula.domain.htmlToPlainText
 import de.jeanlucmakiola.agendula.domain.looksLikeHtml
-import de.jeanlucmakiola.agendula.domain.newTaskPreset
-import de.jeanlucmakiola.agendula.domain.normalizeTags
-import de.jeanlucmakiola.agendula.domain.tagsInUse
 import de.jeanlucmakiola.agendula.domain.rebasedForAllDay
 import de.jeanlucmakiola.agendula.domain.readableDescription
 import de.jeanlucmakiola.agendula.domain.recurrence.RecurringScope
@@ -36,7 +25,6 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
-import java.time.LocalDate
 import javax.inject.Inject
 import kotlin.time.Clock
 import kotlin.time.Instant
@@ -60,20 +48,9 @@ data class TaskEditUiState(
     val priority: Priority = Priority.NONE,
     val parentId: Long? = null,
     val percentComplete: Int? = null,
-    val reminders: List<TaskReminder> = emptyList(),
+    val reminders: List<Int> = emptyList(),
-    /** Whether the user added or removed a reminder; until then the defaults follow the form. */
-    val remindersTouched: Boolean = false,
-    /** Whether [reminders] are stored as they are — see [TaskForm.remindersChosen]. */
-    val remindersChosen: Boolean = false,
-    /** The time an all-day reminder without one of its own rings at. */
-    val allDayMinuteOfDay: Int = DEFAULT_ALL_DAY_REMINDER_MINUTE,
     val location: String = "",
     val url: String = "",
-    val tags: List<String> = emptyList(),
-    /** What is typed in the tag field and not added yet. Saving still takes it. */
-    val tagDraft: String = "",
-    /** Every tag already in use, for completing what the user types. */
-    val tagSuggestions: List<String> = emptyList(),
     val rrule: String? = null,
     /** Editing one occurrence of a series: saving asks how far the edit reaches. */
     val isOccurrence: Boolean = false,
@@ -136,47 +113,22 @@ class TaskEditViewModel @Inject constructor(
     /** Sections shown by default (a setting); the rest unfold via [revealField]. */
     private var defaultFields: Set<TaskFormField> = emptySet()
 
-    /** The settings as the form was bound, for the defaults an all-day switch swaps in. */
-    private var settings: Settings = Settings()
-
-    /** The reminders before the last all-day switch, and what it made of them. */
-    private var lastSwitch: Pair<List<TaskReminder>, List<TaskReminder>>? = null
-
-    /** The reminders the task was loaded with, and the dates it had then. */
-    private var storedReminders: Set<TaskReminder> = emptySet()
-
-    /** [storedReminders] as the task's current kind, timed or all-day. */
-    private var loadedReminders: List<TaskReminder> = emptyList()
-    private var loadedStart: Instant? = null
-    private var loadedDue: Instant? = null
-
     /** Start a fresh task, optionally pre-selecting a list / parent. */
-    fun bindNew(
+    fun bindNew(presetListId: Long? = null, parentId: Long? = null, initialTitle: String? = null) {
-        presetListId: Long? = null,
-        parentId: Long? = null,
-        initialTitle: String? = null,
-        presetTag: String? = null,
-        presetFilterId: Long? = null,
-    ) {
         if (bound) return
         bound = true
         editingTaskId = null
         baselineLastModified = null
         viewModelScope.launch {
             val settings = settingsPrefs.settings.first()
-            this@TaskEditViewModel.settings = settings
             defaultFields = settings.defaultEditFields
             val lists = runCatching { repository.taskLists().first() }.getOrElse { emptyList() }
-            val preset = presetFilterId?.let { settingsPrefs.savedFilter(it).first() }
-                ?.newTaskPreset(LocalDate.now())
             // A read-only or vanished default — or a widget's preset list, if it was
             // since deleted or turned read-only — would give the task a list it
             // cannot be saved to.
             val writable = lists.filter { it.acceptsWrites }
-            val filterLists = preset?.listIds.orEmpty()
             val defaultList = presetListId?.takeIf { id -> writable.any { it.id == id } }
-                ?: settings.defaultListId?.takeIf { id -> writable.any { it.id == id } && (filterLists.isEmpty() || id in filterLists) }
+                ?: settings.defaultListId?.takeIf { id -> writable.any { it.id == id } }
-                ?: writable.firstOrNull { it.id in filterLists }?.id
                 ?: writable.firstOrNull { !it.isLocal }?.id
                 ?: writable.firstOrNull()?.id
             _state.value = withFields(
@@ -184,25 +136,13 @@ class TaskEditViewModel @Inject constructor(
                     loading = false,
                     isNew = true,
                     autofocusTitle = settings.autofocusTitle,
-                    allDayMinuteOfDay = settings.allDayReminderMinuteOfDay,
                     listId = defaultList,
-                    // A preset due is all-day, so a default start has to be too, or
+                    start = if (settings.defaultStartToday) Clock.System.now() else null,
-                    // today's start would land after a due of today.
-                    start = when {
-                        !settings.defaultStartToday -> null
-                        preset?.dueDate != null -> allDayInstantOf(LocalDate.now())
-                        else -> Clock.System.now()
-                    },
-                    // The same all-day value picking the date in the date field gives.
-                    due = preset?.dueDate?.let(::allDayInstantOf),
-                    isAllDay = preset?.dueDate != null,
-                    priority = preset?.priority ?: Priority.NONE,
                     parentId = parentId,
                     lists = lists,
                     parentCandidates = loadParents(defaultList, selfId = null),
                     title = initialTitle.orEmpty(),
-                    tags = (listOfNotNull(presetTag) + preset?.tags.orEmpty()).distinct(),
+                ),
-                ).withDefaultReminders(),
             ).also { baseline = it.toForm().copy(title = "") }
         }
     }
@@ -214,9 +154,7 @@ class TaskEditViewModel @Inject constructor(
         editingTaskId = taskId
         editingOccurrence = occurrenceStart
         viewModelScope.launch {
-            val settings = settingsPrefs.settings.first()
+            defaultFields = settingsPrefs.settings.first().defaultEditFields
-            this@TaskEditViewModel.settings = settings
-            defaultFields = settings.defaultEditFields
             val lists = runCatching { repository.taskLists().first() }.getOrElse { emptyList() }
             val task = runCatching { repository.taskDetail(taskId, occurrenceStart).first()?.task }.getOrNull()
             if (task == null) {
@@ -224,10 +162,6 @@ class TaskEditViewModel @Inject constructor(
                 return@launch
             }
             baselineLastModified = task.lastModified
-            loadedReminders = repository.remindersFor(taskId).map { it.lead }.distinct()
-            storedReminders = loadedReminders.toSet()
-            loadedStart = task.start
-            loadedDue = task.due
             _state.value = withFields(
                 TaskEditUiState(
                     loading = false,
@@ -242,12 +176,9 @@ class TaskEditViewModel @Inject constructor(
                     priority = task.priority,
                     parentId = task.parentId,
                     percentComplete = task.percentComplete,
-                    reminders = loadedReminders
+                    reminders = repository.remindersFor(taskId).filter { !it.fromStart }.map { it.minutesBefore },
-                        .sortedWith(taskReminderDisplayOrder(task.isAllDay, settings.allDayReminderMinuteOfDay)),
-                    allDayMinuteOfDay = settings.allDayReminderMinuteOfDay,
                     location = task.location.orEmpty(),
                     url = task.url.orEmpty(),
-                    tags = task.tags,
                     rrule = task.recurrenceRule,
                     originalRule = task.recurrenceRule,
                     isOccurrence = task.isOccurrence,
@@ -271,18 +202,6 @@ class TaskEditViewModel @Inject constructor(
         return tasks.filter { !it.isClosed && !it.isSubtask && it.taskId != selfId }
     }
 
-    private var suggestionsRequested = false
-
-    /** Tags on open tasks, read once the user starts typing one rather than on every bind. */
-    private fun loadTagSuggestions() {
-        if (suggestionsRequested) return
-        suggestionsRequested = true
-        viewModelScope.launch {
-            val tasks = runCatching { repository.tasks(TaskFilter.Smart(SmartList.ALL)).first() }.getOrElse { emptyList() }
-            _state.value = _state.value.copy(tagSuggestions = tagsInUse(tasks))
-        }
-    }
-
     /** Reveal an optional section (one tap from the "More fields" picker). */
     fun revealField(field: TaskFormField) = update {
         val visible = it.visibleFields + field
@@ -307,104 +226,37 @@ class TaskEditViewModel @Inject constructor(
     /** Switching list invalidates the parent (it lived in the old list); reload candidates. */
     fun onListChange(listId: Long) {
         if (_state.value.listId == listId) return // re-picking the same list keeps the parent
-        update { it.copy(listId = listId, parentId = null, errors = emptySet()).withDefaultReminders() }
+        update { it.copy(listId = listId, parentId = null, errors = emptySet()) }
         viewModelScope.launch {
             val candidates = loadParents(listId, selfId = editingTaskId)
             update { it.copy(parentCandidates = candidates) }
         }
     }
 
-    fun onStartChange(value: Instant?) = update { it.copy(start = value).withDefaultReminders() }
+    fun onStartChange(value: Instant?) = update { it.copy(start = value) }
-    fun onDueChange(value: Instant?) = update { it.copy(due = value).withDefaultReminders() }
+    fun onDueChange(value: Instant?) = update { it.copy(due = value) }
     /**
      * All-day and timed values use different conventions (UTC midnight vs. a real
      * instant in the device zone), so the switch has to move the timestamps too —
      * flipping the flag alone makes an all-day task read back as "02:00", which
-     * looks to the user like the time reset itself. The reminders are made
+     * looks to the user like the time reset itself.
-     * the new kind's here, so the editor shows what will be stored; switching
-     * straight back gives the old ones back.
      */
     fun onAllDayChange(value: Boolean) = update {
-        if (it.isAllDay == value) return@update it
+        it.copy(
-        val switched = it.copy(
             isAllDay = value,
             start = it.start?.rebasedForAllDay(value),
             due = it.due?.rebasedForAllDay(value),
         )
-        if (!it.remindersTouched) {
-            loadedReminders = carried(loadedReminders, switched)
-            return@update switched.withDefaultReminders()
-        }
-        switched.copy(reminders = carried(it.reminders, switched).sortedForDisplay(switched))
     }
-
-    /** [reminders] as [switched]'s kind; straight back after a switch, the ones before it. */
-    private fun carried(reminders: List<TaskReminder>, switched: TaskEditUiState): List<TaskReminder> {
-        val previous = lastSwitch
-        val carried = if (previous != null && previous.second == reminders) {
-            previous.first
-        } else {
-            StoredReminders.switched(reminders, switched.toForm(), settings, nowMillis(), ZoneId.systemDefault())
-        }
-        lastSwitch = reminders to carried
-        return carried
-    }
-
-    /**
-     * The reminders the task will be saved with while the user has not
-     * touched them: those it was loaded with, plus the defaults of the dates
-     * it has gained — all of them, for a new task. Shown so they are noted
-     * before saving rather than added unseen.
-     */
-    private fun TaskEditUiState.withDefaultReminders(): TaskEditUiState {
-        if (remindersTouched) return this
-        val reminders = StoredReminders.withDefaults(
-            toForm().copy(reminders = loadedReminders),
-            loadedStart,
-            loadedDue,
-            settings,
-            nowMillis(),
-            ZoneId.systemDefault(),
-        ).sortedForDisplay(this)
-        val visible = if (reminders.isEmpty()) visibleFields else visibleFields + TaskFormField.Reminder
-        return copy(
-            reminders = reminders,
-            // A new task's, or defaults added to the ones it had: stored as shown.
-            remindersChosen = isNew || reminders.toSet() != storedReminders,
-            visibleFields = visible,
-            hiddenFields = hiddenOf(visible),
-        )
-    }
-
-    private fun nowMillis(): Long = Clock.System.now().toEpochMilliseconds()
     fun onPriorityChange(value: Priority) = update { it.copy(priority = value) }
     fun onPercentChange(value: Int?) = update { it.copy(percentComplete = value?.coerceIn(0, 100)) }
     fun onParentChange(parentId: Long?) = update { it.copy(parentId = parentId) }
-    fun addReminder(reminder: TaskReminder) = update {
+    fun addReminder(minutesBeforeDue: Int) = update {
-        it.copy(
+        it.copy(reminders = (it.reminders + minutesBeforeDue).distinct().sorted(), errors = emptySet())
-            reminders = (it.reminders + reminder).distinct().sortedForDisplay(it),
-            remindersTouched = true,
-            remindersChosen = true,
-            errors = emptySet(),
-        )
-    }
-    fun removeReminder(reminder: TaskReminder) = update {
-        it.copy(reminders = it.reminders - reminder, remindersTouched = true, remindersChosen = true)
     }
+    fun removeReminder(minutesBeforeDue: Int) = update { it.copy(reminders = it.reminders - minutesBeforeDue) }
     fun onLocationChange(value: String) = update { it.copy(location = value) }
     fun onUrlChange(value: String) = update { it.copy(url = value) }
-    fun addTag(name: String) = update { it.copy(tags = normalizeTags(it.tags + name), tagDraft = "") }
-
-    /** A typed comma adds what came before it. */
-    fun onTagDraftChange(value: String) {
-        loadTagSuggestions()
-        update {
-            if (',' in value) it.copy(tags = it.withDraft(value), tagDraft = "") else it.copy(tagDraft = value)
-        }
-    }
-
-    fun commitTagDraft() = update { it.copy(tags = it.withDraft(it.tagDraft), tagDraft = "") }
-    fun removeTag(name: String) = update { it.copy(tags = it.tags - name) }
     fun onRecurrenceChange(rrule: String?) = update { it.copy(rrule = rrule, errors = emptySet()) }
 
     /** Dismiss the conflict prompt without saving (the user keeps editing). */
@@ -473,10 +325,6 @@ class TaskEditViewModel @Inject constructor(
     }
 }
 
-/** The order the editor lists [state]'s reminders in. */
-private fun List<TaskReminder>.sortedForDisplay(state: TaskEditUiState): List<TaskReminder> =
-    sortedWith(taskReminderDisplayOrder(state.isAllDay, state.allDayMinuteOfDay))
-
 /** Snapshot the editable state as a validated [TaskForm]. */
 private fun TaskEditUiState.toForm(): TaskForm = TaskForm(
     title = title,
@@ -489,11 +337,7 @@ private fun TaskEditUiState.toForm(): TaskForm = TaskForm(
     parentId = parentId,
     percentComplete = percentComplete,
     reminders = reminders,
-    remindersChosen = remindersChosen,
     location = location.ifBlank { null },
     url = url.ifBlank { null },
-    tags = withDraft(tagDraft),
     rrule = rrule,
 )
-
-private fun TaskEditUiState.withDraft(draft: String): List<String> = normalizeTags(tags + draft.split(','))

app/src/main/java/de/jeanlucmakiola/agendula/ui/export/ExportScreen.kt

@@ -70,7 +70,6 @@ private const val EXTERNAL_STORAGE = "com.android.externalstorage.documents"
 @Composable
 fun ExportScreen(
     onBack: () -> Unit,
-    visible: Boolean,
     modifier: Modifier = Modifier,
     viewModel: ExportViewModel = hiltViewModel(),
 ) {
@@ -90,8 +89,6 @@ fun ExportScreen(
         title = stringResource(R.string.settings_export),
         onBack = onBack,
         modifier = modifier,
-        predictiveBack = true,
-        visible = visible,
     ) {
         Text(
             text = stringResource(R.string.export_hint),

app/src/main/java/de/jeanlucmakiola/agendula/ui/filters/FilterEditScreen.kt

@@ -1,259 +0,0 @@
-package de.jeanlucmakiola.agendula.ui.filters
-
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.ChevronRight
-import androidx.compose.material.icons.rounded.Delete
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Button
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Switch
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import de.jeanlucmakiola.agendula.R
-import de.jeanlucmakiola.agendula.domain.DueWindow
-import de.jeanlucmakiola.agendula.domain.Priority
-import de.jeanlucmakiola.agendula.domain.SavedFilter
-import de.jeanlucmakiola.agendula.domain.TagMatch
-import de.jeanlucmakiola.agendula.ui.common.ListColorChip
-import de.jeanlucmakiola.agendula.ui.common.NameField
-import de.jeanlucmakiola.floret.components.CollapsingScaffold
-import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.GroupedSectionHeader
-import de.jeanlucmakiola.floret.components.OptionPicker
-import de.jeanlucmakiola.floret.components.Position
-import de.jeanlucmakiola.floret.components.SelectedCheck
-import de.jeanlucmakiola.floret.components.positionOf
-
-/**
- * Creates or edits a [SavedFilter]: a name, then due windows, priority, lists and
- * tags. Each multi-choice section leads with an "any" row that is selected while
- * nothing in it is, so an untouched section visibly doesn't narrow.
- */
-@Composable
-fun FilterEditScreen(
-    viewModel: FilterEditViewModel,
-    isNew: Boolean,
-    onSaved: (Long) -> Unit,
-    onDeleted: () -> Unit,
-    onBack: () -> Unit,
-) {
-    val draft by viewModel.draft.collectAsStateWithLifecycle()
-    val lists by viewModel.lists.collectAsStateWithLifecycle()
-    val tagsInUse by viewModel.tags.collectAsStateWithLifecycle()
-    val filter = draft
-    var choosingPriority by rememberSaveable { mutableStateOf(false) }
-    var confirmDelete by rememberSaveable { mutableStateOf(false) }
-    val save = { viewModel.save(onSaved) }
-
-    CollapsingScaffold(
-        title = stringResource(if (isNew) R.string.filter_new_title else R.string.filter_edit_title),
-        onBack = onBack,
-        largeTopBar = false,
-        actions = {
-            Button(
-                onClick = save,
-                enabled = filter?.name?.isNotBlank() == true,
-                modifier = Modifier.padding(end = 12.dp),
-            ) { Text(stringResource(R.string.save)) }
-        },
-    ) {
-        if (filter == null) return@CollapsingScaffold
-
-        NameField(
-            name = filter.name,
-            placeholder = stringResource(R.string.filter_name_hint),
-            autoFocus = isNew,
-            onNameChange = { name -> viewModel.update { it.copy(name = name) } },
-            onImeAction = save,
-        )
-
-        GroupedSectionHeader(stringResource(R.string.filter_section_due))
-        val windows = DueWindow.entries
-        ChoiceRow(
-            title = stringResource(R.string.filter_any_due),
-            position = positionOf(0, windows.size + 1),
-            selected = filter.due.isEmpty(),
-            onClick = { viewModel.update { it.copy(due = emptySet()) } },
-        )
-        windows.forEachIndexed { index, window ->
-            ChoiceRow(
-                title = dueWindowLabel(window),
-                position = positionOf(index + 1, windows.size + 1),
-                selected = window in filter.due,
-                onClick = { viewModel.update { it.copy(due = it.due.toggle(window)) } },
-            )
-        }
-
-        GroupedSectionHeader(stringResource(R.string.filter_section_priority))
-        GroupedRow(
-            title = minPriorityLabel(filter.minPriority),
-            position = Position.Alone,
-            trailing = { Icon(Icons.Rounded.ChevronRight, contentDescription = null) },
-            onClick = { choosingPriority = true },
-        )
-
-        if (lists.isNotEmpty()) {
-            GroupedSectionHeader(stringResource(R.string.filter_section_lists))
-            val showAccount = lists.mapTo(HashSet()) { it.accountName }.size > 1
-            ChoiceRow(
-                title = stringResource(R.string.filter_any_list),
-                position = positionOf(0, lists.size + 1),
-                selected = filter.anyList,
-                onClick = { viewModel.update { it.copy(listIds = emptySet(), listsElsewhere = false) } },
-            )
-            lists.forEachIndexed { index, list ->
-                ChoiceRow(
-                    title = list.name,
-                    summary = list.accountName.takeIf { showAccount },
-                    position = positionOf(index + 1, lists.size + 1),
-                    selected = list.id in filter.listIds,
-                    leading = { ListColorChip(list.color) },
-                    onClick = { viewModel.update { it.copy(listIds = it.listIds.toggle(list.id)) } },
-                )
-            }
-        }
-
-        // A tag no open task carries any more stays listed while the filter uses
-        // it, so it can still be unticked.
-        val tags = remember(tagsInUse, filter.tags) {
-            (tagsInUse + filter.tags).distinct().sortedWith(String.CASE_INSENSITIVE_ORDER)
-        }
-        if (tags.isNotEmpty()) {
-            GroupedSectionHeader(stringResource(R.string.filter_section_tags))
-            ChoiceRow(
-                title = stringResource(R.string.filter_any_tag),
-                position = positionOf(0, tags.size + 1),
-                selected = filter.tags.isEmpty(),
-                onClick = { viewModel.update { it.copy(tags = emptySet()) } },
-            )
-            tags.forEachIndexed { index, tag ->
-                ChoiceRow(
-                    title = tag,
-                    position = positionOf(index + 1, tags.size + 1),
-                    selected = tag in filter.tags,
-                    onClick = { viewModel.update { it.copy(tags = it.tags.toggle(tag)) } },
-                )
-            }
-            if (filter.tags.size > 1) {
-                Spacer(Modifier.height(8.dp))
-                GroupedRow(
-                    title = stringResource(R.string.filter_match_all_tags),
-                    summary = stringResource(
-                        if (filter.tagMatch == TagMatch.ALL) R.string.filter_match_all_on else R.string.filter_match_all_off,
-                    ),
-                    position = Position.Alone,
-                    trailing = {
-                        Switch(
-                            checked = filter.tagMatch == TagMatch.ALL,
-                            onCheckedChange = { all ->
-                                viewModel.update { it.copy(tagMatch = if (all) TagMatch.ALL else TagMatch.ANY) }
-                            },
-                        )
-                    },
-                    onClick = {
-                        viewModel.update { it.copy(tagMatch = if (it.tagMatch == TagMatch.ALL) TagMatch.ANY else TagMatch.ALL) }
-                    },
-                )
-            }
-        }
-
-        if (filter.id > 0) {
-            Spacer(Modifier.height(24.dp))
-            GroupedRow(
-                title = stringResource(R.string.filter_delete),
-                position = Position.Alone,
-                contentColor = MaterialTheme.colorScheme.error,
-                leading = { Icon(Icons.Rounded.Delete, contentDescription = null) },
-                onClick = { confirmDelete = true },
-            )
-        }
-        Spacer(Modifier.height(24.dp))
-    }
-
-    if (choosingPriority && filter != null) {
-        OptionPicker(
-            title = stringResource(R.string.filter_section_priority),
-            options = Priority.entries,
-            selected = filter.minPriority,
-            label = { minPriorityLabel(it) },
-            onSelect = { priority -> viewModel.update { it.copy(minPriority = priority) } },
-            onDismiss = { choosingPriority = false },
-        )
-    }
-
-    if (confirmDelete && filter != null) {
-        AlertDialog(
-            onDismissRequest = { confirmDelete = false },
-            title = { Text(stringResource(R.string.filter_delete_title, filter.name)) },
-            text = { Text(stringResource(R.string.filter_delete_body)) },
-            confirmButton = {
-                TextButton(onClick = { confirmDelete = false; viewModel.delete(onDeleted) }) {
-                    Text(stringResource(R.string.filter_delete_confirm))
-                }
-            },
-            dismissButton = {
-                TextButton(onClick = { confirmDelete = false }) { Text(stringResource(R.string.dialog_cancel)) }
-            },
-        )
-    }
-}
-
-@Composable
-private fun ChoiceRow(
-    title: String,
-    position: Position,
-    selected: Boolean,
-    onClick: () -> Unit,
-    summary: String? = null,
-    leading: @Composable (() -> Unit)? = null,
-) {
-    GroupedRow(
-        title = title,
-        summary = summary,
-        position = position,
-        selected = selected,
-        leading = leading,
-        trailing = if (selected) {
-            { SelectedCheck() }
-        } else {
-            null
-        },
-        onClick = onClick,
-    )
-}
-
-private fun <T> Set<T>.toggle(item: T): Set<T> = if (item in this) this - item else this + item
-
-@Composable
-private fun dueWindowLabel(window: DueWindow): String = stringResource(
-    when (window) {
-        DueWindow.OVERDUE -> R.string.smart_overdue
-        DueWindow.TODAY -> R.string.smart_today
-        DueWindow.UPCOMING -> R.string.smart_upcoming
-        DueWindow.NO_DATE -> R.string.smart_no_date
-    },
-)
-
-@Composable
-internal fun minPriorityLabel(priority: Priority): String = stringResource(
-    when (priority) {
-        Priority.NONE -> R.string.filter_priority_any
-        Priority.LOW -> R.string.filter_priority_low
-        Priority.MEDIUM -> R.string.filter_priority_medium
-        Priority.HIGH -> R.string.filter_priority_high
-    },
-)

app/src/main/java/de/jeanlucmakiola/agendula/ui/filters/FilterEditViewModel.kt

@@ -1,91 +0,0 @@
-package de.jeanlucmakiola.agendula.ui.filters
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.agendula.data.tasks.TasksRepository
-import de.jeanlucmakiola.agendula.domain.SavedFilter
-import de.jeanlucmakiola.agendula.domain.SmartList
-import de.jeanlucmakiola.agendula.domain.TaskFilter
-import de.jeanlucmakiola.agendula.domain.TaskList
-import de.jeanlucmakiola.agendula.domain.tagsInUse
-import de.jeanlucmakiola.agendula.widget.TaskWidgetUpdater
-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.first
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-/** Holds the filter being created or edited until it's saved. Call [bind] first. */
-@HiltViewModel
-class FilterEditViewModel @Inject constructor(
-    private val settingsPrefs: SettingsPrefs,
-    private val widgetUpdater: TaskWidgetUpdater,
-    private val repository: TasksRepository,
-) : ViewModel() {
-
-    private val _draft = MutableStateFlow<SavedFilter?>(null)
-
-    /** `null` until [bind] has loaded the filter. An id of 0 is a new one. */
-    val draft: StateFlow<SavedFilter?> = _draft.asStateFlow()
-
-    val lists: StateFlow<List<TaskList>> = repository.taskLists()
-        .catch { emit(emptyList()) }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
-
-    /** Every tag on an open task. */
-    val tags: StateFlow<List<String>> = repository.tasks(TaskFilter.Smart(SmartList.ALL))
-        .map { tagsInUse(it) }
-        .catch { emit(emptyList()) }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
-
-    private var bound = false
-    private var saving = false
-
-    fun bind(filterId: Long?) {
-        if (bound) return
-        bound = true
-        if (filterId == null) {
-            _draft.value = SavedFilter(id = 0, name = "")
-            return
-        }
-        viewModelScope.launch {
-            val saved = settingsPrefs.savedFilter(filterId).first()
-            // Show it as it matches: lists deleted since drop out, as they do in the repository.
-            val existing = runCatching { repository.taskLists().first().mapTo(HashSet()) { it.id } }.getOrNull()
-            _draft.value = saved?.let { if (existing == null) it else it.withListsIn(existing) }
-                ?: SavedFilter(id = 0, name = "")
-        }
-    }
-
-    fun update(transform: (SavedFilter) -> SavedFilter) {
-        _draft.value = _draft.value?.let(transform)
-    }
-
-    fun save(onSaved: (Long) -> Unit) {
-        val filter = _draft.value ?: return
-        if (filter.name.isBlank() || saving) return
-        saving = true
-        viewModelScope.launch {
-            val id = settingsPrefs.saveFilter(filter.copy(name = filter.name.trim()))
-            // A widget showing this filter doesn't watch the prefs.
-            widgetUpdater.requestRefresh()
-            onSaved(id)
-        }
-    }
-
-    fun delete(onDeleted: () -> Unit) {
-        val id = _draft.value?.id?.takeIf { it > 0 } ?: return
-        viewModelScope.launch {
-            settingsPrefs.deleteFilter(id)
-            widgetUpdater.requestRefresh()
-            onDeleted()
-        }
-    }
-}

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

@@ -76,8 +76,6 @@ private val PICK_TYPES = arrayOf("text/calendar", "text/x-vcalendar", "applicati
 fun ImportScreen(
     onBack: () -> Unit,
     modifier: Modifier = Modifier,
-    predictiveBack: Boolean = false,
-    visible: Boolean? = null,
     initialUri: Uri? = null,
     onOpenStorage: (() -> Unit)? = null,
     viewModel: ImportViewModel = hiltViewModel(),
@@ -107,8 +105,6 @@ fun ImportScreen(
         title = stringResource(R.string.import_title),
         onBack = onBack,
         modifier = modifier,
-        predictiveBack = predictiveBack,
-        visible = visible,
     ) {
         Text(
             text = stringResource(R.string.import_hint),

app/src/main/java/de/jeanlucmakiola/agendula/ui/licences/LicencesScreen.kt

@@ -25,14 +25,12 @@ import de.jeanlucmakiola.floret.components.positionOf
  * source, which is the specific thing §3.2(a) requires us to point at.
  */
 @Composable
-internal fun LicencesScreen(onBack: () -> Unit, visible: Boolean) {
+internal fun LicencesScreen(onBack: () -> Unit) {
     val uriHandler = LocalUriHandler.current
 
     CollapsingScaffold(
         title = stringResource(R.string.licences_title),
         onBack = onBack,
-        predictiveBack = true,
-        visible = visible,
     ) {
         Text(
             stringResource(R.string.licences_intro),

app/src/main/java/de/jeanlucmakiola/agendula/ui/lists/ListEditorSheet.kt

@@ -30,6 +30,7 @@ import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
@@ -39,22 +40,25 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.luminance
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.agendula.R
 import de.jeanlucmakiola.agendula.domain.TaskList
 import de.jeanlucmakiola.agendula.ui.common.DefaultListColor
 import de.jeanlucmakiola.agendula.ui.common.ListColorChip
 import de.jeanlucmakiola.agendula.ui.common.ListPalette
-import de.jeanlucmakiola.agendula.ui.common.NameField
 import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.GroupedSurface
+import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.OptionPicker
 import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.floret.components.pastelize
@@ -254,14 +258,27 @@ internal fun ListNameField(
     autoFocus: Boolean,
     onNameChange: (String) -> Unit,
     onImeAction: () -> Unit,
-) = NameField(
+) {
-    name = name,
+    val focusRequester = remember { FocusRequester() }
-    placeholder = stringResource(R.string.list_name_hint),
+    LaunchedEffect(autoFocus) { if (autoFocus) focusRequester.requestFocus() }
-    autoFocus = autoFocus,
+    GroupedSurface(position = Position.Alone, modifier = Modifier.padding(horizontal = 16.dp)) {
-    onNameChange = onNameChange,
+        Row(
-    onImeAction = onImeAction,
+            modifier = Modifier.fillMaxWidth().heightIn(min = 72.dp).padding(horizontal = 16.dp),
-    leading = { ListColorChip(color) },
+            verticalAlignment = Alignment.CenterVertically,
-)
+            horizontalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            ListColorChip(color)
+            InlineTextField(
+                value = name,
+                onValueChange = onNameChange,
+                placeholder = stringResource(R.string.list_name_hint),
+                imeAction = ImeAction.Done,
+                onImeAction = onImeAction,
+                modifier = Modifier.fillMaxWidth().focusRequester(focusRequester),
+            )
+        }
+    }
+}
 
 /**
  * The palette as two rows of round swatches; the chosen one carries a check.

app/src/main/java/de/jeanlucmakiola/agendula/ui/lists/ListsScreen.kt

@@ -3,8 +3,6 @@ package de.jeanlucmakiola.agendula.ui.lists
 import de.jeanlucmakiola.floret.components.ReorderableColumn
 import androidx.compose.material.icons.rounded.Check
 import androidx.compose.material.icons.rounded.DragHandle
-import androidx.compose.material.icons.rounded.FilterList
-import androidx.compose.material.icons.rounded.Sell
 import androidx.compose.material.icons.rounded.SwapVert
 import androidx.activity.compose.BackHandler
 import androidx.compose.animation.AnimatedVisibility
@@ -32,7 +30,6 @@ import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.statusBarsPadding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.LazyListScope
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.itemsIndexed
@@ -89,7 +86,6 @@ import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskFilter
 import de.jeanlucmakiola.agendula.ui.common.ActionShapes
 import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.floret.components.SnackChip
 import de.jeanlucmakiola.floret.components.SnackChipHeight
 import de.jeanlucmakiola.floret.components.SnackChipMargin
@@ -118,7 +114,6 @@ fun ListsScreen(
     onNewTask: () -> Unit,
     onOpenSettings: () -> Unit,
     modifier: Modifier = Modifier,
-    onNewFilter: () -> Unit = {},
     viewModel: ListsViewModel = hiltViewModel(),
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
@@ -184,7 +179,6 @@ fun ListsScreen(
                         onOpenFilter = onOpenFilter,
                         onOpenTask = onOpenTask,
                         onNewList = { newList = true },
-                        onNewFilter = onNewFilter,
                         onReorder = viewModel::reorderLists,
                         topPadding = 0.dp,
                         bottomPadding = inner.calculateBottomPadding() + 96.dp,
@@ -258,7 +252,6 @@ private fun ListsContent(
     onOpenFilter: (TaskFilter) -> Unit,
     onOpenTask: (Task) -> Unit,
     onNewList: () -> Unit,
-    onNewFilter: () -> Unit,
     onReorder: (List<Long>) -> Unit,
     topPadding: androidx.compose.ui.unit.Dp,
     bottomPadding: androidx.compose.ui.unit.Dp,
@@ -377,90 +370,6 @@ private fun ListsContent(
                 }
             }
         }
-
-        if (state.tags.isNotEmpty()) {
-            item(key = "tags-header") { SectionHeader(stringResource(R.string.tags_header)) }
-            itemsIndexed(state.tags, key = { _, t -> "tag-${t.tag}" }) { index, overview ->
-                GroupedRow(
-                    title = overview.tag,
-                    position = positionOf(index, state.tags.size),
-                    leading = {
-                        Icon(
-                            Icons.Rounded.Sell,
-                            contentDescription = null,
-                            tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                        )
-                    },
-                    trailing = {
-                        Text(
-                            overview.openCount.toString(),
-                            style = MaterialTheme.typography.labelLarge,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant,
-                        )
-                    },
-                    onClick = { onOpenFilter(TaskFilter.Tagged(overview.tag)) },
-                )
-            }
-        }
-
-        if (state.groups.isNotEmpty()) {
-            filtersSection(state.filters, onOpenFilter, onNewFilter)
-        }
-    }
-}
-
-/** The saved filters, or a single row offering the first one. */
-private fun LazyListScope.filtersSection(
-    filters: List<FilterOverview>,
-    onOpenFilter: (TaskFilter) -> Unit,
-    onNewFilter: () -> Unit,
-) {
-    item(key = "filters-header") {
-        SectionHeader(
-            text = stringResource(R.string.filters_header),
-            action = if (filters.isEmpty()) {
-                null
-            } else {
-                {
-                    IconButton(onClick = onNewFilter) {
-                        Icon(Icons.Rounded.Add, contentDescription = stringResource(R.string.filter_new_title))
-                    }
-                }
-            },
-        )
-    }
-    if (filters.isEmpty()) {
-        item(key = "filters-empty") {
-            GroupedRow(
-                title = stringResource(R.string.filter_new_title),
-                summary = stringResource(R.string.filters_empty_hint),
-                position = Position.Alone,
-                leading = { Icon(Icons.Rounded.Add, contentDescription = null) },
-                onClick = onNewFilter,
-            )
-        }
-        return
-    }
-    itemsIndexed(filters, key = { _, f -> "filter-${f.filter.id}" }) { index, overview ->
-        GroupedRow(
-            title = overview.filter.name,
-            position = positionOf(index, filters.size),
-            leading = {
-                Icon(
-                    Icons.Rounded.FilterList,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                )
-            },
-            trailing = {
-                Text(
-                    overview.openCount.toString(),
-                    style = MaterialTheme.typography.labelLarge,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                )
-            },
-            onClick = { onOpenFilter(TaskFilter.Saved(overview.filter.id)) },
-        )
     }
 }
 

app/src/main/java/de/jeanlucmakiola/agendula/ui/lists/ListsViewModel.kt

@@ -8,13 +8,11 @@ import de.jeanlucmakiola.agendula.data.sync.RemoteLists
 import de.jeanlucmakiola.agendula.data.tasks.TasksRepository
 import de.jeanlucmakiola.agendula.data.tasks.recoveringFromProviderFailure
 import de.jeanlucmakiola.floret.time.DayWindow
-import de.jeanlucmakiola.agendula.domain.SavedFilter
 import de.jeanlucmakiola.agendula.domain.SmartList
 import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskFilter
 import de.jeanlucmakiola.agendula.domain.TaskFiltering
 import de.jeanlucmakiola.agendula.domain.TaskList
-import de.jeanlucmakiola.agendula.domain.tagsInUse
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
@@ -75,8 +73,6 @@ internal fun RemoteLists.Outcome.asFailure(local: ListWriteFailure): ListWriteFa
 data class ListOverview(val list: TaskList, val openCount: Int)
 data class AccountGroup(val accountName: String, val lists: List<ListOverview>)
 data class SmartCount(val smart: SmartList, val count: Int)
-data class TagOverview(val tag: String, val openCount: Int)
-data class FilterOverview(val filter: SavedFilter, val openCount: Int)
 
 sealed interface ListsUiState {
     data object Loading : ListsUiState
@@ -91,10 +87,6 @@ sealed interface ListsUiState {
         val upcoming: List<Task>,
         /** Every task (open and completed) — the corpus the home search filters. */
         val allTasks: List<Task>,
-        /** Each tag on an open task, alphabetically. */
-        val tags: List<TagOverview> = emptyList(),
-        /** The saved filters, oldest first. */
-        val filters: List<FilterOverview> = emptyList(),
     ) : ListsUiState
 }
 
@@ -133,9 +125,8 @@ class ListsViewModel @Inject constructor(
             // ones already ticked off to show "x of y done", so read them too.
             repository.tasks(TaskFilter.Smart(SmartList.COMPLETED)),
             settingsPrefs.settings.map { it.hiddenFromSmartLists }.distinctUntilChanged(),
-            settingsPrefs.savedFilters,
+        ) { lists, openTasks, completedTasks, hidden ->
-        ) { lists, openTasks, completedTasks, hidden, filters ->
+            buildContent(lists, openTasks, completedTasks, hidden) as ListsUiState
-            buildContent(lists, openTasks, completedTasks, hidden, filters) as ListsUiState
         }.recoveringFromProviderFailure { ListsUiState.Failure }
             .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), ListsUiState.Loading)
 
@@ -144,7 +135,6 @@ class ListsViewModel @Inject constructor(
         openTasks: List<Task>,
         completedTasks: List<Task>,
         hidden: Set<Long>,
-        savedFilters: List<SavedFilter>,
     ): ListsUiState.Content {
         val (todayStart, todayEnd) = DayWindow.today(Clock.System.now(), ZoneId.systemDefault())
         // Count only top-level tasks: a subtask is represented by its parent (and
@@ -187,29 +177,13 @@ class ListsViewModel @Inject constructor(
                 )
             }
             .sortedBy { it.accountName.lowercase() }
-        // Counts the open rows the tag's own screen shows: a subtask folds under a
-        // parent carrying the same tag, and stands on its own otherwise.
-        val allTasks = openTasks + completedTasks
-        val tags = tagsInUse(openTasks).map { tag ->
-            val tagged = allTasks.filter { tag in it.tags }
-            val ids = tagged.mapTo(HashSet()) { it.taskId }
-            TagOverview(tag, tagged.count { !it.isClosed && (!it.isSubtask || it.parentId !in ids) })
-        }
-        // Same folding as the tags: a subtask counts only when its parent isn't in the filter too.
-        val filters = savedFilters.map { filter ->
-            val matching = openTasks.filter { filter.matches(it, todayStart, todayEnd) }
-            val ids = matching.mapTo(HashSet()) { it.taskId }
-            FilterOverview(filter, matching.count { !it.isSubtask || it.parentId !in ids })
-        }
         return ListsUiState.Content(
             smartCounts = smartCounts,
-            filters = filters,
             groups = groups,
             todayDone = completedDueToday,
             todayTotal = todayTotal,
             upcoming = upcoming,
-            allTasks = allTasks,
+            allTasks = openTasks + completedTasks,
-            tags = tags,
         )
     }
 

app/src/main/java/de/jeanlucmakiola/agendula/ui/navigation/AgendulaNavHost.kt

@@ -3,14 +3,12 @@ package de.jeanlucmakiola.agendula.ui.navigation
 import androidx.compose.animation.EnterTransition
 import androidx.compose.animation.ExitTransition
 import androidx.compose.animation.fadeIn
-import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.scaleOut
 import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.IntOffset
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import de.jeanlucmakiola.agendula.domain.Task
 import kotlin.time.Instant
@@ -22,14 +20,11 @@ import de.jeanlucmakiola.agendula.ui.detail.TaskDetailScreen
 import de.jeanlucmakiola.agendula.ui.detail.TaskDetailViewModel
 import de.jeanlucmakiola.agendula.ui.edit.TaskEditScreen
 import de.jeanlucmakiola.agendula.ui.edit.TaskEditViewModel
-import de.jeanlucmakiola.agendula.ui.filters.FilterEditScreen
-import de.jeanlucmakiola.agendula.ui.filters.FilterEditViewModel
 import de.jeanlucmakiola.agendula.ui.imports.ImportScreen
 import de.jeanlucmakiola.agendula.ui.lists.ListsScreen
 import de.jeanlucmakiola.agendula.ui.settings.SettingsScreen
 import de.jeanlucmakiola.agendula.ui.tasklist.TaskListScreen
 import de.jeanlucmakiola.agendula.ui.tasklist.TaskListViewModel
-import de.jeanlucmakiola.floret.identity.predictiveBackExit
 
 /**
  * The single in-app back stack: lists → task list → detail / edit.
@@ -40,7 +35,6 @@ import de.jeanlucmakiola.floret.identity.predictiveBackExit
  * `SavedStateHandle`). Screens receive plain navigation lambdas so they stay
  * unaware of the nav library.
  */
-@OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun AgendulaNavHost(
     modifier: Modifier = Modifier,
@@ -66,27 +60,24 @@ fun AgendulaNavHost(
             is NavRequest.OpenList -> nav.navigate(Dest.TaskList.build(TaskFilter.OfList(navRequest.listId))) {
                 launchSingleTop = true
             }
-            is NavRequest.OpenFilter -> nav.navigate(Dest.TaskList.build(TaskFilter.Saved(navRequest.filterId))) {
-                launchSingleTop = true
-            }
             is NavRequest.Import -> nav.navigate(Dest.Import.build(navRequest.uri))
         }
         onNavRequestConsumed()
     }
 
-    val slideSpec = MaterialTheme.motionScheme.defaultSpatialSpec<IntOffset>()
-    val overlayExit = predictiveBackExit()
-
     NavHost(
         navController = nav,
         startDestination = Dest.LISTS,
         modifier = modifier,
-        // Calendula's overlay motion. NavHost's own back handler seeks the exit
+        // Only the screen on top moves; the background is always held static.
-        // over the previous screen, so destinations don't add a preview of their own.
+        // Forward is a plain fade-in over the held screen — calm, not a slide.
-        enterTransition = { slideInHorizontally(slideSpec) { it } + fadeIn() },
+        // Back is the predictive-back peek: navigation-compose composes the
+        // screen being revealed underneath and seeks popExit with the gesture, so
+        // the leaving screen scales down to reveal the (unmoved) previous screen.
+        enterTransition = { fadeIn() },
         exitTransition = { ExitTransition.None },
         popEnterTransition = { EnterTransition.None },
-        popExitTransition = { overlayExit },
+        popExitTransition = { scaleOut(targetScale = 0.9f) + fadeOut() },
     ) {
         composable(Dest.LISTS) {
             ReadableWidth {
@@ -94,7 +85,6 @@ fun AgendulaNavHost(
                     onOpenFilter = { filter -> nav.navigate(Dest.TaskList.build(filter)) },
                     onOpenTask = { task -> nav.navigate(task.detailRoute()) },
                     onNewTask = { nav.navigate(Dest.TaskEdit.buildNew()) },
-                    onNewFilter = { nav.navigate(Dest.FilterEdit.build()) },
                     onOpenSettings = { nav.navigate(Dest.SETTINGS) },
                 )
             }
@@ -124,8 +114,6 @@ fun AgendulaNavHost(
             val filter = Dest.TaskList.filterOf(
                 smart = args?.getString(Dest.TaskList.ARG_SMART),
                 listId = args?.getLong(Dest.TaskList.ARG_LIST_ID) ?: Dest.NO_ID,
-                tag = args?.getString(Dest.TaskList.ARG_TAG),
-                filterId = args?.getLong(Dest.TaskList.ARG_FILTER_ID) ?: Dest.NO_ID,
             )
             val vm: TaskListViewModel = hiltViewModel()
             LaunchedEffect(filter) { vm.bind(filter) }
@@ -136,15 +124,9 @@ fun AgendulaNavHost(
                     viewModel = vm,
                     onOpenTask = onOpenTask,
                     onNewTask = {
-                        nav.navigate(
+                        val presetListId = (filter as? TaskFilter.OfList)?.listId
-                            Dest.TaskEdit.buildNew(
+                        nav.navigate(Dest.TaskEdit.buildNew(presetListId = presetListId))
-                                presetListId = (filter as? TaskFilter.OfList)?.listId,
-                                tag = (filter as? TaskFilter.Tagged)?.tag,
-                                filterId = (filter as? TaskFilter.Saved)?.id,
-                            ),
-                        )
                     },
-                    onEditFilter = { id -> nav.navigate(Dest.FilterEdit.build(id)) },
                     onBack = { nav.popBackStack() },
                 )
             }
@@ -157,32 +139,6 @@ fun AgendulaNavHost(
             }
         }
 
-        composable(Dest.FilterEdit.route, arguments = Dest.FilterEdit.arguments) { entry ->
-            val filterId = entry.arguments?.getLong(Dest.FilterEdit.ARG_FILTER_ID)?.takeIf { it != Dest.NO_ID }
-            val vm: FilterEditViewModel = hiltViewModel()
-            LaunchedEffect(filterId) { vm.bind(filterId) }
-
-            ReadableWidth {
-                FilterEditScreen(
-                    viewModel = vm,
-                    isNew = filterId == null,
-                    onSaved = { id ->
-                        // A different id means the edited filter was gone and a new one was made.
-                        if (id != filterId) {
-                            // A new filter opens straight away, with the editor off the stack.
-                            nav.navigate(Dest.TaskList.build(TaskFilter.Saved(id))) {
-                                popUpTo(Dest.FilterEdit.route) { inclusive = true }
-                            }
-                        } else {
-                            nav.popBackStack()
-                        }
-                    },
-                    onDeleted = { nav.popBackStack(Dest.LISTS, inclusive = false) },
-                    onBack = { nav.popBackStack() },
-                )
-            }
-        }
-
         composable(Dest.TaskDetail.route, arguments = Dest.TaskDetail.arguments) { entry ->
             val taskId = entry.arguments?.getLong(Dest.TaskDetail.ARG_TASK_ID) ?: Dest.NO_ID
             val occurrence = entry.arguments?.getLong(Dest.TaskDetail.ARG_OCC)?.takeIf { it != Dest.NO_ID }
@@ -210,8 +166,6 @@ fun AgendulaNavHost(
             val parentId = args?.getLong(Dest.TaskEdit.ARG_PARENT_ID) ?: Dest.NO_ID
             val occurrence = args?.getLong(Dest.TaskEdit.ARG_OCCURRENCE)?.takeIf { it != Dest.NO_ID }
             val title = args?.getString(Dest.TaskEdit.ARG_TITLE)
-            val tag = args?.getString(Dest.TaskEdit.ARG_TAG)
-            val filterId = args?.getLong(Dest.TaskEdit.ARG_FILTER_ID)?.takeIf { it != Dest.NO_ID }
             val vm: TaskEditViewModel = hiltViewModel()
             LaunchedEffect(taskId, presetListId, parentId) {
                 if (taskId != Dest.NO_ID) {
@@ -221,8 +175,6 @@ fun AgendulaNavHost(
                         presetListId = presetListId.takeIf { it != Dest.NO_ID },
                         parentId = parentId.takeIf { it != Dest.NO_ID },
                         initialTitle = title,
-                        presetTag = tag,
-                        presetFilterId = filterId,
                     )
                 }
             }

app/src/main/java/de/jeanlucmakiola/agendula/ui/navigation/Destinations.kt

@@ -53,51 +53,30 @@ object Dest {
     }
 
     /**
-     * One [TaskFilter]'s tasks. Carries one of `listId` (a real list), `smart`
+     * One [TaskFilter]'s tasks. Carries *either* `listId` (a real list) *or*
-     * (a [SmartList] name), `tag` or `filterId` (a saved filter); whichever is
+     * `smart` (a [SmartList] name); whichever is set decides the filter.
-     * set decides the filter.
      */
     object TaskList {
         const val ARG_LIST_ID = "listId"
         const val ARG_SMART = "smart"
-        const val ARG_TAG = "tag"
+        const val route = "taskList?$ARG_LIST_ID={$ARG_LIST_ID}&$ARG_SMART={$ARG_SMART}"
-        const val ARG_FILTER_ID = "filterId"
-        const val route = "taskList?$ARG_LIST_ID={$ARG_LIST_ID}&$ARG_SMART={$ARG_SMART}&$ARG_TAG={$ARG_TAG}" +
-            "&$ARG_FILTER_ID={$ARG_FILTER_ID}"
 
         val arguments = listOf(
             navArgument(ARG_LIST_ID) { type = NavType.LongType; defaultValue = NO_ID },
             navArgument(ARG_SMART) { type = NavType.StringType; nullable = true; defaultValue = null },
-            navArgument(ARG_TAG) { type = NavType.StringType; nullable = true; defaultValue = null },
-            navArgument(ARG_FILTER_ID) { type = NavType.LongType; defaultValue = NO_ID },
         )
 
         fun build(filter: TaskFilter): String = when (filter) {
             is TaskFilter.OfList -> "taskList?$ARG_LIST_ID=${filter.listId}"
             is TaskFilter.Smart -> "taskList?$ARG_SMART=${filter.list.name}"
-            is TaskFilter.Tagged -> "taskList?$ARG_TAG=${android.net.Uri.encode(filter.tag)}"
-            is TaskFilter.Saved -> "taskList?$ARG_FILTER_ID=${filter.id}"
             // Several lists at once only exists for the widget, which never routes here.
             is TaskFilter.OfLists -> error("OfLists has no task-list screen")
         }
 
         /** Reconstruct the filter from a destination's arguments. */
-        fun filterOf(smart: String?, listId: Long, tag: String? = null, filterId: Long = NO_ID): TaskFilter = when {
+        fun filterOf(smart: String?, listId: Long): TaskFilter =
-            smart != null -> TaskFilter.Smart(SmartList.valueOf(smart))
+            if (smart != null) TaskFilter.Smart(SmartList.valueOf(smart))
-            tag != null -> TaskFilter.Tagged(tag)
+            else TaskFilter.OfList(listId)
-            filterId != NO_ID -> TaskFilter.Saved(filterId)
-            else -> TaskFilter.OfList(listId)
-        }
-    }
-
-    /** Creates a saved filter, or edits the one `filterId` names. */
-    object FilterEdit {
-        const val ARG_FILTER_ID = "filterId"
-        const val route = "filterEdit?$ARG_FILTER_ID={$ARG_FILTER_ID}"
-        val arguments = listOf(navArgument(ARG_FILTER_ID) { type = NavType.LongType; defaultValue = NO_ID })
-
-        fun build(filterId: Long? = null): String =
-            if (filterId == null) "filterEdit" else "filterEdit?$ARG_FILTER_ID=$filterId"
     }
 
     /** A single task's detail; `occ` (epoch millis) picks one occurrence of a series. */
@@ -118,8 +97,7 @@ object Dest {
 
     /**
      * The create / edit form. `taskId` set ([NO_ID] otherwise) ⇒ edit; for a new
-     * task, `presetListId` / `parentId` optionally seed the form, and `filterId`
+     * task, `presetListId` / `parentId` optionally seed the form.
-     * fills it so the task lands in that saved filter.
      */
     object TaskEdit {
         const val ARG_TASK_ID = "taskId"
@@ -127,16 +105,12 @@ object Dest {
         const val ARG_PARENT_ID = "parentId"
         const val ARG_OCCURRENCE = "occ"
         const val ARG_TITLE = "title"
-        const val ARG_TAG = "tag"
-        const val ARG_FILTER_ID = "filterId"
         const val route =
             "taskEdit?$ARG_TASK_ID={$ARG_TASK_ID}" +
                 "&$ARG_PRESET_LIST_ID={$ARG_PRESET_LIST_ID}" +
                 "&$ARG_PARENT_ID={$ARG_PARENT_ID}" +
                 "&$ARG_OCCURRENCE={$ARG_OCCURRENCE}" +
-                "&$ARG_TITLE={$ARG_TITLE}" +
+                "&$ARG_TITLE={$ARG_TITLE}"
-                "&$ARG_TAG={$ARG_TAG}" +
-                "&$ARG_FILTER_ID={$ARG_FILTER_ID}"
 
         val arguments = listOf(
             navArgument(ARG_TASK_ID) { type = NavType.LongType; defaultValue = NO_ID },
@@ -144,27 +118,17 @@ object Dest {
             navArgument(ARG_PARENT_ID) { type = NavType.LongType; defaultValue = NO_ID },
             navArgument(ARG_OCCURRENCE) { type = NavType.LongType; defaultValue = NO_ID },
             navArgument(ARG_TITLE) { type = NavType.StringType; nullable = true; defaultValue = null },
-            navArgument(ARG_TAG) { type = NavType.StringType; nullable = true; defaultValue = null },
-            navArgument(ARG_FILTER_ID) { type = NavType.LongType; defaultValue = NO_ID },
         )
 
         fun buildEdit(taskId: Long, occurrenceStart: Long? = null): String =
             if (occurrenceStart == null) "taskEdit?$ARG_TASK_ID=$taskId"
             else "taskEdit?$ARG_TASK_ID=$taskId&$ARG_OCCURRENCE=$occurrenceStart"
 
-        fun buildNew(
+        fun buildNew(presetListId: Long? = null, parentId: Long? = null, title: String? = null): String {
-            presetListId: Long? = null,
-            parentId: Long? = null,
-            title: String? = null,
-            tag: String? = null,
-            filterId: Long? = null,
-        ): String {
             val params = buildList {
                 if (presetListId != null) add("$ARG_PRESET_LIST_ID=$presetListId")
                 if (parentId != null) add("$ARG_PARENT_ID=$parentId")
                 if (!title.isNullOrBlank()) add("$ARG_TITLE=${android.net.Uri.encode(title)}")
-                if (!tag.isNullOrBlank()) add("$ARG_TAG=${android.net.Uri.encode(tag)}")
-                if (filterId != null) add("$ARG_FILTER_ID=$filterId")
             }
             return if (params.isEmpty()) "taskEdit" else "taskEdit?${params.joinToString("&")}"
         }

app/src/main/java/de/jeanlucmakiola/agendula/ui/navigation/NavRequest.kt

@@ -30,9 +30,6 @@ sealed interface NavRequest {
     /** One real list — a widget header. */
     data class OpenList(val listId: Long) : NavRequest
 
-    /** One saved filter — a widget header. */
-    data class OpenFilter(val filterId: Long) : NavRequest
-
     /** An `.ics` another app handed over. */
     data class Import(val uri: Uri) : NavRequest
 }

app/src/main/java/de/jeanlucmakiola/agendula/ui/settings/AppearanceScreen.kt

@@ -34,7 +34,6 @@ internal fun AppearanceScreen(
     state: SettingsUiState,
     viewModel: SettingsViewModel,
     onBack: () -> Unit,
-    visible: Boolean,
 ) {
     val dynamicColorAvailable = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
     var showTheme by remember { mutableStateOf(false) }
@@ -43,12 +42,7 @@ internal fun AppearanceScreen(
     val systemIs24Hour = DateFormat.is24HourFormat(LocalContext.current)
     val locale = currentLocale()
 
-    CollapsingScaffold(
+    CollapsingScaffold(title = stringResource(R.string.settings_section_appearance), onBack = onBack) {
-        title = stringResource(R.string.settings_section_appearance),
-        onBack = onBack,
-        predictiveBack = true,
-        visible = visible,
-    ) {
         GroupedRow(
             title = stringResource(R.string.settings_theme),
             summary = stringResource(themeLabel(state.settings.themeMode)),

app/src/main/java/de/jeanlucmakiola/agendula/ui/settings/BackupScreen.kt

@@ -1,37 +0,0 @@
-package de.jeanlucmakiola.agendula.ui.settings
-
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.res.stringResource
-import de.jeanlucmakiola.agendula.R
-import de.jeanlucmakiola.floret.components.CollapsingScaffold
-import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.Position
-
-/** Backup & restore: the way into export and import, as its own entry (after Calendula). */
-@Composable
-internal fun BackupScreen(
-    onOpenExport: () -> Unit,
-    onOpenImport: () -> Unit,
-    onBack: () -> Unit,
-    visible: Boolean,
-) {
-    CollapsingScaffold(
-        title = stringResource(R.string.settings_section_backup),
-        onBack = onBack,
-        predictiveBack = true,
-        visible = visible,
-    ) {
-        GroupedRow(
-            title = stringResource(R.string.settings_export),
-            summary = stringResource(R.string.settings_export_hint),
-            position = Position.Top,
-            onClick = onOpenExport,
-        )
-        GroupedRow(
-            title = stringResource(R.string.import_title),
-            summary = stringResource(R.string.settings_import_hint),
-            position = Position.Bottom,
-            onClick = onOpenImport,
-        )
-    }
-}

app/src/main/java/de/jeanlucmakiola/agendula/ui/settings/RemindersScreen.kt

@@ -41,8 +41,6 @@ import androidx.core.net.toUri
 import de.jeanlucmakiola.agendula.R
 import de.jeanlucmakiola.agendula.data.prefs.SNOOZE_PRESETS
 import de.jeanlucmakiola.agendula.data.reminders.TaskNotifier
-import de.jeanlucmakiola.agendula.domain.TaskReminderOrder
-import de.jeanlucmakiola.agendula.domain.asTaskReminder
 import de.jeanlucmakiola.agendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.agendula.ui.common.OnResume
 import de.jeanlucmakiola.agendula.ui.common.canScheduleExactAlarms
@@ -50,7 +48,7 @@ import de.jeanlucmakiola.agendula.ui.common.openExactAlarmSettings
 import de.jeanlucmakiola.agendula.ui.common.ReminderDefaultPicker
 import de.jeanlucmakiola.agendula.ui.common.TimePickerAlert
 import de.jeanlucmakiola.agendula.ui.common.formatMinuteOfDay
-import de.jeanlucmakiola.agendula.ui.common.reminderLabel
+import de.jeanlucmakiola.agendula.ui.common.reminderLeadTimeLabel
 import de.jeanlucmakiola.floret.components.CollapsingScaffold
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.OptionPicker
@@ -59,18 +57,16 @@ import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.pastelize
 import de.jeanlucmakiola.floret.identity.collapseExit
 import de.jeanlucmakiola.floret.identity.expandEnter
-import de.jeanlucmakiola.floret.reminders.ReminderLead
 import de.jeanlucmakiola.floret.reminders.ReminderOverride
 import de.jeanlucmakiola.floret.reminders.reminderOverrideFor
 import java.time.LocalTime
 
 /** Whether due tasks notify at all, how far ahead, and which lists differ. */
 @Composable
-internal fun NotificationsScreen(
+internal fun RemindersScreen(
     state: SettingsUiState,
     viewModel: SettingsViewModel,
     onBack: () -> Unit,
-    visible: Boolean,
 ) {
     val context = LocalContext.current
     var notificationsAllowed by remember { mutableStateOf(context.notificationsAllowed()) }
@@ -123,12 +119,7 @@ internal fun NotificationsScreen(
     )
     val lists = state.lists.filter { it.id > 0L }
 
-    CollapsingScaffold(
+    CollapsingScaffold(title = stringResource(R.string.settings_section_reminders), onBack = onBack) {
-        title = stringResource(R.string.settings_section_reminders),
-        onBack = onBack,
-        predictiveBack = true,
-        visible = visible,
-    ) {
         if (state.settings.remindersEnabled && !notificationsAllowed) {
             GroupedRow(
                 title = stringResource(R.string.settings_notifications_blocked),
@@ -162,13 +153,13 @@ internal fun NotificationsScreen(
         }
         GroupedRow(
             title = stringResource(R.string.settings_default_reminder),
-            summary = reminderChoiceLabel(state.settings.defaultReminders),
+            summary = reminderChoiceLabel(state.settings.defaultReminderMinutes),
             position = Position.Middle,
             onClick = { showOffset = true },
         )
         GroupedRow(
             title = stringResource(R.string.settings_default_reminder_allday),
-            summary = reminderChoiceLabel(state.settings.defaultAllDayReminders, allDay = true),
+            summary = reminderChoiceLabel(state.settings.defaultAllDayReminderMinutes, allDay = true),
             position = Position.Middle,
             onClick = { showAllDay = true },
         )
@@ -254,7 +245,7 @@ internal fun NotificationsScreen(
                                     title = stringResource(R.string.settings_default_reminder),
                                     summary = listOverrideSummary(
                                         state.settings.perListReminderOverride.reminderOverrideFor(list.id),
-                                        state.settings.defaultReminders,
+                                        state.settings.defaultReminderMinutes,
                                         allDay = false,
                                     ),
                                     position = Position.Middle,
@@ -264,7 +255,7 @@ internal fun NotificationsScreen(
                                     title = stringResource(R.string.settings_default_reminder_allday),
                                     summary = listOverrideSummary(
                                         state.settings.perListAllDayReminderOverride.reminderOverrideFor(list.id),
-                                        state.settings.defaultAllDayReminders,
+                                        state.settings.defaultAllDayReminderMinutes,
                                         allDay = true,
                                     ),
                                     position = Position.Middle,
@@ -287,24 +278,24 @@ internal fun NotificationsScreen(
     if (showOffset) {
         ReminderDefaultPicker(
             title = stringResource(R.string.settings_default_reminder),
-            selected = state.settings.defaultReminders.let {
+            selected = state.settings.defaultReminderMinutes.let {
-                if (it.isEmpty()) ReminderOverride.None else ReminderOverride.Minutes.of(it)
+                if (it.isEmpty()) ReminderOverride.None else ReminderOverride.Minutes(it)
             },
             allowInherit = false,
-            onSelect = { viewModel.setDefaultReminders((it as? ReminderOverride.Minutes)?.leads.orEmpty()) },
+            onSelect = { viewModel.setDefaultReminderMinutes((it as? ReminderOverride.Minutes)?.minutes.orEmpty()) },
             onDismiss = { showOffset = false },
         )
     }
     if (showAllDay) {
         ReminderDefaultPicker(
             title = stringResource(R.string.settings_default_reminder_allday),
-            selected = state.settings.defaultAllDayReminders.let {
+            selected = state.settings.defaultAllDayReminderMinutes.let {
-                if (it.isEmpty()) ReminderOverride.None else ReminderOverride.Minutes.of(it)
+                if (it.isEmpty()) ReminderOverride.None else ReminderOverride.Minutes(it)
             },
             allowInherit = false,
             allDay = true,
             leadTimeSummary = allDayFiresAt,
-            onSelect = { viewModel.setDefaultAllDayReminders((it as? ReminderOverride.Minutes)?.leads.orEmpty()) },
+            onSelect = { viewModel.setDefaultAllDayReminderMinutes((it as? ReminderOverride.Minutes)?.minutes.orEmpty()) },
             onDismiss = { showAllDay = false },
         )
     }
@@ -359,27 +350,19 @@ private data class OverrideTarget(val listId: Long, val allDay: Boolean)
 
 /** Row summary for a list: its override, or the inherited global default. */
 @Composable
-private fun listOverrideSummary(choice: ReminderOverride, globalDefault: List<ReminderLead>, allDay: Boolean): String =
+private fun listOverrideSummary(choice: ReminderOverride, globalDefault: List<Int>, allDay: Boolean): String =
     when (choice) {
         ReminderOverride.Inherit ->
             stringResource(R.string.settings_list_reminder_inherits, reminderChoiceLabel(globalDefault, allDay))
         ReminderOverride.None -> stringResource(R.string.reminder_none)
-        is ReminderOverride.Minutes -> reminderChoiceLabel(choice.leads, allDay)
+        is ReminderOverride.Minutes -> reminderChoiceLabel(choice.minutes, allDay)
     }
 
-/**
+/** "30 minutes before, At due time", or "No reminder" for an empty set. */
- * "30 minutes before, At due time", or "No reminder" for an empty set. Each
- * names its date once any counts from the start.
- */
 @Composable
-private fun reminderChoiceLabel(leads: List<ReminderLead>, allDay: Boolean = false): String {
+private fun reminderChoiceLabel(minutes: List<Int>, allDay: Boolean = false): String =
-    if (leads.isEmpty()) return stringResource(R.string.reminder_none)
+    if (minutes.isEmpty()) stringResource(R.string.reminder_none)
-    val reminders = leads.map { it.asTaskReminder() }.sortedWith(TaskReminderOrder)
+    else minutes.map { reminderLeadTimeLabel(it, allDay) }.joinToString(", ")
-    val anchored = reminders.any { it.fromStart }
-    return reminders.map { reminder ->
-        reminderLabel(reminder.minutesBefore, allDay, reminder.fromStart, anchored)
-    }.joinToString(", ")
-}
 
 /** SCHEDULE_EXACT_ALARM is user-granted from API 31; below that exact alarms need no grant. */
 private fun showExactAlarmRow(): Boolean = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S

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

@@ -1,8 +1,11 @@
 package de.jeanlucmakiola.agendula.ui.settings
 
+import androidx.activity.compose.BackHandler
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
 import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Spacer
@@ -10,7 +13,6 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Backup
 import androidx.compose.material.icons.filled.BugReport
 import androidx.compose.material.icons.filled.Code
 import androidx.compose.material.icons.filled.Favorite
@@ -23,7 +25,6 @@ import androidx.compose.material.icons.filled.Translate
 import androidx.compose.material.icons.filled.Tune
 import androidx.compose.material.icons.rounded.CloudSync
 import androidx.compose.material.icons.rounded.Storage
-import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
@@ -36,7 +37,6 @@ import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.res.vectorResource
-import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -50,22 +50,20 @@ import de.jeanlucmakiola.floret.components.CollapsingScaffold
 import de.jeanlucmakiola.floret.components.GroupedListInset
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.GroupedSectionHeader
-import de.jeanlucmakiola.floret.components.LanguagePickerRow
 import de.jeanlucmakiola.floret.components.OptionPicker
 import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.floret.crash.CrashReportDialog
 import de.jeanlucmakiola.floret.crash.CrashReporter
 import de.jeanlucmakiola.floret.crash.openIssueTracker
 import de.jeanlucmakiola.floret.crash.submitCrashReport
-import de.jeanlucmakiola.floret.identity.predictiveBackExit
+import de.jeanlucmakiola.floret.locale.AppLanguage
 
 /** The settings sub-screens reached from the hub's category rows. */
 internal enum class SettingsSection {
     Appearance,
     TaskForm,
-    Notifications,
+    Reminders,
     Storage,
-    Backup,
     Export,
     Import,
     Accounts,
@@ -74,10 +72,10 @@ internal enum class SettingsSection {
     Licences,
     ;
 
-    /** The section that stays composed underneath: Backup under export and import, Accounts under its screens. */
+    /** Where back goes: Export is opened from Storage, the account screens from Accounts. */
     val parent: SettingsSection?
         get() = when (this) {
-            Export, Import -> Backup
+            Export, Import -> Storage
             AddAccount, Account -> Accounts
             else -> null
         }
@@ -90,9 +88,8 @@ internal enum class SettingsSection {
  * A full-screen destination; [onBack] pops it. [initialSection] names a
  * sub-screen to open on (see [de.jeanlucmakiola.agendula.ui.navigation.Dest.Settings]).
  *
- * Every sub-screen is its own file and handles its own back through the
+ * Every sub-screen is its own file. This one owns the hub, the section enum and
- * predictive-back preview. This one owns the hub, the section enum and the
+ * the back rules between them, and nothing else.
- * routing between them, and nothing else.
  */
 @Composable
 fun SettingsScreen(
@@ -109,8 +106,10 @@ fun SettingsScreen(
             else SettingsSection.entries.firstOrNull { it.name == initialSection },
         )
     }
-    // Import's "open storage" comes back to Import rather than the hub.
+
-    var storageReturn by rememberSaveable { mutableStateOf<SettingsSection?>(null) }
+    // Inside a sub-screen, system back (button or gesture) returns to the hub
+    // rather than popping the whole Settings destination to the lists overview.
+    BackHandler(enabled = section != null) { section = section?.parent }
 
     Box(
         modifier = modifier
@@ -119,58 +118,34 @@ fun SettingsScreen(
     ) {
         SettingsHub(onBack = onBack, onOpenSection = { section = it })
 
-        val appearance = section == SettingsSection.Appearance
+        SlideInSection(visible = section == SettingsSection.Appearance) {
-        SlideInSection(visible = appearance) {
+            AppearanceScreen(state = state, viewModel = viewModel, onBack = { section = null })
-            AppearanceScreen(state = state, viewModel = viewModel, onBack = { section = null }, visible = appearance)
         }
-        val taskForm = section == SettingsSection.TaskForm
+        SlideInSection(visible = section == SettingsSection.TaskForm) {
-        SlideInSection(visible = taskForm) {
+            TaskFormScreen(state = state, viewModel = viewModel, onBack = { section = null })
-            TaskFormScreen(state = state, viewModel = viewModel, onBack = { section = null }, visible = taskForm)
         }
-        val notifications = section == SettingsSection.Notifications
+        SlideInSection(visible = section == SettingsSection.Reminders) {
-        SlideInSection(visible = notifications) {
+            RemindersScreen(state = state, viewModel = viewModel, onBack = { section = null })
-            NotificationsScreen(state = state, viewModel = viewModel, onBack = { section = null }, visible = notifications)
         }
-        val storage = section == SettingsSection.Storage
+        // Storage stays composed under Export, so the deeper screen slides over it.
-        SlideInSection(visible = storage) {
+        val storageOpen = section == SettingsSection.Storage ||
+            section?.parent == SettingsSection.Storage
+        SlideInSection(visible = storageOpen) {
             StorageScreen(
                 viewModel = viewModel,
-                onBack = {
-                    section = storageReturn
-                    storageReturn = null
-                },
-                visible = storage,
-            )
-        }
-        // Backup stays composed under export and import, so the deeper screen slides over it.
-        val backup = section == SettingsSection.Backup || section?.parent == SettingsSection.Backup
-        SlideInSection(visible = backup) {
-            BackupScreen(
                 onOpenExport = { section = SettingsSection.Export },
                 onOpenImport = { section = SettingsSection.Import },
                 onBack = { section = null },
-                visible = backup,
             )
         }
-        val exportOpen = section == SettingsSection.Export
+        SlideInSection(visible = section == SettingsSection.Export) {
-        SlideInSection(visible = exportOpen) {
+            ExportScreen(onBack = { section = SettingsSection.Storage })
-            ExportScreen(onBack = { section = SettingsSection.Backup }, visible = exportOpen)
         }
-        val importOpen = section == SettingsSection.Import
+        SlideInSection(visible = section == SettingsSection.Import) {
-        SlideInSection(visible = importOpen) {
+            ImportScreen(onBack = { section = SettingsSection.Storage })
-            ImportScreen(
-                onBack = { section = SettingsSection.Backup },
-                onOpenStorage = {
-                    storageReturn = SettingsSection.Import
-                    section = SettingsSection.Storage
-                },
-                predictiveBack = true,
-                visible = importOpen,
-            )
         }
-        val licences = section == SettingsSection.Licences
+        SlideInSection(visible = section == SettingsSection.Licences) {
-        SlideInSection(visible = licences) {
+            LicencesScreen(onBack = { section = null })
-            LicencesScreen(onBack = { section = null }, visible = licences)
         }
         AccountSections(
             section = section,
@@ -180,18 +155,12 @@ fun SettingsScreen(
     }
 }
 
-/**
- * A sub-screen layered over the hub, with Calendula's overlay motion: it slides
- * in on the motion scheme's spring and leaves from its predictive-back preview.
- */
-@OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 internal fun SlideInSection(visible: Boolean, content: @Composable () -> Unit) {
-    val slideSpec = MaterialTheme.motionScheme.defaultSpatialSpec<IntOffset>()
     AnimatedVisibility(
         visible = visible,
-        enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+        enter = slideInHorizontally { it } + fadeIn(),
-        exit = predictiveBackExit(),
+        exit = slideOutHorizontally { it } + fadeOut(),
     ) { content() }
 }
 
@@ -239,7 +208,7 @@ private fun SettingsHub(
             summary = stringResource(R.string.settings_reminders_subtitle),
             position = Position.Bottom,
             leading = { CategoryIcon(Icons.Default.Notifications, ChipAccent.Primary) },
-            onClick = { onOpenSection(SettingsSection.Notifications) },
+            onClick = { onOpenSection(SettingsSection.Reminders) },
         )
 
         Spacer(Modifier.height(8.dp))
@@ -256,41 +225,14 @@ private fun SettingsHub(
         GroupedRow(
             title = stringResource(R.string.settings_section_storage),
             summary = stringResource(R.string.settings_storage_subtitle),
-            position = if (BuildConfig.SYNC_ENABLED) Position.Middle else Position.Top,
+            position = if (BuildConfig.SYNC_ENABLED) Position.Bottom else Position.Alone,
-            leading = { CategoryIcon(Icons.Rounded.Storage, ChipAccent.Primary) },
+            leading = { CategoryIcon(Icons.Rounded.Storage, ChipAccent.Secondary) },
             onClick = { onOpenSection(SettingsSection.Storage) },
         )
-        GroupedRow(
-            title = stringResource(R.string.settings_section_backup),
-            summary = stringResource(R.string.settings_backup_subtitle),
-            position = Position.Bottom,
-            leading = { CategoryIcon(Icons.Default.Backup, ChipAccent.Secondary) },
-            onClick = { onOpenSection(SettingsSection.Backup) },
-        )
 
         Spacer(Modifier.height(8.dp))
         GroupedSectionHeader(stringResource(R.string.settings_group_app))
-        LanguagePickerRow(
+        LanguageRow(position = Position.Top)
-            position = Position.Top,
-            title = stringResource(R.string.settings_language),
-            autoLabel = stringResource(R.string.settings_language_auto),
-            localesConfig = R.xml.locales_config,
-            predictiveBack = true,
-            // Invite contributions right where users pick their language.
-            header = {
-                val context = LocalContext.current
-                val translateUrl = stringResource(R.string.about_translate_url)
-                GroupedRow(
-                    title = stringResource(R.string.settings_translate),
-                    summary = stringResource(R.string.settings_translate_hint),
-                    position = Position.Alone,
-                    leading = { CategoryIcon(Icons.Default.Translate, ChipAccent.Neutral) },
-                    onClick = { openUrl(context, translateUrl) },
-                )
-                Spacer(Modifier.height(16.dp))
-            },
-            leading = { CategoryIcon(Icons.Default.Language, ChipAccent.Secondary) },
-        )
         ReportProblemRow(position = Position.Bottom)
 
         // Source, licence and privacy sit at the bottom as reference material
@@ -374,6 +316,64 @@ private fun AboutLinkRow(label: String, url: String, icon: ImageVector, position
     )
 }
 
+/**
+ * The app-language row. Deliberately not floret-kit's `LanguagePickerRow`: the
+ * picker it opens carries a "Help translate" header, and inviting contributions
+ * right where a user goes looking for their language is app-specific framing,
+ * not a family primitive. Everything else matches that recipe.
+ */
+@Composable
+private fun LanguageRow(position: Position) {
+    val context = LocalContext.current
+    val supported = remember { AppLanguage.supportedTags(context, R.xml.locales_config) }
+    // Setting a locale recreates the activity; mirror the choice locally so the
+    // row updates instantly even before the recreation lands.
+    var current by remember { mutableStateOf(AppLanguage.currentTag(supported)) }
+    var showDialog by remember { mutableStateOf(false) }
+
+    // null = follow the system; the rest are BCP-47 tags from locales_config.xml.
+    val options = remember(supported) { listOf<String?>(null) + supported }
+
+    GroupedRow(
+        title = stringResource(R.string.settings_language),
+        summary = languageLabel(current),
+        position = position,
+        leading = { CategoryIcon(Icons.Default.Language, ChipAccent.Secondary) },
+        onClick = { showDialog = true },
+    )
+
+    if (showDialog) {
+        OptionPicker(
+            title = stringResource(R.string.settings_language),
+            predictiveBack = true,
+            options = options,
+            selected = current,
+            label = { languageLabel(it) },
+            onSelect = {
+                current = it
+                AppLanguage.apply(it)
+            },
+            onDismiss = { showDialog = false },
+            // Invite contributions right where users pick their language.
+            header = {
+                val translateUrl = stringResource(R.string.about_translate_url)
+                GroupedRow(
+                    title = stringResource(R.string.settings_translate),
+                    summary = stringResource(R.string.settings_translate_hint),
+                    position = Position.Alone,
+                    leading = { CategoryIcon(Icons.Default.Translate, ChipAccent.Neutral) },
+                    onClick = { openUrl(context, translateUrl) },
+                )
+                Spacer(Modifier.height(16.dp))
+            },
+        )
+    }
+}
+
+@Composable
+private fun languageLabel(tag: String?): String =
+    if (tag == null) stringResource(R.string.settings_language_auto) else AppLanguage.displayName(tag)
+
 /**
  * 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

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

@@ -22,7 +22,6 @@ import de.jeanlucmakiola.agendula.data.tasks.transfer.TransferCounts
 import de.jeanlucmakiola.agendula.data.tasks.transfer.TransferResult
 import de.jeanlucmakiola.agendula.domain.TaskFormField
 import de.jeanlucmakiola.agendula.domain.TaskList
-import de.jeanlucmakiola.floret.reminders.ReminderLead
 import de.jeanlucmakiola.floret.reminders.ReminderOverride
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -220,12 +219,12 @@ class SettingsViewModel @Inject constructor(
     fun setThemeMode(mode: ThemeMode) = viewModelScope.launch { prefs.setThemeMode(mode) }
     fun setDynamicColor(enabled: Boolean) = viewModelScope.launch { prefs.setDynamicColor(enabled) }
     fun setDefaultList(id: Long?) = viewModelScope.launch { prefs.setDefaultListId(id) }
-    fun setDefaultReminders(leads: List<ReminderLead>) = viewModelScope.launch {
+    fun setDefaultReminderMinutes(minutes: List<Int>) = viewModelScope.launch {
-        prefs.setDefaultReminders(leads)
+        prefs.setDefaultReminderMinutes(minutes)
         resyncReminders()
     }
-    fun setDefaultAllDayReminders(leads: List<ReminderLead>) = viewModelScope.launch {
+    fun setDefaultAllDayReminderMinutes(minutes: List<Int>) = viewModelScope.launch {
-        prefs.setDefaultAllDayReminders(leads)
+        prefs.setDefaultAllDayReminderMinutes(minutes)
         resyncReminders()
     }
     fun setAllDayReminderMinuteOfDay(minuteOfDay: Int) = viewModelScope.launch {

app/src/main/java/de/jeanlucmakiola/agendula/ui/settings/StorageScreen.kt

@@ -55,8 +55,9 @@ import de.jeanlucmakiola.floret.components.SelectedCheck
 @Composable
 internal fun StorageScreen(
     viewModel: SettingsViewModel,
+    onOpenExport: () -> Unit,
+    onOpenImport: () -> Unit,
     onBack: () -> Unit,
-    visible: Boolean,
 ) {
     val context = LocalContext.current
     val storage by viewModel.storage.collectAsStateWithLifecycle()
@@ -84,17 +85,11 @@ internal fun StorageScreen(
     // permission dialog too, and would wipe the refusal before it is read.
     OnResume { viewModel.refreshStorage() }
 
-    CollapsingScaffold(
+    CollapsingScaffold(title = stringResource(R.string.settings_section_storage), onBack = onBack) {
-        title = stringResource(R.string.settings_section_storage),
-        onBack = onBack,
-        predictiveBack = true,
-        visible = visible,
-    ) {
-        val canCopy = storage?.canCopyFromExternal == true
         GroupedRow(
             title = stringResource(R.string.settings_task_store),
             summary = storage?.let { storeLabel(it) },
-            position = if (canCopy) Position.Top else Position.Alone,
+            position = Position.Top,
             // Nothing to pick until the stored mode has landed; opening the picker
             // on the seeded state would offer the wrong store as the current one.
             onClick = storage?.let {
@@ -104,19 +99,31 @@ internal fun StorageScreen(
                 }
             },
         )
-        if (canCopy) {
+        if (storage?.canCopyFromExternal == true) {
             GroupedRow(
                 title = stringResource(
                     R.string.settings_copy_from_external,
                     storage?.let { externalTitle(it.external, it.externalLabel) }.orEmpty(),
                 ),
                 summary = stringResource(R.string.settings_copy_from_external_hint),
-                position = Position.Bottom,
+                position = Position.Middle,
                 leading = { Icon(Icons.Rounded.MoveDown, contentDescription = null) },
                 // Inert while a copy is in flight; the receipt below says so.
                 onClick = if (transfer.running) null else viewModel::startCopyFromExternal,
             )
         }
+        GroupedRow(
+            title = stringResource(R.string.settings_export),
+            summary = stringResource(R.string.settings_export_hint),
+            position = Position.Middle,
+            onClick = onOpenExport,
+        )
+        GroupedRow(
+            title = stringResource(R.string.import_title),
+            summary = stringResource(R.string.settings_import_hint),
+            position = Position.Bottom,
+            onClick = onOpenImport,
+        )
 
         TransferStatus(transfer)
 

app/src/main/java/de/jeanlucmakiola/agendula/ui/settings/TaskFormScreen.kt

@@ -42,16 +42,10 @@ internal fun TaskFormScreen(
     state: SettingsUiState,
     viewModel: SettingsViewModel,
     onBack: () -> Unit,
-    visible: Boolean,
 ) {
     var showDefaultList by remember { mutableStateOf(false) }
 
-    CollapsingScaffold(
+    CollapsingScaffold(title = stringResource(R.string.settings_section_task_form), onBack = onBack) {
-        title = stringResource(R.string.settings_section_task_form),
-        onBack = onBack,
-        predictiveBack = true,
-        visible = visible,
-    ) {
         SettingsHint(stringResource(R.string.settings_form_fields_hint))
         Spacer(Modifier.height(8.dp))
         val fields = TaskFormField.entries

app/src/main/java/de/jeanlucmakiola/agendula/ui/tasklist/TaskListScreen.kt

@@ -30,7 +30,6 @@ import androidx.compose.foundation.layout.windowInsetsPadding
 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.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
@@ -49,8 +48,6 @@ import androidx.compose.material.icons.rounded.Edit
 import androidx.compose.material.icons.rounded.ExpandMore
 import androidx.compose.material.icons.rounded.Flag
 import androidx.compose.material3.Checkbox
-import androidx.compose.material3.Badge
-import androidx.compose.material3.BadgedBox
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.ExtendedFloatingActionButton
 import androidx.compose.material3.Icon
@@ -60,19 +57,14 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.MediumTopAppBar
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Surface
+import androidx.compose.material.icons.automirrored.rounded.Sort
 import androidx.compose.material.icons.rounded.Repeat
-import androidx.compose.material.icons.rounded.Sell
-import androidx.compose.material.icons.rounded.Tune
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.SwipeToDismissBox
 import androidx.compose.ui.res.pluralStringResource
 import de.jeanlucmakiola.agendula.domain.TaskSortOrder
-import de.jeanlucmakiola.floret.components.revealOnFocus
 import de.jeanlucmakiola.floret.components.InlineTextField
-import de.jeanlucmakiola.floret.components.FullScreenPicker
+import de.jeanlucmakiola.floret.components.OptionPicker
-import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.GroupedSectionHeader
-import de.jeanlucmakiola.floret.components.SelectedCheck
 import androidx.compose.material3.SwipeToDismissBoxValue
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
@@ -140,7 +132,6 @@ fun TaskListScreen(
     onNewTask: () -> Unit,
     onBack: () -> Unit,
     modifier: Modifier = Modifier,
-    onEditFilter: (Long) -> Unit = {},
     viewModel: TaskListViewModel = hiltViewModel(),
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
@@ -159,9 +150,6 @@ fun TaskListScreen(
     val listDeleted by viewModel.listDeleted.collectAsStateWithLifecycle()
     // The list this screen is about is gone; there is nothing left to show.
     LaunchedEffect(listDeleted) { if (listDeleted) onBack() }
-    val savedFilter = content?.savedFilter
-    val filterGone = filter is TaskFilter.Saved && content?.filter == filter && savedFilter == null
-    LaunchedEffect(filterGone) { if (filterGone) onBack() }
     LaunchedEffect(listWriteFailure) {
         if (listWriteFailure != null) {
             delay(4_000)
@@ -190,7 +178,7 @@ fun TaskListScreen(
         modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
         topBar = {
             MediumTopAppBar(
-                title = { Text(titleFor(filter, listName ?: savedFilter?.name)) },
+                title = { Text(titleFor(filter, listName)) },
                 navigationIcon = {
                     IconButton(onClick = onBack) {
                         Icon(
@@ -201,14 +189,7 @@ fun TaskListScreen(
                 },
                 actions = {
                     IconButton(onClick = { showSort = true }, enabled = content != null) {
-                        BadgedBox(badge = { if (content?.selectedTags?.isNotEmpty() == true) Badge() }) {
+                        Icon(Icons.AutoMirrored.Rounded.Sort, contentDescription = stringResource(R.string.sort_title))
-                            Icon(Icons.Rounded.Tune, contentDescription = stringResource(R.string.view_options_title))
-                        }
-                    }
-                    if (savedFilter != null) {
-                        IconButton(onClick = { onEditFilter(savedFilter.id) }) {
-                            Icon(Icons.Rounded.Edit, contentDescription = stringResource(R.string.filter_edit_title))
-                        }
                     }
                     if (list != null) {
                         IconButton(
@@ -296,13 +277,12 @@ fun TaskListScreen(
     }
 
     if (showSort && content != null) {
-        ViewOptionsPicker(
+        OptionPicker(
-            sortOrder = content.sortOrder,
+            title = stringResource(R.string.sort_title),
-            tags = content.availableTags,
+            options = TaskSortOrder.entries,
-            selectedTags = content.selectedTags,
+            selected = content.sortOrder,
-            onSortOrder = viewModel::setSortOrder,
+            label = { stringResource(sortLabel(it)) },
-            onToggleTag = viewModel::toggleTagFilter,
+            onSelect = { viewModel.setSortOrder(it); showSort = false },
-            onClearTags = viewModel::clearTagFilter,
             onDismiss = { showSort = false },
         )
     }
@@ -344,7 +324,7 @@ fun TaskListScreen(
     }
 }
 
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class, ExperimentalLayoutApi::class)
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
 @Composable
 private fun TaskListBody(
     state: TaskListUiState.Content,
@@ -369,8 +349,7 @@ private fun TaskListBody(
     val listId = (filter as? TaskFilter.OfList)?.listId
     // In a mixed view (a smart list) the list colour bar + name disambiguate
     // rows; inside a single real list both are redundant.
-    val showListName = filter is TaskFilter.Smart || filter is TaskFilter.Tagged ||
+    val showListName = filter is TaskFilter.Smart
-        (filter is TaskFilter.Saved && state.savedFilter?.listIds?.size != 1)
     // Completed tasks collapse away by default to keep the active list in focus.
     var completedExpanded by rememberSaveable { mutableStateOf(false) }
     // Parents the user expanded to reveal their subtasks inline. Children are
@@ -400,16 +379,8 @@ private fun TaskListBody(
     // When the bottom quick-add bar is shown it already lives in the scaffold's
     // bottomBar (so `inner` covers it); otherwise reserve room to clear the FAB.
     val bottomBarShown = state.bottomAddBar && listId != null
-    // While typing, the viewport ends at the keyboard (or at the quick-add bar
-    // riding on it), so a focused add-subtask row can scroll fully above it.
-    val imeVisible = WindowInsets.isImeVisible
-    val viewport = when {
-        !imeVisible -> Modifier
-        bottomBarShown -> Modifier.padding(bottom = inner.calculateBottomPadding())
-        else -> Modifier.imePadding()
-    }
     LazyColumn(
-        modifier = Modifier.fillMaxSize().then(viewport),
+        modifier = Modifier.fillMaxSize(),
         contentPadding = PaddingValues(
             top = inner.calculateTopPadding() + 8.dp,
             bottom = inner.calculateBottomPadding() + if (bottomBarShown) 16.dp else 96.dp,
@@ -688,7 +659,7 @@ internal fun TaskRowContent(
     val listName = task.listName?.takeIf { showListName && it.isNotBlank() }
     // Everything secondary collapses into one quiet supporting line below the title.
     val hasMeta = task.priority != Priority.NONE || due != null || subtaskTotal > 0 ||
-        listName != null || task.isOccurrence || task.tags.isNotEmpty()
+        listName != null || task.isOccurrence
 
     Surface(
         onClick = onClick,
@@ -743,7 +714,6 @@ internal fun TaskRowContent(
                         subtaskTotal = subtaskTotal,
                         listName = listName,
                         listColor = task.effectiveColor,
-                        tags = task.tags,
                         dark = dark,
                     )
                 }
@@ -775,7 +745,6 @@ private fun TaskMetaLine(
     subtaskTotal: Int,
     listName: String?,
     listColor: Int,
-    tags: List<String>,
     dark: Boolean,
 ) {
     val muted = MaterialTheme.colorScheme.onSurfaceVariant
@@ -831,28 +800,6 @@ private fun TaskMetaLine(
                 }
             }
         }
-        if (tags.isNotEmpty()) {
-            add {
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.spacedBy(3.dp),
-                ) {
-                    Icon(
-                        Icons.Rounded.Sell,
-                        contentDescription = stringResource(R.string.edit_tags_label),
-                        tint = muted,
-                        modifier = Modifier.size(13.dp),
-                    )
-                    Text(
-                        tags.joinToString(", "),
-                        style = style,
-                        color = muted,
-                        maxLines = 1,
-                        overflow = TextOverflow.Ellipsis,
-                    )
-                }
-            }
-        }
         if (listName != null) {
             add {
                 Text(
@@ -905,7 +852,7 @@ private fun AddSubtaskRow(
         shape = cardShape(position, 22.dp, 6.dp),
         // Same tone as the subtask rows it closes, so the group reads as one unit.
         color = MaterialTheme.colorScheme.surfaceContainer,
-        modifier = modifier.fillMaxWidth().padding(horizontal = 16.dp).then(gap).revealOnFocus(),
+        modifier = modifier.fillMaxWidth().padding(horizontal = 16.dp).then(gap),
     ) {
         Row(
             modifier = Modifier.fillMaxWidth().heightIn(min = 52.dp).padding(start = 12.dp, end = 8.dp),
@@ -1222,65 +1169,11 @@ private fun CenteredMessage(text: String, inner: PaddingValues) {
     }
 }
 
-/**
- * Sort and tag filter in one place. Stays open while choosing, since several
- * tags can be ticked; back leaves. A task must carry every ticked tag.
- */
 @Composable
-private fun ViewOptionsPicker(
+private fun titleFor(filter: TaskFilter, listName: String?): String = when (filter) {
-    sortOrder: TaskSortOrder,
+    is TaskFilter.OfList -> listName ?: stringResource(R.string.tasks_title)
-    tags: List<String>,
-    selectedTags: Set<String>,
-    onSortOrder: (TaskSortOrder) -> Unit,
-    onToggleTag: (String) -> Unit,
-    onClearTags: () -> Unit,
-    onDismiss: () -> Unit,
-) {
-    FullScreenPicker(
-        title = stringResource(R.string.view_options_title),
-        onDismiss = onDismiss,
-        actions = {
-            if (selectedTags.isNotEmpty()) {
-                TextButton(onClick = onClearTags) { Text(stringResource(R.string.view_filter_clear)) }
-            }
-        },
-    ) {
-        GroupedSectionHeader(stringResource(R.string.sort_title))
-        TaskSortOrder.entries.forEachIndexed { index, order ->
-            val isSelected = order == sortOrder
-            GroupedRow(
-                title = stringResource(sortLabel(order)),
-                position = positionOf(index, TaskSortOrder.entries.size),
-                selected = isSelected,
-                trailing = if (isSelected) ({ SelectedCheck() }) else null,
-                onClick = { onSortOrder(order) },
-            )
-        }
-        if (tags.isNotEmpty()) {
-            Spacer(Modifier.height(8.dp))
-            GroupedSectionHeader(stringResource(R.string.view_filter_tags))
-            tags.forEachIndexed { index, tag ->
-                val isSelected = tag in selectedTags
-                GroupedRow(
-                    title = tag,
-                    position = positionOf(index, tags.size),
-                    selected = isSelected,
-                    leading = { Icon(Icons.Rounded.Sell, contentDescription = null) },
-                    trailing = if (isSelected) ({ SelectedCheck() }) else null,
-                    onClick = { onToggleTag(tag) },
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun titleFor(filter: TaskFilter, name: String?): String = when (filter) {
-    is TaskFilter.OfList -> name ?: stringResource(R.string.tasks_title)
-    is TaskFilter.Saved -> name.orEmpty()
     // Several lists at once only exists for the widget, which never routes here.
     is TaskFilter.OfLists -> error("OfLists has no task-list screen")
-    is TaskFilter.Tagged -> filter.tag
     is TaskFilter.Smart -> stringResource(
         when (filter.list) {
             SmartList.TODAY -> R.string.smart_today

app/src/main/java/de/jeanlucmakiola/agendula/ui/tasklist/TaskListViewModel.kt

@@ -7,11 +7,8 @@ import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.agendula.data.sync.RemoteLists
 import de.jeanlucmakiola.agendula.data.tasks.TasksRepository
 import de.jeanlucmakiola.agendula.data.tasks.recoveringFromProviderFailure
-import de.jeanlucmakiola.agendula.domain.SavedFilter
 import de.jeanlucmakiola.agendula.domain.Task
 import de.jeanlucmakiola.agendula.domain.TaskFilter
-import de.jeanlucmakiola.agendula.domain.TaskFiltering
-import de.jeanlucmakiola.agendula.domain.tagsInUse
 import de.jeanlucmakiola.agendula.domain.TaskForm
 import de.jeanlucmakiola.agendula.domain.TaskList
 import de.jeanlucmakiola.agendula.domain.TaskSortOrder
@@ -58,14 +55,6 @@ sealed interface TaskListUiState {
         val sortOrder: TaskSortOrder = TaskSortOrder.DUE,
         /** This real list is kept out of the smart lists. */
         val hiddenFromSmartLists: Boolean = false,
-        /** Tags the unnarrowed view carries, offered as filter chips. */
-        val availableTags: List<String> = emptyList(),
-        /** The tags [tasks] is narrowed to; a task must carry all of them. */
-        val selectedTags: Set<String> = emptySet(),
-        /** The definition behind a [TaskFilter.Saved]; `null` once it's deleted. */
-        val savedFilter: SavedFilter? = null,
-        /** The filter this content was built for; a reused screen briefly holds the previous one's. */
-        val filter: TaskFilter? = null,
     ) : TaskListUiState
 }
 
@@ -94,8 +83,6 @@ class TaskListViewModel @Inject constructor(
 
     private val filter = MutableStateFlow<TaskFilter?>(null)
 
-    private val tagFilter = MutableStateFlow<Set<String>>(emptySet())
-
     /** Occurrences swiped to delete but not yet committed — hidden until the undo lapses. */
     private val pendingDeletes = MutableStateFlow<Map<String, Task>>(emptyMap())
 
@@ -114,33 +101,20 @@ class TaskListViewModel @Inject constructor(
                         combine(tasks, repository.taskLists()) { rows, lists ->
                             TaskListUiState.Content(rows, lists.firstOrNull { it.id == f.listId })
                         }
-                    is TaskFilter.Smart, is TaskFilter.Tagged ->
+                    is TaskFilter.Smart ->
                         tasks.map { TaskListUiState.Content(it) }
-                    is TaskFilter.Saved ->
-                        repository.filteredTasks(f).map {
-                            TaskListUiState.Content(it.tasks, savedFilter = it.savedFilter)
-                        }
                     // Several lists at once only exists for the widget, which never routes here.
                     is TaskFilter.OfLists -> error("OfLists has no task-list screen")
                 }
                 // Drop rows pending an undoable delete so the row vanishes on swipe
                 // while the actual provider delete waits for the snackbar to commit,
                 // and fold in the live UI settings (add-subtask row, bottom add bar).
-                combine(content, pendingDeletes, settingsPrefs.settings, tagFilter) { st, pending, settings, tags ->
+                combine(content, pendingDeletes, settingsPrefs.settings) { st, pending, settings ->
                     if (st is TaskListUiState.Content) {
-                        val visible = settings.visibleIn(f, st.tasks).filter { it.occurrenceKey !in pending }
-                        val available = tagsInUse(visible) - setOfNotNull((f as? TaskFilter.Tagged)?.tag)
-                        // A tag that vanished can no longer be unticked, so it is dropped
-                        // for good rather than narrowing again when it comes back.
-                        val selected = tags.filterTo(LinkedHashSet()) { it in available }
-                        if (selected.size != tags.size) tagFilter.value = selected
                         st.copy(
-                            filter = f,
+                            tasks = settings.visibleIn(f, st.tasks)
-                            tasks = visible
+                                .filter { it.occurrenceKey !in pending }
-                                .filter { TaskFiltering.hasAllTags(it, selected) }
                                 .sortedWith(settings.sortOrder.comparator()),
-                            availableTags = available,
-                            selectedTags = selected,
                             showAddSubtaskRow = settings.showAddSubtaskRow,
                             bottomAddBar = settings.bottomAddBar,
                             sortOrder = settings.sortOrder,
@@ -189,12 +163,6 @@ class TaskListViewModel @Inject constructor(
 
     fun bind(taskFilter: TaskFilter) { filter.value = taskFilter }
 
-    fun toggleTagFilter(tag: String) {
-        tagFilter.value = if (tag in tagFilter.value) tagFilter.value - tag else tagFilter.value + tag
-    }
-
-    fun clearTagFilter() { tagFilter.value = emptySet() }
-
     fun toggleComplete(task: Task) {
         if (task.isCompleted) {
             viewModelScope.launch {

app/src/main/java/de/jeanlucmakiola/agendula/widget/TaskWidget.kt

@@ -169,12 +169,6 @@ private fun TaskWidgetBody(
     val ready = data as? TaskWidgetData.Ready
     val title = when (filter) {
         is TaskFilter.Smart -> context.getString(smartListLabel(filter.list))
-        is TaskFilter.Tagged -> filter.tag
-        is TaskFilter.Saved -> if (ready == null) {
-            context.getString(R.string.widget_tasks_label)
-        } else {
-            ready.filterName ?: context.getString(R.string.filter_missing)
-        }
         is TaskFilter.OfList, is TaskFilter.OfLists -> ready?.singleListName
             ?: context.getString(R.string.widget_tasks_label)
     }
@@ -285,8 +279,6 @@ private fun TaskWidgetHeader(title: String, filter: TaskFilter, singleListId: Lo
         // still opens straight to it, otherwise this just raises the app.
         is TaskFilter.OfLists -> filter.listIds.singleOrNull()?.let { MainActivity.listIntent(context, it) }
             ?: Intent(context, MainActivity::class.java).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        is TaskFilter.Tagged -> Intent(context, MainActivity::class.java).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        is TaskFilter.Saved -> MainActivity.filterIntent(context, filter.id)
     }
     WidgetHeader(
         title = title,

app/src/main/java/de/jeanlucmakiola/agendula/widget/TaskWidgetConfigActivity.kt

@@ -41,7 +41,6 @@ import de.jeanlucmakiola.agendula.data.prefs.Settings
 import de.jeanlucmakiola.agendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.agendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.agendula.data.tasks.TasksRepository
-import de.jeanlucmakiola.agendula.domain.SavedFilter
 import de.jeanlucmakiola.agendula.domain.SmartList
 import de.jeanlucmakiola.agendula.domain.TaskFilter
 import de.jeanlucmakiola.agendula.domain.TaskList
@@ -119,7 +118,6 @@ class TaskWidgetConfigActivity : ComponentActivity() {
         setContent {
             val settings by settingsPrefs.settings.collectAsState(initial = Settings())
             val lists by remember { listsFlow }.collectAsState(initial = emptyList())
-            val savedFilters by settingsPrefs.savedFilters.collectAsState(initial = emptyList())
             var current by remember { mutableStateOf<TaskFilter?>(null) }
             var groupByList by remember { mutableStateOf(false) }
             var background by remember { mutableStateOf(WidgetBackground.SOLID) }
@@ -145,7 +143,6 @@ class TaskWidgetConfigActivity : ComponentActivity() {
                 WidgetFilterPicker(
                     kind = kind,
                     lists = lists.filter { it.isVisible },
-                    savedFilters = savedFilters,
                     dark = dark,
                     selected = current ?: DEFAULT_WIDGET_FILTER,
                     groupByList = groupByList,
@@ -196,7 +193,6 @@ class TaskWidgetConfigActivity : ComponentActivity() {
 private fun WidgetFilterPicker(
     kind: WidgetKind,
     lists: List<TaskList>,
-    savedFilters: List<SavedFilter>,
     selected: TaskFilter,
     dark: Boolean,
     groupByList: Boolean,
@@ -215,25 +211,21 @@ private fun WidgetFilterPicker(
     var showBackgroundPicker by remember { mutableStateOf(false) }
     var showThemePicker by remember { mutableStateOf(false) }
     var showRowColorPicker by remember { mutableStateOf(false) }
-    // Smart lists, saved filters and real lists are mutually exclusive; only real
+    // Smart lists and real lists are mutually exclusive; only real lists support
-    // lists support picking more than one. `selectedSmart` or `selectedFilter`
+    // picking more than one. `selectedLists` empty + `selectedSmart` non-null is
-    // non-null is that pick; otherwise (or before the stored filter loads) it's
+    // a smart-list pick; the reverse (or both empty, before the stored filter
-    // a list pick.
+    // loads) is a list pick.
     var selectedSmart by remember(selected) { mutableStateOf((selected as? TaskFilter.Smart)?.list) }
-    var selectedFilter by remember(selected) { mutableStateOf((selected as? TaskFilter.Saved)?.id) }
     var selectedLists by remember(selected) {
         mutableStateOf(
             when (selected) {
                 is TaskFilter.OfList -> setOf(selected.listId)
                 is TaskFilter.OfLists -> selected.listIds
-                is TaskFilter.Smart, is TaskFilter.Tagged, is TaskFilter.Saved -> emptySet()
+                is TaskFilter.Smart -> emptySet()
             },
         )
     }
-    // A widget whose filter was deleted keeps the dead id until something else is picked.
+    val canSave = kind != WidgetKind.TASKS || selectedSmart != null || selectedLists.isNotEmpty()
-    val liveFilter = selectedFilter?.takeIf { id -> savedFilters.any { it.id == id } }
-    val canSave = kind != WidgetKind.TASKS || selectedSmart != null || liveFilter != null ||
-        selectedLists.isNotEmpty()
 
     FullScreenPicker(
         title = stringResource(if (kind == WidgetKind.LISTS) R.string.widget_lists_config_title else R.string.widget_config_title),
@@ -247,11 +239,8 @@ private fun WidgetFilterPicker(
                     // a smart list, has to clear it here instead; otherwise it's
                     // stuck on with no way left to see or undo it.
                     if (selectedLists.size <= 1 && groupByList) onGroupByListChange(false)
-                    when {
+                    selectedSmart?.let { onSave(TaskFilter.Smart(it)) }
-                        selectedSmart != null -> onSave(TaskFilter.Smart(selectedSmart!!))
+                        ?: onSave(TaskFilter.OfLists(selectedLists))
-                        liveFilter != null -> onSave(TaskFilter.Saved(liveFilter))
-                        else -> onSave(TaskFilter.OfLists(selectedLists))
-                    }
                 },
             ) { Text(stringResource(android.R.string.ok)) }
         },
@@ -265,22 +254,9 @@ private fun WidgetFilterPicker(
                     position = positionOf(index, WIDGET_SMART_LISTS.size),
                     selected = isSelected,
                     trailing = if (isSelected) ({ SelectedCheck() }) else null,
-                    onClick = { selectedSmart = smart; selectedFilter = null; selectedLists = emptySet() },
+                    onClick = { selectedSmart = smart; selectedLists = emptySet() },
                 )
             }
-            if (savedFilters.isNotEmpty()) {
-                GroupedSectionHeader(stringResource(R.string.filters_header))
-                savedFilters.forEachIndexed { index, filter ->
-                    val isSelected = filter.id == selectedFilter
-                    GroupedRow(
-                        title = filter.name,
-                        position = positionOf(index, savedFilters.size),
-                        selected = isSelected,
-                        trailing = if (isSelected) ({ SelectedCheck() }) else null,
-                        onClick = { selectedFilter = filter.id; selectedSmart = null; selectedLists = emptySet() },
-                    )
-                }
-            }
             if (lists.isNotEmpty()) {
                 GroupedSectionHeader(stringResource(R.string.lists_header))
                 lists.forEachIndexed { index, list ->
@@ -293,7 +269,6 @@ private fun WidgetFilterPicker(
                         trailing = if (isSelected) ({ SelectedCheck() }) else null,
                         onClick = {
                             selectedSmart = null
-                            selectedFilter = null
                             selectedLists = if (isSelected) selectedLists - list.id else selectedLists + list.id
                         },
                     )

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

@@ -100,8 +100,6 @@ internal fun TaskFilter.widgetStorageValue(): String = when (this) {
     is TaskFilter.OfList -> "list:$listId"
     is TaskFilter.OfLists -> "lists:${listIds.sorted().joinToString(",")}"
     is TaskFilter.Smart -> "smart:${list.name}"
-    is TaskFilter.Tagged -> error("A tag has no widget")
-    is TaskFilter.Saved -> "filter:$id"
 }
 
 /** Anything unreadable, or a smart list the widget doesn't offer, falls back to Today. */
@@ -113,8 +111,6 @@ internal fun parseWidgetFilter(raw: String?): TaskFilter {
         value.startsWith("lists:") ->
             value.removePrefix("lists:").split(",").mapNotNull { it.toLongOrNull()?.takeIf { id -> id > 0 } }
                 .toSet().takeIf { it.isNotEmpty() }?.let { TaskFilter.OfLists(it) }
-        value.startsWith("filter:") ->
-            value.removePrefix("filter:").toLongOrNull()?.takeIf { it > 0 }?.let { TaskFilter.Saved(it) }
         value.startsWith("smart:") ->
             WIDGET_SMART_LISTS.firstOrNull { it.name == value.removePrefix("smart:") }?.let { TaskFilter.Smart(it) }
         else -> null
@@ -165,14 +161,12 @@ sealed interface TaskWidgetData {
         val dynamicColor: Boolean,
         val themeMode: ThemeMode,
         val use24Hour: Boolean,
-        /** The saved filter's name when [filter] is one; `null` once it's deleted. */
-        val filterName: String? = null,
     ) : TaskWidgetData {
         /** The one list's id, when [filter] names exactly one real list — seeds a widget's add button. */
         val singleListId: Long? = when (filter) {
             is TaskFilter.OfList -> filter.listId
             is TaskFilter.OfLists -> filter.listIds.singleOrNull()
-            is TaskFilter.Smart, is TaskFilter.Tagged, is TaskFilter.Saved -> null
+            is TaskFilter.Smart -> null
         }
 
         /** [singleListId]'s name. */
@@ -277,11 +271,10 @@ internal fun Context.taskWidgetData(filter: TaskFilter, groupByList: Boolean): F
     val ep = widgetEntryPoint()
     val repository = ep.tasksRepository()
     return combine(
-        repository.filteredTasks(filter),
+        repository.tasks(filter),
         repository.taskLists(),
         ep.settingsPrefs().settings,
-    ) { filtered, lists, settings ->
+    ) { tasks, lists, settings ->
-        val tasks = filtered.tasks
         val listNames = lists.associate { it.id to it.name }
         val data: TaskWidgetData = TaskWidgetData.Ready(
             filter = filter,
@@ -298,7 +291,6 @@ internal fun Context.taskWidgetData(filter: TaskFilter, groupByList: Boolean): F
             dynamicColor = settings.dynamicColor,
             themeMode = settings.themeMode,
             use24Hour = settings.timeFormat.is24Hour(DateFormat.is24HourFormat(this)),
-            filterName = filtered.savedFilter?.name,
         )
         data
     }.catch { emit(TaskWidgetData.Unavailable) }