diff --git a/CONTEXT.md b/CONTEXT.md
index 52b2290..019cfbe 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -23,7 +23,7 @@ Optional markdown text attached to a MoodEntry. Serves both quick annotations ("
 _Avoid_: Note, quick note, description, journal entry
 
 **Activity**:
-A named item from a user's personal catalog, tagged onto MoodEntries. Covers heterogeneous concepts (social contexts like "friends", health actions like "exercise", sleep indicators like "good sleep") under one umbrella term. Each Activity belongs to exactly one User. Activities are archivable — archived Activities remain on historical entries but cannot be tagged onto new ones.
+A named item from a user's personal catalog, tagged onto MoodEntries. Covers heterogeneous concepts (social contexts like "friends", health actions like "exercise", sleep indicators like "good sleep") under one umbrella term. Each Activity belongs to exactly one User. Activities are archivable — an archived Activity stays on every entry already wearing it, and those entries stay editable, but it cannot be added to an entry that does not already carry it. Unarchiving makes it taggable again.
 _Avoid_: Tag, label, habit, tracker
 
 **Category**:
@@ -43,9 +43,13 @@ _Avoid_: TZ, offset, locale, region
 ### Scheduling
 
 **Reminder**:
-A per-user notification schedule. Each Reminder defines an `Option<Time>` for each day of the week — `Some(20:00)` means remind at 8 PM, `None` means skip that day. Can be enabled or disabled. A User can have multiple Reminders (e.g., one for morning check-in, one for evening). The domain defines when to remind; clients decide the message and delivery mechanism.
+A per-user notification schedule. Each Reminder defines an `Option<Time>` for each day of the week — `Some(20:00)` means remind at 8 PM, `None` means skip that day. Can be enabled or disabled. A User can have multiple Reminders (e.g., one for morning check-in, one for evening). Remembers the last DueOccurrence it sent, so a schedule is answered once however often it is asked. The domain defines when to remind; clients decide the message and delivery mechanism.
 _Avoid_: Notification, alert, alarm, push
 
+**DueOccurrence**:
+One scheduled firing of one Reminder, identified by the instant its wall clock time resolves to in the User's Timezone. What a Reminder records as sent — not the moment of sending, so asking again about the same occurrence answers no. Reached only once its instant has passed and while it is still inside a configured grace, so a worker that starts late does not deliver a morning that is over.
+_Avoid_: Trigger, firing, due time, schedule slot
+
 ### Measurement
 
 **DailyMetric**:
@@ -61,9 +65,13 @@ An external system that supplies data. Identified only by name — the domain kn
 _Avoid_: Integration, service, source, connector
 
 **ApiToken**:
-A named, revocable, non-expiring credential a User mints for an automation that cannot hold a session. Scoped to writing DailyMetrics and nothing else — it cannot read entries or touch the account. Its name is the Provider its writes are attributed to, so two tokens of one account cannot share a name. The value is shown once at mint time and held only as a digest.
+A named, revocable, non-expiring credential a User mints for a client that cannot hold a session. Grants the TokenScopes it was minted with and nothing else, and never the account itself — no token can change a password, mint another token, or restore a backup. Its name is the Provider its metric writes are attributed to, so two tokens of one account cannot share a name. The value is shown once at mint time and held only as a digest.
 _Avoid_: API key, secret, personal access token, integration key
 
+**TokenScope**:
+One named thing an ApiToken may do — read the journal, write the journal, write DailyMetrics, read the profile. Named after what a client does, not after the routes it calls, so a route's requirement is a statement about intent. A token holds a non-empty set of them; a name this build does not know is refused rather than ignored, because a typo must never mint a narrower token than the one asked for.
+_Avoid_: Permission, grant, role, capability
+
 **ProviderConnection**:
 A User's standing authorization to a Provider, held as an opaque credential the domain never inspects. Each User supplies their own, and holds at most one per Provider — connecting again replaces it. The domain knows only that a User is or is not connected to a named Provider.
 _Avoid_: Account link, integration, credentials, connection
@@ -76,6 +84,14 @@ _Avoid_: Metric type, field, measurement name
 The calendar day a DailyMetric belongs to, resolved by converting an instant into the User's Timezone. The single day boundary in the system — MoodEntries group onto the same Date for calendar and analytics.
 _Avoid_: Day, logged date, local date
 
+**EntrySelection**:
+What a client is asking to read, as one value: the account, and optionally a range of instants, a Mood, an Activity, and an instant to return only what changed after. Combining narrowings is the point — every filter is the same kind of thing, so a page of one mood within one month is a selection rather than an endpoint nobody wrote. Counting and reading use the same selection, so a total can never describe a different question from the page beneath it.
+_Avoid_: Filter, criteria, search, query params
+
+**Page**:
+One window onto an EntrySelection, with the total for the whole selection beside it. The total is what makes paging honest: without it a client can only fetch until a short page arrives and hope. A page larger than the server serves cannot be constructed, so an unbounded read is not something a client can ask for by accident.
+_Avoid_: Batch, chunk, result set, slice
+
 **DateSpan**:
 A run of consecutive Dates, inclusive of both ends. What day-keyed data is read by, and distinct from the range of instants that MoodEntries are deleted by — a span of days has no time of day, so nothing about it depends on an offset.
 _Avoid_: Date range, period, window, interval
@@ -106,6 +122,10 @@ _Avoid_: Weather code, description, icon, summary
 The coordinates a MoodEntry was logged at. Supplied by the client, optional, and the prerequisite for Weather.
 _Avoid_: GPS, position, place, geo
 
+**MediaRef**:
+A photo or voice memo named by its kind together with its id. What ownership of a blob is recorded against, so one record serves both kinds and two objects sharing a uuid across kinds stay distinct. The blob store itself knows nothing of Users; who may delete a photo is a fact held beside it, never inferred from whichever MoodEntry happens to wear it.
+_Avoid_: Attachment id, file, asset, blob key
+
 **CycleStart**:
 A Date on which a User's menstrual period began. Recorded once per cycle, never per day. Cycle day for any Date is derived from the most recent preceding CycleStart and is never stored — correcting a CycleStart therefore corrects every Date that depends on it. Recorded only while the User has cycle tracking on; turning it off hides every derived cycle day without forgetting what was recorded.
 _Avoid_: Period, cycle day, menstrual day
diff --git a/Cargo.lock b/Cargo.lock
index b67ea2a..9b1e644 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -783,6 +783,20 @@ dependencies = [
  "cmov",
 ]
 
+[[package]]
+name = "dashmap"
+version = "6.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6361d5c062261c78a176addb82d4c821ae42bed6089de0e12603cd25de2059c"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
 [[package]]
 name = "der"
 version = "0.4.5"
@@ -1137,6 +1151,16 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "forwarded-header-value"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8835f84f38484cc86f110a805655697908257fb9a7af005234060891557198e9"
+dependencies = [
+ "nonempty",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "fs_extra"
 version = "1.3.0"
@@ -1210,6 +1234,12 @@ version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
 
+[[package]]
+name = "futures-timer"
+version = "3.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af43fadb8a98512d547e37b4e92e0ced13e205c061b87b4623eff01d918d6968"
+
 [[package]]
 name = "futures-util"
 version = "0.3.34"
@@ -1257,9 +1287,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "r-efi 5.3.0",
  "wasip2",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -1285,6 +1317,29 @@ dependencies = [
  "polyval",
 ]
 
+[[package]]
+name = "governor"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9efcab3c1958580ff1f25a2a41be1668f7603d849bb63af523b208a3cc1223b8"
+dependencies = [
+ "cfg-if",
+ "dashmap",
+ "futures-sink",
+ "futures-timer",
+ "futures-util",
+ "getrandom 0.3.4",
+ "hashbrown 0.16.1",
+ "nonzero_ext",
+ "parking_lot",
+ "portable-atomic",
+ "quanta",
+ "rand 0.9.5",
+ "smallvec",
+ "spinning_top",
+ "web-time",
+]
+
 [[package]]
 name = "group"
 version = "0.13.0"
@@ -1315,6 +1370,12 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
 [[package]]
 name = "hashbrown"
 version = "0.16.1"
@@ -1444,9 +1505,13 @@ dependencies = [
  "axum",
  "config",
  "domain",
+ "http-body-util",
  "serde",
  "serde_json",
+ "tokio",
+ "tower",
  "tower-http 0.7.0",
+ "tower_governor",
  "tracing",
  "utoipa",
  "utoipa-scalar",
@@ -2124,6 +2189,18 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "nonempty"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9e591e719385e6ebaeb5ce5d3887f7d5676fceca6411d1925ccc95745f3d6f7"
+
+[[package]]
+name = "nonzero_ext"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38bf9645c8b145698bb0b18a4637dcacbc421ea49bef2317e4fd8065a387cf21"
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.50.3"
@@ -2432,6 +2509,26 @@ dependencies = [
  "siphasher",
 ]
 
+[[package]]
+name = "pin-project"
+version = "1.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.17"
@@ -2497,6 +2594,12 @@ dependencies = [
  "universal-hash 0.6.1",
 ]
 
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
 [[package]]
 name = "potential_utf"
 version = "0.1.6"
@@ -2552,6 +2655,21 @@ dependencies = [
  "yansi",
 ]
 
+[[package]]
+name = "quanta"
+version = "0.12.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3ab5a9d756f0d97bdc89019bd2e4ea098cf9cde50ee7564dde6b81ccc8f06c7"
+dependencies = [
+ "crossbeam-utils",
+ "libc",
+ "once_cell",
+ "raw-cpuid",
+ "wasi",
+ "web-sys",
+ "winapi",
+]
+
 [[package]]
 name = "quick-xml"
 version = "0.41.0"
@@ -2725,6 +2843,15 @@ dependencies = [
  "rand_core 0.10.1",
 ]
 
+[[package]]
+name = "raw-cpuid"
+version = "11.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186"
+dependencies = [
+ "bitflags",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
@@ -3317,6 +3444,15 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "023a211cb3138dbc438680b32560ad89f699977624c9f8dbb95a47d5b4c07dd3"
 
+[[package]]
+name = "spinning_top"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d96d2d1d716fb500937168cc09353ffdc7a012be8475ac7308e1bdf0e3923300"
+dependencies = [
+ "lock_api",
+]
+
 [[package]]
 name = "spki"
 version = "0.7.3"
@@ -3939,6 +4075,22 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
+[[package]]
+name = "tower_governor"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44de9b94d849d3c46e06a883d72d408c2de6403367b39df2b1c9d9e7b6736fe6"
+dependencies = [
+ "axum",
+ "forwarded-header-value",
+ "governor",
+ "http 1.5.0",
+ "pin-project",
+ "thiserror 2.0.20",
+ "tower",
+ "tracing",
+]
+
 [[package]]
 name = "tracing"
 version = "0.1.44"
@@ -4377,6 +4529,22 @@ version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "626c4bac6755d76ffc12cb01b2eac751db1996b9e0041de9aa02c8c211ddc82c"
 
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
 [[package]]
 name = "winapi-util"
 version = "0.1.11"
@@ -4386,6 +4554,12 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
 [[package]]
 name = "windows-core"
 version = "0.62.2"
@@ -4548,6 +4722,7 @@ version = "0.1.0"
 dependencies = [
  "application",
  "bootstrap",
+ "chrono",
  "config",
  "domain",
  "tokio",
diff --git a/Cargo.toml b/Cargo.toml
index 74fe2d9..eec22ee 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -57,7 +57,10 @@ tokio = { version = "1", features = ["rt-multi-thread", "macros", "signal"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 axum = { version = "0.8", features = ["macros", "multipart"] }
+tower = { version = "0.5", features = ["util"] }
+http-body-util = "0.1"
 tower-http = { version = "0.7", features = ["cors", "trace", "fs"] }
+tower_governor = { version = "0.8", default-features = false, features = ["axum"] }
 sqlx = { version = "0.9", features = ["runtime-tokio", "sqlite"] }
 email_address = "0.2"
 chrono-tz = { version = "0.10", features = ["serde"] }
diff --git a/config.example.toml b/config.example.toml
index e261d0a..87f0b2f 100644
--- a/config.example.toml
+++ b/config.example.toml
@@ -18,6 +18,25 @@ max_content_length = 65536
 max_photos = 10
 max_voice_memos = 5
 max_activities_per_entry = 50
+max_entries_per_page = 200
+
+[server.rate_limit]
+# Guards the API only. The client's own static files are served outside this
+# budget — one cold load asks for a dozen or more hashed assets at once, and
+# counting those here lets a hard refresh starve the app of its own code.
+enabled = true
+# Sustained ceiling per caller. Opening the client and touching every screen
+# costs roughly 25 API calls, so this is far above any person and still caps
+# what a script can pull.
+requests_per_second = 15
+# How much can arrive at once before the ceiling applies. Covers that opening
+# flurry about twice over, and refills completely in four seconds.
+burst = 60
+# Behind a reverse proxy this MUST be true, or every caller shares one bucket
+# keyed by the proxy's address and one busy client throttles everyone. Only
+# turn it on when the proxy sets X-Forwarded-For itself and refuses to pass
+# through a client-supplied one, or the limit can be evaded by forging it.
+trust_forwarded_for = false
 
 [storage]
 data_dir = "./data"
@@ -67,6 +86,7 @@ poll_seconds = 15
 sweep_seconds = 900
 session_cleanup_seconds = 3600
 reminder_seconds = 60
+reminder_grace_minutes = 30
 jobs_per_poll = 20
 enqueued_per_sweep = 200
 most_attempts = 5
diff --git a/crates/adapters/exporter/src/backup.rs b/crates/adapters/exporter/src/backup.rs
index 9b3d874..9856a85 100644
--- a/crates/adapters/exporter/src/backup.rs
+++ b/crates/adapters/exporter/src/backup.rs
@@ -15,7 +15,7 @@ use domain::reminder::Reminder;
 
 use super::shared::{io_err, json_err, zip_err};
 
-pub const BACKUP_FORMAT_VERSION: u32 = 2;
+pub const BACKUP_FORMAT_VERSION: u32 = 3;
 pub const BACKUP_MANIFEST: &str = "backup.json";
 
 pub struct ZipBackupWriter;
@@ -67,6 +67,7 @@ fn manifest(backup: &UserBackup) -> Result<Vec<u8>, DomainError> {
             .map(BackedUpReminder::from)
             .collect(),
         tracks_cycle: backup.preferences.tracks_cycle(),
+        media: backed_up_media(backup),
     };
 
     serde_json::to_vec_pretty(&manifest).map_err(json_err)
@@ -82,6 +83,37 @@ pub struct BackupManifest {
     pub activities: Vec<BackedUpActivity>,
     pub reminders: Vec<BackedUpReminder>,
     pub tracks_cycle: bool,
+    #[serde(default)]
+    pub media: Vec<BackedUpMedia>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BackedUpMedia {
+    pub id: String,
+    pub kind: String,
+    pub content_type: String,
+}
+
+pub const PHOTO_KIND: &str = "photo";
+pub const VOICE_MEMO_KIND: &str = "voice_memo";
+
+fn backed_up_media(backup: &UserBackup) -> Vec<BackedUpMedia> {
+    let photos = backup.media.photos.iter().map(|blob| (PHOTO_KIND, blob));
+    let memos = backup
+        .media
+        .voice_memos
+        .iter()
+        .map(|blob| (VOICE_MEMO_KIND, blob));
+
+    photos
+        .chain(memos)
+        .map(|(kind, blob)| BackedUpMedia {
+            id: blob.id.clone(),
+            kind: kind.to_string(),
+            content_type: blob.content_type.value().to_string(),
+        })
+        .collect()
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
diff --git a/crates/adapters/exporter/src/lib.rs b/crates/adapters/exporter/src/lib.rs
index 7f116aa..36b0f09 100644
--- a/crates/adapters/exporter/src/lib.rs
+++ b/crates/adapters/exporter/src/lib.rs
@@ -3,7 +3,7 @@ mod extract;
 mod shared;
 
 pub use backup::{
-    BACKUP_FORMAT_VERSION, BACKUP_MANIFEST, BackedUpActivity, BackedUpEntry, BackedUpMetric,
-    BackedUpReminder, BackupManifest, ZipBackupWriter,
+    BACKUP_FORMAT_VERSION, BACKUP_MANIFEST, BackedUpActivity, BackedUpEntry, BackedUpMedia,
+    BackedUpMetric, BackedUpReminder, BackupManifest, PHOTO_KIND, VOICE_MEMO_KIND, ZipBackupWriter,
 };
 pub use extract::MarkdownExtractWriter;
diff --git a/crates/adapters/http-axum/Cargo.toml b/crates/adapters/http-axum/Cargo.toml
index 4b702a0..926fe05 100644
--- a/crates/adapters/http-axum/Cargo.toml
+++ b/crates/adapters/http-axum/Cargo.toml
@@ -11,6 +11,7 @@ config.workspace = true
 web-push-adapter.workspace = true
 axum.workspace = true
 tower-http.workspace = true
+tower_governor.workspace = true
 async-trait.workspace = true
 serde.workspace = true
 serde_json.workspace = true
@@ -18,3 +19,8 @@ uuid.workspace = true
 utoipa.workspace = true
 utoipa-scalar.workspace = true
 tracing.workspace = true
+
+[dev-dependencies]
+tower.workspace = true
+http-body-util.workspace = true
+tokio.workspace = true
diff --git a/crates/adapters/http-axum/src/errors.rs b/crates/adapters/http-axum/src/errors.rs
index f5014d6..2f403c6 100644
--- a/crates/adapters/http-axum/src/errors.rs
+++ b/crates/adapters/http-axum/src/errors.rs
@@ -3,24 +3,37 @@ use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
 
 use api_types::errors::ApiValidationError;
+use api_types::responses::ErrorResponse;
 use application::errors::ApplicationError;
 use domain::errors::DomainError;
 
+pub const NOT_FOUND: &str = "NOT_FOUND";
+pub const INVALID_INPUT: &str = "INVALID_INPUT";
+pub const CONFLICT: &str = "CONFLICT";
+pub const UNAUTHORIZED: &str = "UNAUTHORIZED";
+pub const FORBIDDEN: &str = "FORBIDDEN";
+pub const VALIDATION_ERROR: &str = "VALIDATION_ERROR";
+pub const TOO_MANY_REQUESTS: &str = "TOO_MANY_REQUESTS";
+pub const INTERNAL_ERROR: &str = "INTERNAL_ERROR";
+
 pub struct ApiError(pub ApplicationError);
 
+pub fn refuse(status: StatusCode, code: &str, message: impl Into<String>) -> Response {
+    (status, Json(ErrorResponse::new(code, message))).into_response()
+}
+
 impl IntoResponse for ApiError {
     fn into_response(self) -> Response {
         let (status, code, message) = match &self.0 {
             ApplicationError::Domain(domain_err) => domain_error_response(domain_err),
             ApplicationError::Validation(msg) => (
                 StatusCode::UNPROCESSABLE_ENTITY,
-                "VALIDATION_ERROR",
+                VALIDATION_ERROR,
                 msg.clone(),
             ),
         };
 
-        let body = serde_json::json!({ "error": { "code": code, "message": message } });
-        (status, Json(body)).into_response()
+        refuse(status, code, message)
     }
 }
 
@@ -47,10 +60,10 @@ impl From<DomainError> for ApiError {
 
 fn domain_error_response(err: &DomainError) -> (StatusCode, &'static str, String) {
     match err {
-        DomainError::NotFound(msg) => (StatusCode::NOT_FOUND, "NOT_FOUND", msg.clone()),
-        DomainError::InvalidInput(msg) => (StatusCode::BAD_REQUEST, "INVALID_INPUT", msg.clone()),
-        DomainError::Conflict(msg) => (StatusCode::CONFLICT, "CONFLICT", msg.clone()),
-        DomainError::Unauthorized(msg) => (StatusCode::UNAUTHORIZED, "UNAUTHORIZED", msg.clone()),
-        DomainError::Forbidden(msg) => (StatusCode::FORBIDDEN, "FORBIDDEN", msg.clone()),
+        DomainError::NotFound(msg) => (StatusCode::NOT_FOUND, NOT_FOUND, msg.clone()),
+        DomainError::InvalidInput(msg) => (StatusCode::BAD_REQUEST, INVALID_INPUT, msg.clone()),
+        DomainError::Conflict(msg) => (StatusCode::CONFLICT, CONFLICT, msg.clone()),
+        DomainError::Unauthorized(msg) => (StatusCode::UNAUTHORIZED, UNAUTHORIZED, msg.clone()),
+        DomainError::Forbidden(msg) => (StatusCode::FORBIDDEN, FORBIDDEN, msg.clone()),
     }
 }
diff --git a/crates/adapters/http-axum/src/extractors/authenticated_user.rs b/crates/adapters/http-axum/src/extractors/authenticated_user.rs
deleted file mode 100644
index 1a6e99a..0000000
--- a/crates/adapters/http-axum/src/extractors/authenticated_user.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use axum::Json;
-use axum::extract::FromRequestParts;
-use axum::http::StatusCode;
-use axum::http::request::Parts;
-use axum::response::{IntoResponse, Response};
-
-use domain::user::UserId;
-
-use crate::state::AppState;
-
-pub struct AuthenticatedUser(pub UserId);
-
-impl IntoResponse for AuthRejection {
-    fn into_response(self) -> Response {
-        let body = serde_json::json!({ "error": self.0 });
-        (StatusCode::UNAUTHORIZED, Json(body)).into_response()
-    }
-}
-
-pub struct AuthRejection(String);
-
-impl AuthRejection {
-    pub fn new(reason: impl Into<String>) -> Self {
-        Self(reason.into())
-    }
-}
-
-impl<S> FromRequestParts<S> for AuthenticatedUser
-where
-    S: Send + Sync,
-    AppState: FromRef<S>,
-{
-    type Rejection = AuthRejection;
-
-    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
-        let app_state = AppState::from_ref(state);
-
-        let token = bearer_token(parts)
-            .ok_or_else(|| AuthRejection("missing or invalid authorization header".into()))?;
-
-        let user_id = app_state
-            .auth_service
-            .validate_token(&token)
-            .await
-            .map_err(|_| AuthRejection("invalid or expired token".into()))?;
-
-        Ok(AuthenticatedUser(user_id))
-    }
-}
-
-pub fn bearer_token(parts: &Parts) -> Option<String> {
-    let header = parts.headers.get("authorization")?.to_str().ok()?;
-    let token = header.strip_prefix("Bearer ")?;
-    Some(token.to_string())
-}
-
-use axum::extract::FromRef;
diff --git a/crates/adapters/http-axum/src/extractors/authentication.rs b/crates/adapters/http-axum/src/extractors/authentication.rs
new file mode 100644
index 0000000..ffcb70a
--- /dev/null
+++ b/crates/adapters/http-axum/src/extractors/authentication.rs
@@ -0,0 +1,145 @@
+use axum::http::StatusCode;
+use axum::http::request::Parts;
+use axum::response::{IntoResponse, Response};
+
+use application::errors::ApplicationError;
+use domain::api_token::{ApiToken, TokenScope};
+use domain::errors::DomainError;
+use domain::metric::Source;
+use domain::user::UserId;
+
+use application::api_token::use_cases::authenticate_api_token;
+
+use crate::errors::{FORBIDDEN, UNAUTHORIZED, refuse};
+use crate::state::AppState;
+
+pub struct AuthRejection {
+    status: StatusCode,
+    code: &'static str,
+    reason: String,
+}
+
+impl AuthRejection {
+    pub fn new(reason: impl Into<String>) -> Self {
+        Self {
+            status: StatusCode::UNAUTHORIZED,
+            code: UNAUTHORIZED,
+            reason: reason.into(),
+        }
+    }
+
+    pub fn forbidding(reason: impl Into<String>) -> Self {
+        Self {
+            status: StatusCode::FORBIDDEN,
+            code: FORBIDDEN,
+            reason: reason.into(),
+        }
+    }
+}
+
+impl IntoResponse for AuthRejection {
+    fn into_response(self) -> Response {
+        refuse(self.status, self.code, self.reason)
+    }
+}
+
+pub enum Bearer {
+    Session(UserId),
+    Token(ApiToken),
+}
+
+impl Bearer {
+    pub fn user_id(&self) -> &UserId {
+        match self {
+            Self::Session(user_id) => user_id,
+            Self::Token(token) => token.user_id(),
+        }
+    }
+
+    pub fn into_user_id(self) -> UserId {
+        match self {
+            Self::Session(user_id) => user_id,
+            Self::Token(token) => token.user_id().clone(),
+        }
+    }
+
+    pub fn attributes_writes_to(&self) -> Source {
+        match self {
+            Self::Session(_) => Source::Manual,
+            Self::Token(token) => Source::Provider(token.name().clone()),
+        }
+    }
+}
+
+pub fn bearer_token(parts: &Parts) -> Option<String> {
+    let header = parts.headers.get("authorization")?.to_str().ok()?;
+    let token = header.strip_prefix("Bearer ")?;
+
+    Some(token.to_string())
+}
+
+pub async fn session_only(parts: &Parts, state: &AppState) -> Result<UserId, AuthRejection> {
+    let presented = bearer_token(parts)
+        .ok_or_else(|| AuthRejection::new("missing or invalid authorization header"))?;
+
+    state
+        .auth_service
+        .validate_token(&presented)
+        .await
+        .map_err(|_| {
+            AuthRejection::new("this endpoint needs a signed-in session, not an api token")
+        })
+}
+
+pub async fn administrator(parts: &Parts, state: &AppState) -> Result<UserId, AuthRejection> {
+    let user_id = session_only(parts, state).await?;
+
+    let user = state
+        .user_query
+        .find_by_id(&user_id)
+        .await
+        .map_err(|_| AuthRejection::new("this account could not be read"))?
+        .ok_or_else(|| AuthRejection::new("this account no longer exists"))?;
+
+    if !user.is_admin() {
+        return Err(AuthRejection::forbidding(
+            "this endpoint is for whoever runs the server",
+        ));
+    }
+
+    Ok(user_id)
+}
+
+pub async fn session_or_token_granting(
+    parts: &Parts,
+    state: &AppState,
+    needed: TokenScope,
+) -> Result<Bearer, AuthRejection> {
+    let presented = bearer_token(parts)
+        .ok_or_else(|| AuthRejection::new("missing or invalid authorization header"))?;
+
+    if let Ok(user_id) = state.auth_service.validate_token(&presented).await {
+        return Ok(Bearer::Session(user_id));
+    }
+
+    let deps = authenticate_api_token::Deps {
+        query: state.api_token_query.clone(),
+        command: state.api_token_command.clone(),
+        secrets: state.api_token_secrets.clone(),
+    };
+
+    let token = authenticate_api_token::execute(&presented, needed, &deps)
+        .await
+        .map_err(refusal_for)?;
+
+    Ok(Bearer::Token(token))
+}
+
+fn refusal_for(error: ApplicationError) -> AuthRejection {
+    match error {
+        ApplicationError::Domain(DomainError::Forbidden(reason)) => {
+            AuthRejection::forbidding(reason)
+        }
+        other => AuthRejection::new(other.to_string()),
+    }
+}
diff --git a/crates/adapters/http-axum/src/extractors/body.rs b/crates/adapters/http-axum/src/extractors/body.rs
new file mode 100644
index 0000000..faa1070
--- /dev/null
+++ b/crates/adapters/http-axum/src/extractors/body.rs
@@ -0,0 +1,59 @@
+use axum::extract::rejection::{JsonRejection, QueryRejection};
+use axum::extract::{FromRequest, FromRequestParts, Query, Request};
+use axum::http::StatusCode;
+use axum::http::request::Parts;
+use axum::response::{IntoResponse, Response};
+
+use crate::errors::{INVALID_INPUT, refuse};
+
+pub struct Body<T>(pub T);
+
+pub struct Params<T>(pub T);
+
+pub struct MalformedRequest(String);
+
+impl IntoResponse for MalformedRequest {
+    fn into_response(self) -> Response {
+        refuse(StatusCode::BAD_REQUEST, INVALID_INPUT, self.0)
+    }
+}
+
+impl From<JsonRejection> for MalformedRequest {
+    fn from(rejection: JsonRejection) -> Self {
+        Self(rejection.body_text())
+    }
+}
+
+impl From<QueryRejection> for MalformedRequest {
+    fn from(rejection: QueryRejection) -> Self {
+        Self(rejection.body_text())
+    }
+}
+
+impl<S, T> FromRequest<S> for Body<T>
+where
+    S: Send + Sync,
+    axum::Json<T>: FromRequest<S, Rejection = JsonRejection>,
+{
+    type Rejection = MalformedRequest;
+
+    async fn from_request(request: Request, state: &S) -> Result<Self, Self::Rejection> {
+        let axum::Json(value) = axum::Json::<T>::from_request(request, state).await?;
+
+        Ok(Self(value))
+    }
+}
+
+impl<S, T> FromRequestParts<S> for Params<T>
+where
+    S: Send + Sync,
+    Query<T>: FromRequestParts<S, Rejection = QueryRejection>,
+{
+    type Rejection = MalformedRequest;
+
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
+        let Query(value) = Query::<T>::from_request_parts(parts, state).await?;
+
+        Ok(Self(value))
+    }
+}
diff --git a/crates/adapters/http-axum/src/extractors/importing_provider.rs b/crates/adapters/http-axum/src/extractors/importing_provider.rs
index ebcbfc9..ee3ce32 100644
--- a/crates/adapters/http-axum/src/extractors/importing_provider.rs
+++ b/crates/adapters/http-axum/src/extractors/importing_provider.rs
@@ -8,7 +8,9 @@ use application::api_token::use_cases::authenticate_api_token;
 
 use crate::state::AppState;
 
-use super::authenticated_user::{AuthRejection, bearer_token};
+use domain::api_token::TokenScope;
+
+use super::authentication::{AuthRejection, bearer_token};
 
 pub struct ImportingProvider {
     pub user_id: UserId,
@@ -34,9 +36,13 @@ where
             secrets: app_state.api_token_secrets,
         };
 
-        let token = authenticate_api_token::execute(&presented, &deps)
+        let token = authenticate_api_token::execute(&presented, TokenScope::WriteMetrics, &deps)
             .await
-            .map_err(|_| AuthRejection::new("importing needs an api token minted in settings"))?;
+            .map_err(|_| {
+                AuthRejection::new(
+                    "importing needs an api token granting writeMetrics, minted in settings",
+                )
+            })?;
 
         Ok(Self {
             user_id: token.user_id().clone(),
diff --git a/crates/adapters/http-axum/src/extractors/metric_writer.rs b/crates/adapters/http-axum/src/extractors/metric_writer.rs
deleted file mode 100644
index 6e32962..0000000
--- a/crates/adapters/http-axum/src/extractors/metric_writer.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use axum::extract::{FromRef, FromRequestParts};
-use axum::http::request::Parts;
-
-use domain::metric::Source;
-use domain::user::UserId;
-
-use application::api_token::use_cases::authenticate_api_token;
-
-use crate::state::AppState;
-
-use super::authenticated_user::{AuthRejection, bearer_token};
-
-pub struct MetricWriter {
-    pub user_id: UserId,
-    pub source: Source,
-}
-
-impl<S> FromRequestParts<S> for MetricWriter
-where
-    S: Send + Sync,
-    AppState: FromRef<S>,
-{
-    type Rejection = AuthRejection;
-
-    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
-        let app_state = AppState::from_ref(state);
-
-        let presented = bearer_token(parts)
-            .ok_or_else(|| AuthRejection::new("missing or invalid authorization header"))?;
-
-        if let Ok(user_id) = app_state.auth_service.validate_token(&presented).await {
-            return Ok(Self {
-                user_id,
-                source: Source::Manual,
-            });
-        }
-
-        let deps = authenticate_api_token::Deps {
-            query: app_state.api_token_query,
-            command: app_state.api_token_command,
-            secrets: app_state.api_token_secrets,
-        };
-
-        let token = authenticate_api_token::execute(&presented, &deps)
-            .await
-            .map_err(|_| AuthRejection::new("invalid or expired token"))?;
-
-        Ok(Self {
-            user_id: token.user_id().clone(),
-            source: Source::Provider(token.name().clone()),
-        })
-    }
-}
diff --git a/crates/adapters/http-axum/src/extractors/mod.rs b/crates/adapters/http-axum/src/extractors/mod.rs
index d0fd249..d21e7a5 100644
--- a/crates/adapters/http-axum/src/extractors/mod.rs
+++ b/crates/adapters/http-axum/src/extractors/mod.rs
@@ -1,11 +1,15 @@
-pub mod authenticated_user;
+pub mod authentication;
+mod body;
 mod importing_provider;
-mod metric_writer;
 mod multipart;
 mod path_id;
+mod scoped;
 
-pub use authenticated_user::AuthenticatedUser;
+pub use authentication::AuthRejection;
+pub use body::{Body, Params};
 pub use importing_provider::ImportingProvider;
-pub use metric_writer::MetricWriter;
 pub use multipart::{extract_file_bytes, extract_media_upload};
 pub use path_id::PathId;
+pub use scoped::{
+    Administrator, JournalReader, JournalWriter, MetricWriter, ProfileReader, SessionUser,
+};
diff --git a/crates/adapters/http-axum/src/extractors/path_id.rs b/crates/adapters/http-axum/src/extractors/path_id.rs
index 5a65df7..9414076 100644
--- a/crates/adapters/http-axum/src/extractors/path_id.rs
+++ b/crates/adapters/http-axum/src/extractors/path_id.rs
@@ -1,4 +1,3 @@
-use axum::Json;
 use axum::extract::Path;
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
@@ -9,8 +8,11 @@ pub struct PathIdRejection(String);
 
 impl IntoResponse for PathIdRejection {
     fn into_response(self) -> Response {
-        let body = serde_json::json!({ "error": self.0 });
-        (StatusCode::BAD_REQUEST, Json(body)).into_response()
+        crate::errors::refuse(
+            StatusCode::BAD_REQUEST,
+            crate::errors::INVALID_INPUT,
+            self.0,
+        )
     }
 }
 
diff --git a/crates/adapters/http-axum/src/extractors/scoped.rs b/crates/adapters/http-axum/src/extractors/scoped.rs
new file mode 100644
index 0000000..48d7ed8
--- /dev/null
+++ b/crates/adapters/http-axum/src/extractors/scoped.rs
@@ -0,0 +1,99 @@
+use axum::extract::{FromRef, FromRequestParts};
+use axum::http::request::Parts;
+
+use domain::api_token::TokenScope;
+use domain::metric::Source;
+use domain::user::UserId;
+
+use crate::state::AppState;
+
+use super::authentication::{
+    AuthRejection, administrator, session_only, session_or_token_granting,
+};
+
+pub struct SessionUser(pub UserId);
+
+pub struct Administrator(pub UserId);
+
+pub struct JournalReader(pub UserId);
+
+pub struct JournalWriter(pub UserId);
+
+pub struct ProfileReader(pub UserId);
+
+pub struct MetricWriter {
+    pub user_id: UserId,
+    pub source: Source,
+}
+
+impl<S> FromRequestParts<S> for SessionUser
+where
+    S: Send + Sync,
+    AppState: FromRef<S>,
+{
+    type Rejection = AuthRejection;
+
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
+        let state = AppState::from_ref(state);
+
+        Ok(Self(session_only(parts, &state).await?))
+    }
+}
+
+impl<S> FromRequestParts<S> for Administrator
+where
+    S: Send + Sync,
+    AppState: FromRef<S>,
+{
+    type Rejection = AuthRejection;
+
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
+        let state = AppState::from_ref(state);
+
+        Ok(Self(administrator(parts, &state).await?))
+    }
+}
+
+macro_rules! scoped_extractor {
+    ($name:ident, $scope:expr) => {
+        impl<S> FromRequestParts<S> for $name
+        where
+            S: Send + Sync,
+            AppState: FromRef<S>,
+        {
+            type Rejection = AuthRejection;
+
+            async fn from_request_parts(
+                parts: &mut Parts,
+                state: &S,
+            ) -> Result<Self, Self::Rejection> {
+                let state = AppState::from_ref(state);
+                let bearer = session_or_token_granting(parts, &state, $scope).await?;
+
+                Ok(Self(bearer.into_user_id()))
+            }
+        }
+    };
+}
+
+scoped_extractor!(JournalReader, TokenScope::ReadJournal);
+scoped_extractor!(JournalWriter, TokenScope::WriteJournal);
+scoped_extractor!(ProfileReader, TokenScope::ReadProfile);
+
+impl<S> FromRequestParts<S> for MetricWriter
+where
+    S: Send + Sync,
+    AppState: FromRef<S>,
+{
+    type Rejection = AuthRejection;
+
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
+        let state = AppState::from_ref(state);
+        let bearer = session_or_token_granting(parts, &state, TokenScope::WriteMetrics).await?;
+
+        Ok(Self {
+            source: bearer.attributes_writes_to(),
+            user_id: bearer.into_user_id(),
+        })
+    }
+}
diff --git a/crates/adapters/http-axum/src/handlers/activities.rs b/crates/adapters/http-axum/src/handlers/activities.rs
index 1b2217b..5445638 100644
--- a/crates/adapters/http-axum/src/handlers/activities.rs
+++ b/crates/adapters/http-axum/src/handlers/activities.rs
@@ -2,8 +2,9 @@ use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
 
+use api_types::params::ListActivitiesParams;
 use api_types::requests::{CreateActivityRequest, RenameActivityRequest, SetCategoryRequest};
-use api_types::responses::ActivityResponse;
+use api_types::responses::{ActivityResponse, ErrorResponse};
 use application::activity::use_cases::{
     archive_activity, create_activity, delete_activity, get_activity, list_activities,
     rename_activity, set_category,
@@ -11,17 +12,21 @@ use application::activity::use_cases::{
 use domain::activity::ActivityId;
 
 use crate::errors::ApiError;
-use crate::extractors::{AuthenticatedUser, PathId};
+use crate::extractors::{Body, JournalReader, JournalWriter, Params, PathId};
 use crate::state::AppState;
 
 #[utoipa::path(post, path = "/api/v1/activities", tag = "activities", security(("bearer" = [])),
     request_body = CreateActivityRequest,
-    responses((status = 201, body = ActivityResponse))
+    responses((status = 201, body = ActivityResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_create(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Json(body): Json<CreateActivityRequest>,
+    JournalWriter(user_id): JournalWriter,
+    Body(body): Body<CreateActivityRequest>,
 ) -> Result<(StatusCode, Json<ActivityResponse>), ApiError> {
     let cmd = body.into_command(user_id)?;
     let deps = create_activity::Deps {
@@ -34,11 +39,15 @@ pub async fn handle_create(
 
 #[utoipa::path(get, path = "/api/v1/activities/{id}", tag = "activities", security(("bearer" = [])),
     params(("id" = String, Path)),
-    responses((status = 200, body = ActivityResponse))
+    responses((status = 200, body = ActivityResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_get(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalReader(user_id): JournalReader,
     PathId(activity_id): PathId<ActivityId>,
 ) -> Result<Json<ActivityResponse>, ApiError> {
     let deps = get_activity::Deps {
@@ -49,16 +58,28 @@ pub async fn handle_get(
 }
 
 #[utoipa::path(get, path = "/api/v1/activities", tag = "activities", security(("bearer" = [])),
-    responses((status = 200, body = Vec<ActivityResponse>))
+    description = "This account's activity catalogue. Archived activities are left out unless \
+                   `includeArchived` asks for them, because they cannot be tagged onto anything \
+                   new — but they stay listable, so a client can show them and unarchive one.",
+    params(ListActivitiesParams),
+    responses((status = 200, body = Vec<ActivityResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_list(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalReader(user_id): JournalReader,
+    Params(params): Params<ListActivitiesParams>,
 ) -> Result<Json<Vec<ActivityResponse>>, ApiError> {
     let deps = list_activities::Deps {
         query: state.activity_query,
     };
-    let activities = list_activities::active_only(user_id, &deps).await?;
+    let activities = match params.include_archived.unwrap_or(false) {
+        true => list_activities::all(user_id, &deps).await?,
+        false => list_activities::active_only(user_id, &deps).await?,
+    };
     Ok(Json(
         activities.into_iter().map(ActivityResponse::from).collect(),
     ))
@@ -67,13 +88,17 @@ pub async fn handle_list(
 #[utoipa::path(patch, path = "/api/v1/activities/{id}/name", tag = "activities", security(("bearer" = [])),
     params(("id" = String, Path)),
     request_body = RenameActivityRequest,
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_rename(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(activity_id): PathId<ActivityId>,
-    Json(body): Json<RenameActivityRequest>,
+    Body(body): Body<RenameActivityRequest>,
 ) -> Result<StatusCode, ApiError> {
     let cmd = body.into_command(activity_id)?;
     let deps = rename_activity::Deps {
@@ -88,13 +113,17 @@ pub async fn handle_rename(
 #[utoipa::path(patch, path = "/api/v1/activities/{id}/category", tag = "activities", security(("bearer" = [])),
     params(("id" = String, Path)),
     request_body = SetCategoryRequest,
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_set_category(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(activity_id): PathId<ActivityId>,
-    Json(body): Json<SetCategoryRequest>,
+    Body(body): Body<SetCategoryRequest>,
 ) -> Result<StatusCode, ApiError> {
     let cmd = body.into_command(activity_id)?;
     let deps = set_category::Deps {
@@ -107,11 +136,15 @@ pub async fn handle_set_category(
 
 #[utoipa::path(post, path = "/api/v1/activities/{id}/archive", tag = "activities", security(("bearer" = [])),
     params(("id" = String, Path)),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_archive(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(activity_id): PathId<ActivityId>,
 ) -> Result<StatusCode, ApiError> {
     let deps = archive_activity::Deps {
@@ -125,11 +158,15 @@ pub async fn handle_archive(
 
 #[utoipa::path(post, path = "/api/v1/activities/{id}/unarchive", tag = "activities", security(("bearer" = [])),
     params(("id" = String, Path)),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_unarchive(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(activity_id): PathId<ActivityId>,
 ) -> Result<StatusCode, ApiError> {
     let deps = archive_activity::Deps {
@@ -143,14 +180,19 @@ pub async fn handle_unarchive(
 
 #[utoipa::path(delete, path = "/api/v1/activities/{id}", tag = "activities", security(("bearer" = [])),
     params(("id" = String, Path)),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_delete(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(activity_id): PathId<ActivityId>,
 ) -> Result<StatusCode, ApiError> {
     let deps = delete_activity::Deps {
+        entries: state.entry_query.clone(),
         command: state.activity_command,
         query: state.activity_query,
     };
diff --git a/crates/adapters/http-axum/src/handlers/auth.rs b/crates/adapters/http-axum/src/handlers/auth.rs
index f838893..7921c08 100644
--- a/crates/adapters/http-axum/src/handlers/auth.rs
+++ b/crates/adapters/http-axum/src/handlers/auth.rs
@@ -3,20 +3,23 @@ use axum::extract::State;
 use axum::http::StatusCode;
 
 use api_types::requests::LoginRequest;
-use api_types::responses::UserResponse;
+use api_types::responses::{ErrorResponse, RefreshedResponse, SignedInResponse, UserResponse};
 use application::auth::use_cases::{login, logout, refresh};
 
 use crate::errors::ApiError;
+use crate::extractors::Body;
 use crate::state::AppState;
 
 #[utoipa::path(post, path = "/api/v1/auth/login", tag = "auth",
     request_body = LoginRequest,
-    responses((status = 200, description = "Login successful"))
+    responses((status = 200, body = SignedInResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_login(
     State(state): State<AppState>,
-    Json(body): Json<LoginRequest>,
-) -> Result<Json<serde_json::Value>, ApiError> {
+    Body(body): Body<LoginRequest>,
+) -> Result<Json<SignedInResponse>, ApiError> {
     let cmd = body.into_command();
     let deps = login::Deps {
         user_query: state.user_query,
@@ -27,14 +30,13 @@ pub async fn handle_login(
     };
 
     let result = login::execute(cmd, &deps).await?;
-    let user_response = UserResponse::from(result.user);
 
-    Ok(Json(serde_json::json!({
-        "accessToken": result.access_token.token(),
-        "refreshToken": result.refresh_token,
-        "expiresAt": result.access_token.expires_at(),
-        "user": user_response,
-    })))
+    Ok(Json(SignedInResponse {
+        access_token: result.access_token.token().to_string(),
+        refresh_token: result.refresh_token,
+        expires_at: *result.access_token.expires_at(),
+        user: UserResponse::from(result.user),
+    }))
 }
 
 #[derive(serde::Deserialize, utoipa::ToSchema)]
@@ -45,12 +47,14 @@ pub struct RefreshRequest {
 
 #[utoipa::path(post, path = "/api/v1/auth/refresh", tag = "auth",
     request_body = RefreshRequest,
-    responses((status = 200, description = "Token refreshed"))
+    responses((status = 200, body = RefreshedResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_refresh(
     State(state): State<AppState>,
-    Json(body): Json<RefreshRequest>,
-) -> Result<Json<serde_json::Value>, ApiError> {
+    Body(body): Body<RefreshRequest>,
+) -> Result<Json<RefreshedResponse>, ApiError> {
     let deps = refresh::Deps {
         auth_service: state.auth_service,
         refresh_session_command: state.refresh_session_command,
@@ -60,11 +64,11 @@ pub async fn handle_refresh(
 
     let result = refresh::execute(&body.refresh_token, &deps).await?;
 
-    Ok(Json(serde_json::json!({
-        "accessToken": result.access_token.token(),
-        "refreshToken": result.refresh_token,
-        "expiresAt": result.access_token.expires_at(),
-    })))
+    Ok(Json(RefreshedResponse {
+        access_token: result.access_token.token().to_string(),
+        refresh_token: result.refresh_token,
+        expires_at: *result.access_token.expires_at(),
+    }))
 }
 
 #[derive(serde::Deserialize, utoipa::ToSchema)]
@@ -75,11 +79,13 @@ pub struct LogoutRequest {
 
 #[utoipa::path(post, path = "/api/v1/auth/logout", tag = "auth",
     request_body = LogoutRequest,
-    responses((status = 204, description = "Logged out"))
+    responses((status = 204, description = "Logged out"),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_logout(
     State(state): State<AppState>,
-    Json(body): Json<LogoutRequest>,
+    Body(body): Body<LogoutRequest>,
 ) -> Result<StatusCode, ApiError> {
     let deps = logout::Deps {
         refresh_session_command: state.refresh_session_command,
diff --git a/crates/adapters/http-axum/src/handlers/correlations.rs b/crates/adapters/http-axum/src/handlers/correlations.rs
index 0a58b35..3ebcfb0 100644
--- a/crates/adapters/http-axum/src/handlers/correlations.rs
+++ b/crates/adapters/http-axum/src/handlers/correlations.rs
@@ -1,13 +1,13 @@
 use axum::Json;
-use axum::extract::{Query, State};
+use axum::extract::State;
 
-use api_types::requests::DateSpanParams;
-use api_types::responses::CorrelationRowResponse;
+use api_types::params::DateSpanParams;
+use api_types::responses::{CorrelationRowResponse, ErrorResponse};
 use application::correlation::queries::CorrelationQuery;
 use application::correlation::use_cases::get_correlations;
 
 use crate::errors::ApiError;
-use crate::extractors::AuthenticatedUser;
+use crate::extractors::{JournalReader, Params};
 use crate::state::AppState;
 
 #[utoipa::path(get, path = "/api/v1/correlations", tag = "correlations", security(("bearer" = [])),
@@ -18,12 +18,16 @@ use crate::state::AppState;
                    never ranked by strength. Below the configured minimum sample size a row \
                    carries its day count and no coefficient.",
     params(DateSpanParams),
-    responses((status = 200, body = Vec<CorrelationRowResponse>))
+    responses((status = 200, body = Vec<CorrelationRowResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_list(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Query(params): Query<DateSpanParams>,
+    JournalReader(user_id): JournalReader,
+    Params(params): Params<DateSpanParams>,
 ) -> Result<Json<Vec<CorrelationRowResponse>>, ApiError> {
     let span = params.into_span()?;
 
@@ -33,6 +37,7 @@ pub async fn handle_list(
         activities: state.activity_query,
         cycles: state.cycle_query,
         weather_store: state.weather_store,
+        activity_store: state.activity_store,
         preferences: state.preferences_query,
         users: state.user_query,
     };
diff --git a/crates/adapters/http-axum/src/handlers/cycle.rs b/crates/adapters/http-axum/src/handlers/cycle.rs
index 8e62fd0..f6ff96b 100644
--- a/crates/adapters/http-axum/src/handlers/cycle.rs
+++ b/crates/adapters/http-axum/src/handlers/cycle.rs
@@ -4,23 +4,27 @@ use axum::http::StatusCode;
 
 use api_types::mappers::parse_date;
 use api_types::requests::SetPreferencesRequest;
-use api_types::responses::{CycleViewResponse, PreferencesResponse};
+use api_types::responses::{CycleViewResponse, ErrorResponse, PreferencesResponse};
 use application::cycle::use_cases::{forget_cycle_start, read_cycle, record_cycle_start};
 use application::user::use_cases::set_preferences;
 
 use crate::errors::ApiError;
-use crate::extractors::AuthenticatedUser;
+use crate::extractors::{Body, JournalReader, JournalWriter, ProfileReader, SessionUser};
 use crate::state::AppState;
 
 #[utoipa::path(get, path = "/api/v1/cycle", tag = "cycle", security(("bearer" = [])),
     description = "The recorded cycle starts and the cycle day derived for today. Cycle day is \
                    never stored: correcting a start corrects every day that depended on it. \
                    Returns nothing at all while cycle tracking is off.",
-    responses((status = 200, body = CycleViewResponse))
+    responses((status = 200, body = CycleViewResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_read(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalReader(user_id): JournalReader,
 ) -> Result<Json<CycleViewResponse>, ApiError> {
     let deps = read_cycle::Deps {
         query: state.cycle_query,
@@ -37,11 +41,15 @@ pub async fn handle_read(
     description = "Records that a cycle began on this date. Recording the same date twice \
                    records it once.",
     params(("date" = String, Path, description = "Calendar date, as YYYY-MM-DD")),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_record(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     Path(date): Path<String>,
 ) -> Result<StatusCode, ApiError> {
     let deps = record_cycle_start::Deps {
@@ -58,11 +66,15 @@ pub async fn handle_record(
     description = "Forgets a recorded start. Every day that derived its cycle day from it \
                    changes at once.",
     params(("date" = String, Path, description = "Calendar date, as YYYY-MM-DD")),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_forget(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     Path(date): Path<String>,
 ) -> Result<StatusCode, ApiError> {
     let deps = forget_cycle_start::Deps {
@@ -78,12 +90,16 @@ pub async fn handle_forget(
     description = "Turns optional features on or off. Cycle tracking is off until turned on, \
                    and turning it off hides the cycle without forgetting what was recorded.",
     request_body = SetPreferencesRequest,
-    responses((status = 200, body = PreferencesResponse))
+    responses((status = 200, body = PreferencesResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_set_preferences(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Json(body): Json<SetPreferencesRequest>,
+    SessionUser(user_id): SessionUser,
+    Body(body): Body<SetPreferencesRequest>,
 ) -> Result<Json<PreferencesResponse>, ApiError> {
     let deps = set_preferences::Deps {
         command: state.preferences_command,
@@ -96,11 +112,15 @@ pub async fn handle_set_preferences(
 }
 
 #[utoipa::path(get, path = "/api/v1/users/me/preferences", tag = "users", security(("bearer" = [])),
-    responses((status = 200, body = PreferencesResponse))
+    responses((status = 200, body = PreferencesResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_preferences(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    ProfileReader(user_id): ProfileReader,
 ) -> Result<Json<PreferencesResponse>, ApiError> {
     let preferences =
         application::user::preferences::preferences_of(&user_id, &state.preferences_query).await?;
diff --git a/crates/adapters/http-axum/src/handlers/data.rs b/crates/adapters/http-axum/src/handlers/data.rs
index edc9ae6..ad0de70 100644
--- a/crates/adapters/http-axum/src/handlers/data.rs
+++ b/crates/adapters/http-axum/src/handlers/data.rs
@@ -3,13 +3,13 @@ use axum::extract::{Multipart, State};
 use axum::http::{StatusCode, header};
 use axum::response::IntoResponse;
 
-use api_types::responses::RestoreOutcomeResponse;
+use api_types::responses::{ErrorResponse, RestoreOutcomeResponse};
 use application::export::use_cases::{write_backup, write_extract};
 use application::restore::commands::RestoreBackupCommand;
 use application::restore::use_cases::restore_backup;
 
 use crate::errors::ApiError;
-use crate::extractors::{AuthenticatedUser, extract_file_bytes};
+use crate::extractors::{SessionUser, extract_file_bytes};
 use crate::state::AppState;
 
 const BACKUP_FILENAME: &str = "k-mood-complete-backup.zip";
@@ -20,11 +20,15 @@ const EXTRACT_FILENAME: &str = "k-mood-shareable-journal.md";
                    every cycle start, the activity catalogue, reminders, preferences and all \
                    media. Restores through /data/restore. Keep it private — it holds everything \
                    the account knows.",
-    responses((status = 200, description = "A zip archive", content_type = "application/zip"))
+    responses((status = 200, description = "A zip archive", content_type = "application/zip"),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_backup(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
 ) -> Result<impl IntoResponse, ApiError> {
     let deps = write_backup::Deps {
         entries: state.entry_query,
@@ -48,11 +52,15 @@ pub async fn handle_backup(
                    readable markdown document. It carries no places, no health readings, no \
                    cycle records and no media, and it cannot be restored from. This is the one \
                    to hand to someone.",
-    responses((status = 200, description = "A markdown document", content_type = "text/markdown"))
+    responses((status = 200, description = "A markdown document", content_type = "text/markdown"),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_extract(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
 ) -> Result<impl IntoResponse, ApiError> {
     let deps = write_extract::Deps {
         entries: state.entry_query,
@@ -74,16 +82,23 @@ pub async fn handle_extract(
     description = "Restores a complete backup into this account. Existing data is kept: a \
                    restore adds, it does not replace. Anything in the archive this build cannot \
                    read is reported rather than silently dropped.",
-    responses((status = 200, body = RestoreOutcomeResponse))
+    responses((status = 200, body = RestoreOutcomeResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_restore(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
     multipart: Multipart,
 ) -> Result<Json<RestoreOutcomeResponse>, ApiError> {
     let data = extract_file_bytes(multipart).await?;
 
     let deps = restore_backup::Deps {
+        entry_query: state.entry_query.clone(),
+        reminder_query: state.reminder_query.clone(),
+        media_ownership: state.media_ownership.clone(),
         reader: state.backup_reader,
         entry_command: state.entry_command,
         dimensions: state.dimensions,
diff --git a/crates/adapters/http-axum/src/handlers/entries.rs b/crates/adapters/http-axum/src/handlers/entries.rs
index 9d68071..6a48d45 100644
--- a/crates/adapters/http-axum/src/handlers/entries.rs
+++ b/crates/adapters/http-axum/src/handlers/entries.rs
@@ -1,26 +1,25 @@
 use axum::Json;
-use axum::extract::{Path, Query, State};
+use axum::extract::{Path, State};
 use axum::http::StatusCode;
 
+use api_types::params::{DateRangeParams, ListEntriesParams};
 use api_types::requests::{
-    CreateEntryRequest, DateRangeParams, ListEntriesParams, ReplaceActivityRequest,
-    UpdateEntryRequest,
+    CreateEntriesRequest, CreateEntryRequest, ReplaceActivityRequest, UpdateEntryRequest,
 };
 use api_types::responses::{
-    BulkActionResponse, CalendarDayResponse, EntryResponse, MoodStatsResponse,
+    BulkActionResponse, CalendarDayResponse, EntryPageResponse, EntryResponse, ErrorResponse,
+    MoodStatsResponse,
 };
 use application::entry::composition::EntryComposer;
-use application::entry::queries::{FilterByActivityQuery, FilterByMoodQuery, MoodStatsQuery};
+use application::entry::queries::MoodStatsQuery;
 use application::entry::use_cases::{
-    create_entry, delete_entries_by_date_range, delete_entry, filter_by_activity, filter_by_mood,
-    get_calendar, get_entry, get_mood_stats, list_entries, replace_activity, update_entry,
+    create_entries, create_entry, delete_entries_by_date_range, delete_entry, get_calendar,
+    get_entry, get_mood_stats, list_entries, replace_activity, update_entry,
 };
-use domain::activity::ActivityId;
-use domain::entry::MoodEntry;
-use domain::entry::{Mood, MoodEntryId};
+use domain::entry::{MoodEntry, MoodEntryId, Page};
 
 use crate::errors::ApiError;
-use crate::extractors::{AuthenticatedUser, PathId};
+use crate::extractors::{Body, JournalReader, JournalWriter, Params, PathId};
 use crate::state::AppState;
 
 async fn compose(
@@ -31,6 +30,24 @@ async fn compose(
     Ok(composed.into_iter().map(EntryResponse::from).collect())
 }
 
+async fn composed_page(
+    dimensions: Vec<std::sync::Arc<dyn domain::ports::EntryDimensionPort>>,
+    page: Page<MoodEntry>,
+) -> Result<EntryPageResponse, ApiError> {
+    let total = page.total();
+    let limit = page.limit();
+    let offset = page.offset();
+    let has_more = page.more_after_this();
+
+    Ok(EntryPageResponse {
+        items: compose(dimensions, page.into_items()).await?,
+        total,
+        limit,
+        offset,
+        has_more,
+    })
+}
+
 async fn compose_one(
     dimensions: Vec<std::sync::Arc<dyn domain::ports::EntryDimensionPort>>,
     entry: MoodEntry,
@@ -41,16 +58,21 @@ async fn compose_one(
 
 #[utoipa::path(post, path = "/api/v1/entries", tag = "entries", security(("bearer" = [])),
     request_body = CreateEntryRequest,
-    responses((status = 201, body = EntryResponse))
+    responses((status = 201, body = EntryResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_create(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Json(body): Json<CreateEntryRequest>,
+    JournalWriter(user_id): JournalWriter,
+    Body(body): Body<CreateEntryRequest>,
 ) -> Result<(StatusCode, Json<EntryResponse>), ApiError> {
     let cmd = body.into_command(user_id, &state.entry_config)?;
     let dimensions = state.dimensions.clone();
     let deps = create_entry::Deps {
+        activities: state.activity_query.clone(),
         entries: state.entry_command,
         dimensions: state.dimensions.clone(),
         events: state.event_publisher,
@@ -62,13 +84,55 @@ pub async fn handle_create(
     ))
 }
 
+#[utoipa::path(post, path = "/api/v1/entries/bulk", tag = "entries", security(("bearer" = [])),
+    description = "Creates many entries in one request, for a client syncing what it collected \
+                   while offline. Either every entry is written or none is: one activity the \
+                   account does not own refuses the whole batch.",
+    request_body = CreateEntriesRequest,
+    responses((status = 201, body = Vec<EntryResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
+)]
+pub async fn handle_create_many(
+    State(state): State<AppState>,
+    JournalWriter(user_id): JournalWriter,
+    Body(body): Body<CreateEntriesRequest>,
+) -> Result<(StatusCode, Json<Vec<EntryResponse>>), ApiError> {
+    let wanted = body
+        .entries
+        .into_iter()
+        .map(|one| one.into_command(user_id.clone(), &state.entry_config))
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let dimensions = state.dimensions.clone();
+    let deps = create_entries::Deps {
+        entries: state.entry_command,
+        dimensions: state.dimensions.clone(),
+        activities: state.activity_query.clone(),
+        events: state.event_publisher,
+    };
+
+    let created = create_entries::execute(user_id, wanted, &deps).await?;
+
+    Ok((
+        StatusCode::CREATED,
+        Json(compose(dimensions, created).await?),
+    ))
+}
+
 #[utoipa::path(get, path = "/api/v1/entries/{id}", tag = "entries", security(("bearer" = [])),
     params(("id" = String, Path, description = "Entry ID")),
-    responses((status = 200, body = EntryResponse))
+    responses((status = 200, body = EntryResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_get(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalReader(user_id): JournalReader,
     PathId(entry_id): PathId<MoodEntryId>,
 ) -> Result<Json<EntryResponse>, ApiError> {
     let dimensions = state.dimensions.clone();
@@ -81,36 +145,52 @@ pub async fn handle_get(
 
 #[utoipa::path(get, path = "/api/v1/entries", tag = "entries", security(("bearer" = [])),
     params(ListEntriesParams),
-    responses((status = 200, body = Vec<EntryResponse>))
+    description = "One page of entries, newest first, narrowed by any combination of the \
+                   parameters. `total` counts everything the selection matches, not the page, \
+                   so a client can page with confidence. `updatedSince` returns only entries \
+                   changed after that instant, which is what a polling client should use rather \
+                   than refetching the journal.",
+    responses((status = 200, body = EntryPageResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_list(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Query(params): Query<ListEntriesParams>,
-) -> Result<Json<Vec<EntryResponse>>, ApiError> {
-    let query = params.into_query(user_id)?;
+    JournalReader(user_id): JournalReader,
+    Params(params): Params<ListEntriesParams>,
+) -> Result<Json<EntryPageResponse>, ApiError> {
+    let query = params.into_query(user_id, &state.entry_config)?;
     let dimensions = state.dimensions.clone();
     let deps = list_entries::Deps {
         query: state.entry_query,
     };
-    let entries = list_entries::execute(query, &deps).await?;
-    Ok(Json(compose(dimensions, entries).await?))
+
+    let page = list_entries::execute(query, &deps).await?;
+
+    Ok(Json(composed_page(dimensions, page).await?))
 }
 
 #[utoipa::path(patch, path = "/api/v1/entries/{id}", tag = "entries", security(("bearer" = [])),
     params(("id" = String, Path, description = "Entry ID")),
     request_body = UpdateEntryRequest,
-    responses((status = 200, body = EntryResponse))
+    responses((status = 200, body = EntryResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_update(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(entry_id): PathId<MoodEntryId>,
-    Json(body): Json<UpdateEntryRequest>,
+    Body(body): Body<UpdateEntryRequest>,
 ) -> Result<Json<EntryResponse>, ApiError> {
     let cmd = body.into_command(entry_id, &state.entry_config)?;
     let dimensions = state.dimensions.clone();
     let deps = update_entry::Deps {
+        activities: state.activity_query.clone(),
         command: state.entry_command,
         dimensions: state.dimensions.clone(),
         query: state.entry_query,
@@ -123,11 +203,15 @@ pub async fn handle_update(
 
 #[utoipa::path(delete, path = "/api/v1/entries/{id}", tag = "entries", security(("bearer" = [])),
     params(("id" = String, Path, description = "Entry ID")),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_delete(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(entry_id): PathId<MoodEntryId>,
 ) -> Result<StatusCode, ApiError> {
     let deps = delete_entry::Deps {
@@ -142,53 +226,65 @@ pub async fn handle_delete(
 }
 
 #[utoipa::path(get, path = "/api/v1/entries/filter/mood/{mood}", tag = "entries", security(("bearer" = [])),
-    params(("mood" = u8, Path, description = "Mood value 1-5")),
-    responses((status = 200, body = Vec<EntryResponse>))
+    description = "A page of entries of one mood. The same selection is available on \
+                   GET /entries as the `mood` parameter, alongside every other narrowing.",
+    params(("mood" = u8, Path, description = "Mood value 1-5"), ListEntriesParams),
+    responses((status = 200, body = EntryPageResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_filter_by_mood(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    reader: JournalReader,
     Path(mood): Path<u8>,
-) -> Result<Json<Vec<EntryResponse>>, ApiError> {
-    let mood = Mood::try_from(mood)?;
-    let query = FilterByMoodQuery { user_id, mood };
-    let dimensions = state.dimensions.clone();
-    let deps = filter_by_mood::Deps {
-        query: state.entry_query,
+    Params(params): Params<ListEntriesParams>,
+) -> Result<Json<EntryPageResponse>, ApiError> {
+    let narrowed = ListEntriesParams {
+        mood: Some(mood),
+        ..params
     };
-    let entries = filter_by_mood::execute(query, &deps).await?;
-    Ok(Json(compose(dimensions, entries).await?))
+
+    handle_list(State(state), reader, Params(narrowed)).await
 }
 
 #[utoipa::path(get, path = "/api/v1/entries/filter/activity/{id}", tag = "entries", security(("bearer" = [])),
-    params(("id" = String, Path, description = "Activity ID")),
-    responses((status = 200, body = Vec<EntryResponse>))
+    description = "A page of entries tagged with one activity. The same selection is available \
+                   on GET /entries as the `activity` parameter.",
+    params(("id" = String, Path, description = "Activity ID"), ListEntriesParams),
+    responses((status = 200, body = EntryPageResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_filter_by_activity(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    PathId(activity_id): PathId<ActivityId>,
-) -> Result<Json<Vec<EntryResponse>>, ApiError> {
-    let query = FilterByActivityQuery {
-        user_id,
-        activity_id,
+    reader: JournalReader,
+    Path(activity_id): Path<String>,
+    Params(params): Params<ListEntriesParams>,
+) -> Result<Json<EntryPageResponse>, ApiError> {
+    let narrowed = ListEntriesParams {
+        activity: Some(activity_id),
+        ..params
     };
-    let dimensions = state.dimensions.clone();
-    let deps = filter_by_activity::Deps {
-        query: state.entry_query,
-    };
-    let entries = filter_by_activity::execute(query, &deps).await?;
-    Ok(Json(compose(dimensions, entries).await?))
+
+    handle_list(State(state), reader, Params(narrowed)).await
 }
 
 #[utoipa::path(get, path = "/api/v1/entries/stats", tag = "entries", security(("bearer" = [])),
     params(ListEntriesParams),
-    responses((status = 200, body = MoodStatsResponse))
+    responses((status = 200, body = MoodStatsResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_stats(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Query(params): Query<ListEntriesParams>,
+    JournalReader(user_id): JournalReader,
+    Params(params): Params<ListEntriesParams>,
 ) -> Result<Json<MoodStatsResponse>, ApiError> {
     let range = match (params.from, params.to) {
         (Some(from), Some(to)) => {
@@ -209,12 +305,16 @@ pub async fn handle_stats(
 
 #[utoipa::path(get, path = "/api/v1/entries/calendar", tag = "entries", security(("bearer" = [])),
     params(DateRangeParams),
-    responses((status = 200, body = Vec<CalendarDayResponse>))
+    responses((status = 200, body = Vec<CalendarDayResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_calendar(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Query(params): Query<DateRangeParams>,
+    JournalReader(user_id): JournalReader,
+    Params(params): Params<DateRangeParams>,
 ) -> Result<Json<Vec<CalendarDayResponse>>, ApiError> {
     let range = params.into_date_range()?;
     let deps = get_calendar::Deps {
@@ -232,12 +332,16 @@ pub async fn handle_calendar(
 
 #[utoipa::path(delete, path = "/api/v1/entries/bulk/delete", tag = "entries", security(("bearer" = [])),
     params(DateRangeParams),
-    responses((status = 200, body = BulkActionResponse))
+    responses((status = 200, body = BulkActionResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_delete_by_date_range(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Query(params): Query<DateRangeParams>,
+    JournalWriter(user_id): JournalWriter,
+    Params(params): Params<DateRangeParams>,
 ) -> Result<Json<BulkActionResponse>, ApiError> {
     let range = params.into_date_range()?;
     let deps = delete_entries_by_date_range::Deps {
@@ -252,12 +356,16 @@ pub async fn handle_delete_by_date_range(
 
 #[utoipa::path(post, path = "/api/v1/entries/bulk/replace-activity", tag = "entries", security(("bearer" = [])),
     request_body = ReplaceActivityRequest,
-    responses((status = 200, body = BulkActionResponse))
+    responses((status = 200, body = BulkActionResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_replace_activity(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Json(body): Json<ReplaceActivityRequest>,
+    JournalWriter(user_id): JournalWriter,
+    Body(body): Body<ReplaceActivityRequest>,
 ) -> Result<Json<BulkActionResponse>, ApiError> {
     let (user_id, old_id, new_id) = body.into_parts(user_id)?;
     let deps = replace_activity::Deps {
diff --git a/crates/adapters/http-axum/src/handlers/import_export.rs b/crates/adapters/http-axum/src/handlers/import_export.rs
index b910814..140498d 100644
--- a/crates/adapters/http-axum/src/handlers/import_export.rs
+++ b/crates/adapters/http-axum/src/handlers/import_export.rs
@@ -1,20 +1,24 @@
 use axum::Json;
 use axum::extract::{Multipart, State};
 
-use api_types::responses::ImportResultResponse;
+use api_types::responses::{ErrorResponse, ImportResultResponse};
 use application::import::commands::ImportCommand;
 use application::import::use_cases::import_entries;
 
 use crate::errors::ApiError;
-use crate::extractors::{AuthenticatedUser, extract_file_bytes};
+use crate::extractors::{SessionUser, extract_file_bytes};
 use crate::state::AppState;
 
 #[utoipa::path(post, path = "/api/v1/data/import", tag = "data", security(("bearer" = [])),
-    responses((status = 200, body = ImportResultResponse))
+    responses((status = 200, body = ImportResultResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_import(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
     multipart: Multipart,
 ) -> Result<Json<ImportResultResponse>, ApiError> {
     let data = extract_file_bytes(multipart).await?;
diff --git a/crates/adapters/http-axum/src/handlers/jobs.rs b/crates/adapters/http-axum/src/handlers/jobs.rs
new file mode 100644
index 0000000..be83284
--- /dev/null
+++ b/crates/adapters/http-axum/src/handlers/jobs.rs
@@ -0,0 +1,35 @@
+use axum::Json;
+use axum::extract::State;
+
+use api_types::responses::{ErrorResponse, ExhaustedJobResponse};
+use application::job::use_cases::list_exhausted_jobs;
+
+use crate::errors::ApiError;
+use crate::extractors::Administrator;
+use crate::state::AppState;
+
+const MOST_SHOWN: usize = 100;
+
+#[utoipa::path(get, path = "/api/v1/jobs/exhausted", tag = "jobs", security(("bearer" = [])),
+    description = "Background work that used every attempt and stopped being retried, with the \
+                   reason the last attempt failed. Losing a job costs promptness and never data, \
+                   so this is an operator's view of what is stale rather than what is missing. \
+                   Needs an administrator's session.",
+    responses((status = 200, body = Vec<ExhaustedJobResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
+)]
+pub async fn handle_list_exhausted(
+    State(state): State<AppState>,
+    Administrator(_who): Administrator,
+) -> Result<Json<Vec<ExhaustedJobResponse>>, ApiError> {
+    let deps = list_exhausted_jobs::Deps {
+        jobs: state.job_view,
+    };
+
+    let stalled = list_exhausted_jobs::execute(MOST_SHOWN, &deps).await?;
+
+    Ok(Json(stalled.into_iter().map(Into::into).collect()))
+}
diff --git a/crates/adapters/http-axum/src/handlers/media.rs b/crates/adapters/http-axum/src/handlers/media.rs
index d38c8a4..aec3fbd 100644
--- a/crates/adapters/http-axum/src/handlers/media.rs
+++ b/crates/adapters/http-axum/src/handlers/media.rs
@@ -3,55 +3,89 @@ use axum::extract::{Multipart, State};
 use axum::http::{StatusCode, header};
 use axum::response::IntoResponse;
 
-use api_types::responses::MediaIdResponse;
+use api_types::responses::{ErrorResponse, MediaIdResponse, OwnedMediaResponse};
 use application::media::use_cases::{
-    delete_photo, delete_voice_memo, upload_photo, upload_voice_memo,
+    delete_photo, delete_voice_memo, list_media, upload_photo, upload_voice_memo,
 };
 use domain::attachment::{PhotoId, VoiceMemoId};
 use domain::errors::DomainError;
 
 use crate::errors::ApiError;
-use crate::extractors::{AuthenticatedUser, PathId, extract_media_upload};
+use crate::extractors::{JournalReader, JournalWriter, PathId, extract_media_upload};
 use crate::state::AppState;
 
 #[utoipa::path(post, path = "/api/v1/media/photos", tag = "media", security(("bearer" = [])),
-    responses((status = 201, body = MediaIdResponse))
+    responses((status = 201, body = MediaIdResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_upload_photo(
     State(state): State<AppState>,
-    AuthenticatedUser(_user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     multipart: Multipart,
 ) -> Result<(StatusCode, Json<MediaIdResponse>), ApiError> {
     let upload = extract_media_upload(multipart).await?;
     let deps = upload_photo::Deps {
         storage: state.media_storage,
+        ownership: state.media_ownership,
     };
-    let photo_id = upload_photo::execute(upload, &deps).await?;
+    let photo_id = upload_photo::execute(user_id, upload, &deps).await?;
     Ok((StatusCode::CREATED, Json(MediaIdResponse::from(photo_id))))
 }
 
 #[utoipa::path(post, path = "/api/v1/media/voice-memos", tag = "media", security(("bearer" = [])),
-    responses((status = 201, body = MediaIdResponse))
+    responses((status = 201, body = MediaIdResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_upload_voice_memo(
     State(state): State<AppState>,
-    AuthenticatedUser(_user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     multipart: Multipart,
 ) -> Result<(StatusCode, Json<MediaIdResponse>), ApiError> {
     let upload = extract_media_upload(multipart).await?;
     let deps = upload_voice_memo::Deps {
         storage: state.media_storage,
+        ownership: state.media_ownership,
     };
-    let voice_memo_id = upload_voice_memo::execute(upload, &deps).await?;
+    let voice_memo_id = upload_voice_memo::execute(user_id, upload, &deps).await?;
     Ok((
         StatusCode::CREATED,
         Json(MediaIdResponse::from(voice_memo_id)),
     ))
 }
 
+#[utoipa::path(get, path = "/api/v1/media", tag = "media", security(("bearer" = [])),
+    description = "Every photo and voice memo this account owns, including any uploaded but \
+                   never attached to an entry, each with the url it is served from.",
+    responses((status = 200, body = Vec<OwnedMediaResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
+)]
+pub async fn handle_list(
+    State(state): State<AppState>,
+    JournalReader(user_id): JournalReader,
+) -> Result<Json<Vec<OwnedMediaResponse>>, ApiError> {
+    let deps = list_media::Deps {
+        ownership: state.media_ownership,
+    };
+
+    let held = list_media::execute(user_id, &deps).await?;
+
+    Ok(Json(held.into_iter().map(Into::into).collect()))
+}
+
 #[utoipa::path(get, path = "/api/v1/media/photos/{id}", tag = "media",
     params(("id" = String, Path)),
-    responses((status = 200, description = "Photo binary"))
+    responses((status = 200, description = "Photo binary"),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_serve_photo(
     State(state): State<AppState>,
@@ -71,7 +105,9 @@ pub async fn handle_serve_photo(
 
 #[utoipa::path(get, path = "/api/v1/media/voice-memos/{id}", tag = "media",
     params(("id" = String, Path)),
-    responses((status = 200, description = "Voice memo binary"))
+    responses((status = 200, description = "Voice memo binary"),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_serve_voice_memo(
     State(state): State<AppState>,
@@ -91,32 +127,42 @@ pub async fn handle_serve_voice_memo(
 
 #[utoipa::path(delete, path = "/api/v1/media/photos/{id}", tag = "media", security(("bearer" = [])),
     params(("id" = String, Path)),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_delete_photo(
     State(state): State<AppState>,
-    AuthenticatedUser(_user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(photo_id): PathId<PhotoId>,
 ) -> Result<StatusCode, ApiError> {
     let deps = delete_photo::Deps {
         storage: state.media_storage,
+        ownership: state.media_ownership,
     };
-    delete_photo::execute(photo_id, &deps).await?;
+    delete_photo::execute(photo_id, user_id, &deps).await?;
     Ok(StatusCode::NO_CONTENT)
 }
 
 #[utoipa::path(delete, path = "/api/v1/media/voice-memos/{id}", tag = "media", security(("bearer" = [])),
     params(("id" = String, Path)),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_delete_voice_memo(
     State(state): State<AppState>,
-    AuthenticatedUser(_user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(voice_memo_id): PathId<VoiceMemoId>,
 ) -> Result<StatusCode, ApiError> {
     let deps = delete_voice_memo::Deps {
         storage: state.media_storage,
+        ownership: state.media_ownership,
     };
-    delete_voice_memo::execute(voice_memo_id, &deps).await?;
+    delete_voice_memo::execute(voice_memo_id, user_id, &deps).await?;
     Ok(StatusCode::NO_CONTENT)
 }
diff --git a/crates/adapters/http-axum/src/handlers/metrics.rs b/crates/adapters/http-axum/src/handlers/metrics.rs
index 967459d..64e357c 100644
--- a/crates/adapters/http-axum/src/handlers/metrics.rs
+++ b/crates/adapters/http-axum/src/handlers/metrics.rs
@@ -1,27 +1,34 @@
 use axum::Json;
-use axum::extract::{Path, Query, State};
+use axum::extract::{Path, State};
 use axum::http::StatusCode;
 
 use api_types::mappers::parse_date;
-use api_types::requests::{DateSpanParams, ImportDailyMetricsRequest, SetDailyMetricsRequest};
-use api_types::responses::{DailyMetricResponse, ImportOutcomeResponse, RejectionResponse};
+use api_types::params::DateSpanParams;
+use api_types::requests::{ImportDailyMetricsRequest, SetDailyMetricsRequest};
+use api_types::responses::{
+    DailyMetricResponse, ErrorResponse, ImportOutcomeResponse, RejectionResponse,
+};
 use application::import::commands::ImportDailyMetricsCommand;
 use application::import::use_cases::import_daily_metrics;
 use application::metric::commands::SetDailyMetricsCommand;
-use application::metric::use_cases::{list_daily_metrics, set_daily_metrics};
+use application::metric::use_cases::{list_daily_metrics, list_rejections, set_daily_metrics};
 
 use crate::errors::ApiError;
-use crate::extractors::{AuthenticatedUser, ImportingProvider, MetricWriter};
+use crate::extractors::{Body, ImportingProvider, JournalReader, MetricWriter, Params};
 use crate::state::AppState;
 
 #[utoipa::path(get, path = "/api/v1/metrics", tag = "metrics", security(("bearer" = [])),
     params(DateSpanParams),
-    responses((status = 200, body = Vec<DailyMetricResponse>))
+    responses((status = 200, body = Vec<DailyMetricResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_list(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Query(params): Query<DateSpanParams>,
+    JournalReader(user_id): JournalReader,
+    Params(params): Params<DateSpanParams>,
 ) -> Result<Json<Vec<DailyMetricResponse>>, ApiError> {
     let span = params.into_span()?;
 
@@ -40,13 +47,17 @@ pub async fn handle_list(
                    only once per request.",
     params(("date" = String, Path, description = "Calendar date, as YYYY-MM-DD")),
     request_body = SetDailyMetricsRequest,
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_set(
     State(state): State<AppState>,
     writer: MetricWriter,
     Path(date): Path<String>,
-    Json(body): Json<SetDailyMetricsRequest>,
+    Body(body): Body<SetDailyMetricsRequest>,
 ) -> Result<StatusCode, ApiError> {
     let date = parse_date(&date)?;
 
@@ -85,12 +96,16 @@ pub async fn handle_set(
                    rejection. Only a payload carrying more days than the configured limit is \
                    refused outright.",
     request_body = ImportDailyMetricsRequest,
-    responses((status = 200, body = ImportOutcomeResponse))
+    responses((status = 200, body = ImportOutcomeResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_import(
     State(state): State<AppState>,
     importer: ImportingProvider,
-    Json(body): Json<ImportDailyMetricsRequest>,
+    Body(body): Body<ImportDailyMetricsRequest>,
 ) -> Result<Json<ImportOutcomeResponse>, ApiError> {
     let deps = import_daily_metrics::Deps {
         metrics: state.daily_metric_command,
@@ -115,13 +130,21 @@ pub async fn handle_import(
     description = "Readings that could not be used, most recent first, whether they arrived \
                    broken from an importer or were stored by an older build and can no longer be \
                    read. Only the most recent are kept.",
-    responses((status = 200, body = Vec<RejectionResponse>))
+    responses((status = 200, body = Vec<RejectionResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_rejections(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalReader(user_id): JournalReader,
 ) -> Result<Json<Vec<RejectionResponse>>, ApiError> {
-    let rejections = state.rejection_query.find_recent_by_user(&user_id).await?;
+    let deps = list_rejections::Deps {
+        rejections: state.rejection_query,
+    };
+
+    let rejections = list_rejections::execute(user_id, &deps).await?;
 
     Ok(Json(rejections.into_iter().map(Into::into).collect()))
 }
diff --git a/crates/adapters/http-axum/src/handlers/mod.rs b/crates/adapters/http-axum/src/handlers/mod.rs
index 39dcd30..d46e2a3 100644
--- a/crates/adapters/http-axum/src/handlers/mod.rs
+++ b/crates/adapters/http-axum/src/handlers/mod.rs
@@ -5,10 +5,12 @@ pub mod cycle;
 pub mod data;
 pub mod entries;
 pub mod import_export;
+pub mod jobs;
 pub mod media;
 pub mod metrics;
 pub mod providers;
 pub mod push;
 pub mod reminders;
+pub mod server;
 pub mod tokens;
 pub mod users;
diff --git a/crates/adapters/http-axum/src/handlers/providers.rs b/crates/adapters/http-axum/src/handlers/providers.rs
index 6e7e876..eb540f4 100644
--- a/crates/adapters/http-axum/src/handlers/providers.rs
+++ b/crates/adapters/http-axum/src/handlers/providers.rs
@@ -4,7 +4,7 @@ use axum::http::StatusCode;
 
 use api_types::dimension::DimensionPayload;
 use api_types::requests::ConnectProviderRequest;
-use api_types::responses::ProviderConnectionResponse;
+use api_types::responses::{ErrorResponse, ProviderConnectionResponse};
 use application::provider::commands::ConnectProviderCommand;
 use application::provider::use_cases::{
     connect_provider, disconnect_provider, get_now_playing, list_connections,
@@ -14,7 +14,7 @@ use domain::errors::DomainError;
 use domain::provider::ProviderName;
 
 use crate::errors::ApiError;
-use crate::extractors::AuthenticatedUser;
+use crate::extractors::{Body, JournalReader, ProfileReader, SessionUser};
 use crate::state::AppState;
 
 fn cipher(
@@ -30,11 +30,15 @@ fn cipher(
 }
 
 #[utoipa::path(get, path = "/api/v1/providers", tag = "providers", security(("bearer" = [])),
-    responses((status = 200, body = Vec<ProviderConnectionResponse>))
+    responses((status = 200, body = Vec<ProviderConnectionResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_list(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    ProfileReader(user_id): ProfileReader,
 ) -> Result<Json<Vec<ProviderConnectionResponse>>, ApiError> {
     let deps = list_connections::Deps {
         query: state.provider_connection_query,
@@ -47,13 +51,17 @@ pub async fn handle_list(
 #[utoipa::path(put, path = "/api/v1/providers/{provider}", tag = "providers", security(("bearer" = [])),
     params(("provider" = String, Path, description = "Provider name")),
     request_body = ConnectProviderRequest,
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_connect(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
     Path(provider): Path<String>,
-    Json(body): Json<ConnectProviderRequest>,
+    Body(body): Body<ConnectProviderRequest>,
 ) -> Result<StatusCode, ApiError> {
     let cipher = cipher(&state)?;
     let provider = ProviderName::new(provider)?;
@@ -81,11 +89,15 @@ pub async fn handle_connect(
 
 #[utoipa::path(delete, path = "/api/v1/providers/{provider}", tag = "providers", security(("bearer" = [])),
     params(("provider" = String, Path, description = "Provider name")),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_disconnect(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
     Path(provider): Path<String>,
 ) -> Result<StatusCode, ApiError> {
     let provider = ProviderName::new(provider)?;
@@ -100,11 +112,15 @@ pub async fn handle_disconnect(
 }
 
 #[utoipa::path(get, path = "/api/v1/providers/now-playing", tag = "providers", security(("bearer" = [])),
-    responses((status = 200, body = Option<DimensionPayload>))
+    responses((status = 200, body = Option<DimensionPayload>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_now_playing(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalReader(user_id): JournalReader,
 ) -> Result<Json<Option<DimensionPayload>>, ApiError> {
     let cipher = cipher(&state)?;
 
diff --git a/crates/adapters/http-axum/src/handlers/push.rs b/crates/adapters/http-axum/src/handlers/push.rs
index 2793977..35503cf 100644
--- a/crates/adapters/http-axum/src/handlers/push.rs
+++ b/crates/adapters/http-axum/src/handlers/push.rs
@@ -3,18 +3,21 @@ use axum::extract::State;
 use axum::http::StatusCode;
 
 use api_types::requests::{PushSubscribeRequest, PushUnsubscribeRequest};
-use application::push::use_cases::{subscribe, unsubscribe};
+use api_types::responses::{ErrorResponse, PushSubscriptionResponse, VapidKeyResponse};
+use application::push::use_cases::{list_subscriptions, subscribe, unsubscribe};
 
 use crate::errors::ApiError;
-use crate::extractors::AuthenticatedUser;
+use crate::extractors::{Body, SessionUser};
 use crate::state::AppState;
 
 #[utoipa::path(get, path = "/api/v1/push/vapid-key", tag = "push",
-    responses((status = 200, description = "VAPID public key"))
+    responses((status = 200, body = VapidKeyResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_vapid_key(
     State(state): State<AppState>,
-) -> Result<Json<serde_json::Value>, ApiError> {
+) -> Result<Json<VapidKeyResponse>, ApiError> {
     if !state.push_config.enabled {
         return Err(domain::errors::DomainError::NotFound(
             "push notifications are disabled".into(),
@@ -22,17 +25,44 @@ pub async fn handle_vapid_key(
         .into());
     }
     let public_key = web_push_adapter::WebPushSender::public_key_base64(&state.push_config)?;
-    Ok(Json(serde_json::json!({ "publicKey": public_key })))
+
+    Ok(Json(VapidKeyResponse { public_key }))
+}
+
+#[utoipa::path(get, path = "/api/v1/push/subscriptions", tag = "push", security(("bearer" = [])),
+    description = "The devices this account has subscribed for reminders. Keys are never \
+                   returned; a client sees only which endpoints exist and when each was added.",
+    responses((status = 200, body = Vec<PushSubscriptionResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
+)]
+pub async fn handle_list_subscriptions(
+    State(state): State<AppState>,
+    SessionUser(user_id): SessionUser,
+) -> Result<Json<Vec<PushSubscriptionResponse>>, ApiError> {
+    let deps = list_subscriptions::Deps {
+        push_query: state.push_subscription_query,
+    };
+
+    let held = list_subscriptions::execute(user_id, &deps).await?;
+
+    Ok(Json(held.into_iter().map(Into::into).collect()))
 }
 
 #[utoipa::path(post, path = "/api/v1/push/subscribe", tag = "push", security(("bearer" = [])),
     request_body = PushSubscribeRequest,
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_subscribe(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Json(body): Json<PushSubscribeRequest>,
+    SessionUser(user_id): SessionUser,
+    Body(body): Body<PushSubscribeRequest>,
 ) -> Result<StatusCode, ApiError> {
     let cmd = body.into_command(user_id);
     let deps = subscribe::Deps {
@@ -45,14 +75,18 @@ pub async fn handle_subscribe(
 
 #[utoipa::path(post, path = "/api/v1/push/unsubscribe", tag = "push", security(("bearer" = [])),
     request_body = PushUnsubscribeRequest,
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_unsubscribe(
     State(state): State<AppState>,
-    AuthenticatedUser(_user_id): AuthenticatedUser,
-    Json(body): Json<PushUnsubscribeRequest>,
+    SessionUser(user_id): SessionUser,
+    Body(body): Body<PushUnsubscribeRequest>,
 ) -> Result<StatusCode, ApiError> {
-    let cmd = body.into_command();
+    let cmd = body.into_command(user_id);
     let deps = unsubscribe::Deps {
         push_command: state.push_subscription_command,
     };
@@ -61,11 +95,15 @@ pub async fn handle_unsubscribe(
 }
 
 #[utoipa::path(post, path = "/api/v1/push/test", tag = "push", security(("bearer" = [])),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_test(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
 ) -> Result<StatusCode, ApiError> {
     let sender = state
         .reminder_sender
diff --git a/crates/adapters/http-axum/src/handlers/reminders.rs b/crates/adapters/http-axum/src/handlers/reminders.rs
index 3a798b2..41e6521 100644
--- a/crates/adapters/http-axum/src/handlers/reminders.rs
+++ b/crates/adapters/http-axum/src/handlers/reminders.rs
@@ -3,24 +3,28 @@ use axum::extract::State;
 use axum::http::StatusCode;
 
 use api_types::requests::{CreateReminderRequest, UpdateReminderRequest};
-use api_types::responses::ReminderResponse;
+use api_types::responses::{ErrorResponse, ReminderResponse};
 use application::reminder::use_cases::{
     create_reminder, delete_reminder, get_reminder, list_reminders, update_reminder,
 };
 use domain::reminder::ReminderId;
 
 use crate::errors::ApiError;
-use crate::extractors::{AuthenticatedUser, PathId};
+use crate::extractors::{Body, JournalReader, JournalWriter, PathId};
 use crate::state::AppState;
 
 #[utoipa::path(post, path = "/api/v1/reminders", tag = "reminders", security(("bearer" = [])),
     request_body = CreateReminderRequest,
-    responses((status = 201, body = ReminderResponse))
+    responses((status = 201, body = ReminderResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_create(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Json(body): Json<CreateReminderRequest>,
+    JournalWriter(user_id): JournalWriter,
+    Body(body): Body<CreateReminderRequest>,
 ) -> Result<(StatusCode, Json<ReminderResponse>), ApiError> {
     let cmd = body.into_command(user_id)?;
     let deps = create_reminder::Deps {
@@ -33,11 +37,15 @@ pub async fn handle_create(
 
 #[utoipa::path(get, path = "/api/v1/reminders/{id}", tag = "reminders", security(("bearer" = [])),
     params(("id" = String, Path)),
-    responses((status = 200, body = ReminderResponse))
+    responses((status = 200, body = ReminderResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_get(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalReader(user_id): JournalReader,
     PathId(reminder_id): PathId<ReminderId>,
 ) -> Result<Json<ReminderResponse>, ApiError> {
     let deps = get_reminder::Deps {
@@ -48,11 +56,15 @@ pub async fn handle_get(
 }
 
 #[utoipa::path(get, path = "/api/v1/reminders", tag = "reminders", security(("bearer" = [])),
-    responses((status = 200, body = Vec<ReminderResponse>))
+    responses((status = 200, body = Vec<ReminderResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_list(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalReader(user_id): JournalReader,
 ) -> Result<Json<Vec<ReminderResponse>>, ApiError> {
     let deps = list_reminders::Deps {
         query: state.reminder_query,
@@ -66,13 +78,17 @@ pub async fn handle_list(
 #[utoipa::path(patch, path = "/api/v1/reminders/{id}", tag = "reminders", security(("bearer" = [])),
     params(("id" = String, Path)),
     request_body = UpdateReminderRequest,
-    responses((status = 200, body = ReminderResponse))
+    responses((status = 200, body = ReminderResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_update(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(reminder_id): PathId<ReminderId>,
-    Json(body): Json<UpdateReminderRequest>,
+    Body(body): Body<UpdateReminderRequest>,
 ) -> Result<Json<ReminderResponse>, ApiError> {
     let cmd = body.into_command(reminder_id)?;
     let deps = update_reminder::Deps {
@@ -86,11 +102,15 @@ pub async fn handle_update(
 
 #[utoipa::path(delete, path = "/api/v1/reminders/{id}", tag = "reminders", security(("bearer" = [])),
     params(("id" = String, Path)),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_delete(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    JournalWriter(user_id): JournalWriter,
     PathId(reminder_id): PathId<ReminderId>,
 ) -> Result<StatusCode, ApiError> {
     let deps = delete_reminder::Deps {
diff --git a/crates/adapters/http-axum/src/handlers/server.rs b/crates/adapters/http-axum/src/handlers/server.rs
new file mode 100644
index 0000000..567167e
--- /dev/null
+++ b/crates/adapters/http-axum/src/handlers/server.rs
@@ -0,0 +1,76 @@
+use axum::Json;
+use axum::extract::State;
+
+use api_types::responses::{
+    ErrorResponse, MetricKindResponse, MoodResponse, ServerInfoResponse, ServerLimitsResponse,
+    TokenScopeResponse,
+};
+use domain::api_token::TokenScope;
+use domain::entry::Mood;
+use domain::metric::MetricKind;
+use domain::weather::Condition;
+
+use crate::state::AppState;
+
+#[utoipa::path(get, path = "/api/v1/server", tag = "server",
+    description = "What this deployment is and what it allows, for a client deciding what to \
+                   offer before anyone has signed in. Carries no secrets and needs no \
+                   authentication. The vocabularies are the ones the API validates against, so \
+                   a client can build its forms from here rather than hardcoding them.",
+    responses((status = 200, body = ServerInfoResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
+)]
+pub async fn handle_info(State(state): State<AppState>) -> Json<ServerInfoResponse> {
+    Json(ServerInfoResponse {
+        version: env!("CARGO_PKG_VERSION").to_string(),
+        registration_open: state.auth_config.allow_registration,
+        push_enabled: state.push_config.enabled,
+        weather_enabled: state.weather_enabled,
+        now_playing_provider: state
+            .now_playing
+            .as_ref()
+            .map(|playing| playing.provider().to_string()),
+        access_token_ttl_seconds: state.auth_config.access_token_ttl_seconds,
+        limits: ServerLimitsResponse {
+            max_body_size: state.server_config.max_body_size,
+            max_content_length: state.entry_config.max_content_length,
+            max_photos: state.entry_config.max_photos,
+            max_voice_memos: state.entry_config.max_voice_memos,
+            max_activities_per_entry: state.entry_config.max_activities_per_entry,
+            max_entries_per_page: state.entry_config.max_entries_per_page,
+            max_import_days: state.import_config.maximum_days_per_import,
+        },
+        token_scopes: TokenScope::ALL
+            .into_iter()
+            .map(|scope| TokenScopeResponse {
+                name: scope.name().to_string(),
+                describes: scope.describes().to_string(),
+            })
+            .collect(),
+        metric_kinds: MetricKind::ALL
+            .into_iter()
+            .map(|kind| {
+                let (minimum, maximum) = kind.bounds();
+
+                MetricKindResponse {
+                    name: kind.name().to_string(),
+                    unit: kind.unit().to_string(),
+                    minimum,
+                    maximum,
+                }
+            })
+            .collect(),
+        moods: Mood::ALL
+            .into_iter()
+            .map(|mood| MoodResponse {
+                value: mood.value(),
+                label: mood.label().to_string(),
+            })
+            .collect(),
+        weather_conditions: Condition::ALL
+            .into_iter()
+            .map(|condition| condition.name().to_string())
+            .collect(),
+    })
+}
diff --git a/crates/adapters/http-axum/src/handlers/tokens.rs b/crates/adapters/http-axum/src/handlers/tokens.rs
index 5df15ea..c2d9d5e 100644
--- a/crates/adapters/http-axum/src/handlers/tokens.rs
+++ b/crates/adapters/http-axum/src/handlers/tokens.rs
@@ -3,24 +3,28 @@ use axum::extract::State;
 use axum::http::StatusCode;
 
 use api_types::requests::MintApiTokenRequest;
-use api_types::responses::{ApiTokenResponse, MintedApiTokenResponse};
+use api_types::responses::{ApiTokenResponse, ErrorResponse, MintedApiTokenResponse};
 use application::api_token::commands::MintApiTokenCommand;
 use application::api_token::use_cases::{list_api_tokens, mint_api_token, revoke_api_token};
-use domain::api_token::ApiTokenId;
+use domain::api_token::{ApiTokenId, TokenScopes};
 use domain::provider::ProviderName;
 
 use crate::errors::ApiError;
-use crate::extractors::{AuthenticatedUser, PathId};
+use crate::extractors::{Body, PathId, SessionUser};
 use crate::state::AppState;
 
 #[utoipa::path(get, path = "/api/v1/tokens", tag = "tokens", security(("bearer" = [])),
     description = "Lists this account's api tokens. Values are never returned; only the name, \
                    when it was minted, and when it was last used.",
-    responses((status = 200, body = Vec<ApiTokenResponse>))
+    responses((status = 200, body = Vec<ApiTokenResponse>),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_list(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
 ) -> Result<Json<Vec<ApiTokenResponse>>, ApiError> {
     let deps = list_api_tokens::Deps {
         query: state.api_token_query,
@@ -32,16 +36,23 @@ pub async fn handle_list(
 }
 
 #[utoipa::path(post, path = "/api/v1/tokens", tag = "tokens", security(("bearer" = [])),
-    description = "Mints a token for writing daily metrics. The value comes back once and is \
-                   never retrievable again. The name becomes the Provider that the token's \
-                   writes are attributed to, so it must be lowercase letters, digits and hyphens.",
+    description = "Mints a token granting the scopes named in the request, and nothing else. \
+                   The value comes back once and is never retrievable again. The name becomes \
+                   the Provider that the token's metric writes are attributed to, so it must be \
+                   lowercase letters, digits and hyphens. Account operations — minting tokens, \
+                   changing the password, backup and restore — always need a signed-in session \
+                   and are never reachable with a token.",
     request_body = MintApiTokenRequest,
-    responses((status = 201, body = MintedApiTokenResponse))
+    responses((status = 201, body = MintedApiTokenResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_mint(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Json(body): Json<MintApiTokenRequest>,
+    SessionUser(user_id): SessionUser,
+    Body(body): Body<MintApiTokenRequest>,
 ) -> Result<(StatusCode, Json<MintedApiTokenResponse>), ApiError> {
     let deps = mint_api_token::Deps {
         command: state.api_token_command,
@@ -52,6 +63,7 @@ pub async fn handle_mint(
         MintApiTokenCommand {
             user_id,
             name: ProviderName::new(body.name)?,
+            scopes: TokenScopes::from_names(body.scopes.iter().map(String::as_str))?,
         },
         &deps,
     )
@@ -63,11 +75,15 @@ pub async fn handle_mint(
 #[utoipa::path(delete, path = "/api/v1/tokens/{id}", tag = "tokens", security(("bearer" = [])),
     description = "Revokes a token. It stops working at once.",
     params(("id" = String, Path, description = "Token ID")),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_revoke(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
     PathId(token_id): PathId<ApiTokenId>,
 ) -> Result<StatusCode, ApiError> {
     let deps = revoke_api_token::Deps {
diff --git a/crates/adapters/http-axum/src/handlers/users.rs b/crates/adapters/http-axum/src/handlers/users.rs
index 0564155..df6b100 100644
--- a/crates/adapters/http-axum/src/handlers/users.rs
+++ b/crates/adapters/http-axum/src/handlers/users.rs
@@ -3,22 +3,24 @@ use axum::extract::State;
 use axum::http::StatusCode;
 
 use api_types::requests::{ChangePasswordRequest, RegisterRequest, UpdateProfileRequest};
-use api_types::responses::UserResponse;
+use api_types::responses::{ErrorResponse, UserResponse};
 use application::user::use_cases::{
     change_password, clear_data, delete_user, get_profile, register, update_profile,
 };
 
 use crate::errors::ApiError;
-use crate::extractors::AuthenticatedUser;
+use crate::extractors::{Body, ProfileReader, SessionUser};
 use crate::state::AppState;
 
 #[utoipa::path(post, path = "/api/v1/users/register", tag = "users",
     request_body = RegisterRequest,
-    responses((status = 201, body = UserResponse))
+    responses((status = 201, body = UserResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_register(
     State(state): State<AppState>,
-    Json(body): Json<RegisterRequest>,
+    Body(body): Body<RegisterRequest>,
 ) -> Result<(StatusCode, Json<UserResponse>), ApiError> {
     if !state.auth_config.allow_registration {
         return Err(
@@ -39,11 +41,15 @@ pub async fn handle_register(
 }
 
 #[utoipa::path(get, path = "/api/v1/users/me", tag = "users", security(("bearer" = [])),
-    responses((status = 200, body = UserResponse))
+    responses((status = 200, body = UserResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_get_profile(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    ProfileReader(user_id): ProfileReader,
 ) -> Result<Json<UserResponse>, ApiError> {
     let deps = get_profile::Deps {
         user_query: state.user_query,
@@ -54,12 +60,16 @@ pub async fn handle_get_profile(
 
 #[utoipa::path(patch, path = "/api/v1/users/me", tag = "users", security(("bearer" = [])),
     request_body = UpdateProfileRequest,
-    responses((status = 200, body = UserResponse))
+    responses((status = 200, body = UserResponse),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_update_profile(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Json(body): Json<UpdateProfileRequest>,
+    SessionUser(user_id): SessionUser,
+    Body(body): Body<UpdateProfileRequest>,
 ) -> Result<Json<UserResponse>, ApiError> {
     let cmd = body.into_command(user_id)?;
     let deps = update_profile::Deps {
@@ -72,15 +82,20 @@ pub async fn handle_update_profile(
 
 #[utoipa::path(patch, path = "/api/v1/users/me/password", tag = "users", security(("bearer" = [])),
     request_body = ChangePasswordRequest,
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_change_password(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    Json(body): Json<ChangePasswordRequest>,
+    SessionUser(user_id): SessionUser,
+    Body(body): Body<ChangePasswordRequest>,
 ) -> Result<StatusCode, ApiError> {
     let cmd = body.into_command(user_id);
     let deps = change_password::Deps {
+        refresh_sessions: state.refresh_session_command.clone(),
         user_command: state.user_command,
         user_query: state.user_query,
         password_hasher: state.password_hasher,
@@ -90,18 +105,21 @@ pub async fn handle_change_password(
 }
 
 #[utoipa::path(delete, path = "/api/v1/users/me", tag = "users", security(("bearer" = [])),
-    responses((status = 204))
+    responses((status = 204),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_delete(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
 ) -> Result<StatusCode, ApiError> {
     let deps = delete_user::Deps {
-        dimensions: state.dimensions.clone(),
         user_query: state.user_query,
-        entry_query: state.entry_query,
         cascade: state.cascade,
         media_storage: state.media_storage,
+        media_ownership: state.media_ownership,
         events: state.event_publisher,
     };
     delete_user::execute(user_id, &deps).await?;
@@ -109,17 +127,20 @@ pub async fn handle_delete(
 }
 
 #[utoipa::path(delete, path = "/api/v1/users/me/data", tag = "users", security(("bearer" = [])),
-    responses((status = 204, description = "All user data cleared"))
+    responses((status = 204, description = "All user data cleared"),
+        (status = 401, description = "No credential, or one this endpoint does not accept", body = ErrorResponse),
+        (status = 403, description = "A token that does not grant what this endpoint needs", body = ErrorResponse),
+        (status = 400, description = "Malformed request", body = ErrorResponse),
+        (status = 422, description = "Understood but refused", body = ErrorResponse))
 )]
 pub async fn handle_clear_data(
     State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
+    SessionUser(user_id): SessionUser,
 ) -> Result<StatusCode, ApiError> {
     let deps = clear_data::Deps {
-        dimensions: state.dimensions.clone(),
-        entry_query: state.entry_query,
         cascade: state.cascade,
         media_storage: state.media_storage,
+        media_ownership: state.media_ownership,
     };
     clear_data::execute(user_id, &deps).await?;
     Ok(StatusCode::NO_CONTENT)
diff --git a/crates/adapters/http-axum/src/openapi.rs b/crates/adapters/http-axum/src/openapi.rs
index 19d5769..37a82e4 100644
--- a/crates/adapters/http-axum/src/openapi.rs
+++ b/crates/adapters/http-axum/src/openapi.rs
@@ -18,6 +18,7 @@ use utoipa::{Modify, OpenApi};
         crate::handlers::auth::handle_refresh,
         crate::handlers::auth::handle_logout,
         crate::handlers::entries::handle_create,
+        crate::handlers::entries::handle_create_many,
         crate::handlers::entries::handle_get,
         crate::handlers::entries::handle_list,
         crate::handlers::entries::handle_update,
@@ -47,6 +48,7 @@ use utoipa::{Modify, OpenApi};
         crate::handlers::reminders::handle_list,
         crate::handlers::reminders::handle_update,
         crate::handlers::reminders::handle_delete,
+        crate::handlers::media::handle_list,
         crate::handlers::media::handle_upload_photo,
         crate::handlers::media::handle_upload_voice_memo,
         crate::handlers::media::handle_serve_photo,
@@ -58,6 +60,7 @@ use utoipa::{Modify, OpenApi};
         crate::handlers::data::handle_restore,
         crate::handlers::import_export::handle_import,
         crate::handlers::push::handle_vapid_key,
+        crate::handlers::push::handle_list_subscriptions,
         crate::handlers::push::handle_subscribe,
         crate::handlers::push::handle_unsubscribe,
         crate::handlers::push::handle_test,
@@ -74,14 +77,19 @@ use utoipa::{Modify, OpenApi};
         crate::handlers::metrics::handle_import,
         crate::handlers::metrics::handle_rejections,
         crate::handlers::metrics::handle_set,
+        crate::handlers::server::handle_info,
+        crate::handlers::jobs::handle_list_exhausted,
     ),
     components(schemas(
         api_types::requests::CreateEntryRequest,
+        api_types::requests::CreateEntriesRequest,
+        api_types::responses::EntryPageResponse,
         api_types::requests::UpdateEntryRequest,
-        api_types::requests::ListEntriesParams,
-        api_types::requests::DateRangeParams,
+        api_types::params::ListEntriesParams,
+        api_types::params::DateRangeParams,
         api_types::requests::ReplaceActivityRequest,
         api_types::requests::CreateActivityRequest,
+        api_types::params::ListActivitiesParams,
         api_types::requests::RenameActivityRequest,
         api_types::requests::SetCategoryRequest,
         api_types::requests::RegisterRequest,
@@ -98,15 +106,18 @@ use utoipa::{Modify, OpenApi};
         api_types::responses::ReminderResponse,
         api_types::responses::DayScheduleResponse,
         api_types::responses::MoodStatsResponse,
-        api_types::responses::MoodFrequency,
+        api_types::responses::MoodFrequencyResponse,
         api_types::responses::CalendarDayResponse,
         api_types::responses::BulkActionResponse,
         api_types::responses::ImportResultResponse,
         api_types::responses::RestoreOutcomeResponse,
         api_types::responses::MediaIdResponse,
+        api_types::responses::OwnedMediaResponse,
+        api_types::responses::ExhaustedJobResponse,
+        api_types::responses::PushSubscriptionResponse,
         api_types::requests::SetDailyMetricsRequest,
         api_types::requests::MetricPayload,
-        api_types::requests::DateSpanParams,
+        api_types::params::DateSpanParams,
         api_types::responses::DailyMetricResponse,
         api_types::requests::MintApiTokenRequest,
         api_types::requests::SetPreferencesRequest,
@@ -127,6 +138,16 @@ use utoipa::{Modify, OpenApi};
         api_types::responses::StrategyScoreResponse,
         api_types::requests::PushSubscribeRequest,
         api_types::requests::PushUnsubscribeRequest,
+        api_types::responses::ErrorResponse,
+        api_types::responses::ErrorDetailResponse,
+        api_types::responses::SignedInResponse,
+        api_types::responses::RefreshedResponse,
+        api_types::responses::VapidKeyResponse,
+        api_types::responses::ServerInfoResponse,
+        api_types::responses::ServerLimitsResponse,
+        api_types::responses::TokenScopeResponse,
+        api_types::responses::MetricKindResponse,
+        api_types::responses::MoodResponse,
     )),
     tags(
         (name = "auth", description = "Authentication"),
diff --git a/crates/adapters/http-axum/src/router.rs b/crates/adapters/http-axum/src/router.rs
index 7558d97..9bdf215 100644
--- a/crates/adapters/http-axum/src/router.rs
+++ b/crates/adapters/http-axum/src/router.rs
@@ -1,15 +1,20 @@
 use axum::extract::DefaultBodyLimit;
 use axum::http::HeaderValue;
+use axum::http::StatusCode;
 use axum::routing::{delete, get, patch, post, put};
 use axum::{Json, Router};
+use tower_governor::GovernorError;
+use tower_governor::governor::GovernorConfigBuilder;
+use tower_governor::{GovernorLayer, key_extractor::SmartIpKeyExtractor};
 use tower_http::cors::{AllowOrigin, Any, CorsLayer};
 use tower_http::trace::TraceLayer;
 use utoipa::OpenApi;
 use utoipa_scalar::{Scalar, Servable};
 
+use crate::errors::{INTERNAL_ERROR, TOO_MANY_REQUESTS, refuse};
 use crate::handlers::{
-    activities, auth, correlations, cycle, data, entries, import_export, media, metrics, providers,
-    push, reminders, tokens, users,
+    activities, auth, correlations, cycle, data, entries, import_export, jobs, media, metrics,
+    providers, push, reminders, server, tokens, users,
 };
 use crate::openapi::ApiDoc;
 use crate::state::AppState;
@@ -18,11 +23,17 @@ pub fn build_router(state: AppState) -> Router {
     let cors = build_cors(&state.server_config.cors);
     let body_limit = DefaultBodyLimit::max(state.server_config.max_body_size);
 
-    Router::new()
+    let answered_here = Router::new()
         .nest("/api/v1", api_routes())
         .route("/health", get(health))
         .route("/openapi.json", get(openapi_json))
-        .merge(Scalar::with_url("/docs", ApiDoc::openapi()))
+        .merge(Scalar::with_url("/docs", ApiDoc::openapi()));
+
+    // The limit guards the journal, not the files the browser needs to show
+    // it. One cold load of the client asks for a dozen or more hashed assets
+    // at once, and counting those against the same budget as the API means a
+    // hard refresh can leave the app unable to fetch its own code.
+    rate_limited(answered_here, &state.server_config.rate_limit)
         .fallback_service(crate::spa::serve_spa(&state.server_config.spa_dir))
         .layer(body_limit)
         .layer(cors)
@@ -30,6 +41,98 @@ pub fn build_router(state: AppState) -> Router {
         .with_state(state)
 }
 
+/// One second, in milliseconds.
+const ONE_SECOND_IN_MILLIS: u64 = 1000;
+
+/// How long to wait between replenishing one unit of the quota.
+///
+/// `GovernorConfigBuilder::per_second` takes the *interval* between
+/// replenishments, not a rate, so feeding it a per-second figure means the
+/// opposite of what the name says: `50` asks for one request every fifty
+/// seconds rather than fifty every second. This converts the configured rate
+/// into the interval the builder actually wants.
+pub fn replenish_interval_millis(requests_per_second: u64) -> u64 {
+    (ONE_SECOND_IN_MILLIS / requests_per_second.max(1)).max(1)
+}
+
+/// Applies the limit with `route_layer`, so it runs only for requests that
+/// match a route here. Static client assets are served by the fallback and are
+/// deliberately outside it.
+pub fn rate_limited<S>(router: Router<S>, config: &config::RateLimitConfig) -> Router<S>
+where
+    S: Clone + Send + Sync + 'static,
+{
+    if !config.enabled {
+        tracing::warn!("rate limiting is switched off, so any client may poll as fast as it likes");
+
+        return router;
+    }
+
+    match config.trust_forwarded_for {
+        true => keyed_by_forwarded_ip(router, config),
+        false => keyed_by_peer_ip(router, config),
+    }
+}
+
+fn keyed_by_forwarded_ip<S>(router: Router<S>, config: &config::RateLimitConfig) -> Router<S>
+where
+    S: Clone + Send + Sync + 'static,
+{
+    let built = GovernorConfigBuilder::default()
+        .per_millisecond(replenish_interval_millis(config.requests_per_second))
+        .burst_size(config.burst)
+        .key_extractor(SmartIpKeyExtractor)
+        .finish();
+
+    match built {
+        Some(governor) => router.route_layer(GovernorLayer::new(governor).error_handler(slow_down)),
+        None => unusable(router),
+    }
+}
+
+fn keyed_by_peer_ip<S>(router: Router<S>, config: &config::RateLimitConfig) -> Router<S>
+where
+    S: Clone + Send + Sync + 'static,
+{
+    let built = GovernorConfigBuilder::default()
+        .per_millisecond(replenish_interval_millis(config.requests_per_second))
+        .burst_size(config.burst)
+        .finish();
+
+    match built {
+        Some(governor) => router.route_layer(GovernorLayer::new(governor).error_handler(slow_down)),
+        None => unusable(router),
+    }
+}
+
+fn unusable<S>(router: Router<S>) -> Router<S> {
+    tracing::error!("the configured rate limit is not usable, so none is applied");
+
+    router
+}
+
+fn slow_down(error: GovernorError) -> axum::response::Response {
+    let (status, code, message) = match error {
+        GovernorError::TooManyRequests { .. } => (
+            StatusCode::TOO_MANY_REQUESTS,
+            TOO_MANY_REQUESTS,
+            "too many requests: slow down and try again shortly".to_string(),
+        ),
+        GovernorError::UnableToExtractKey => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            INTERNAL_ERROR,
+            "the caller could not be identified for rate limiting".to_string(),
+        ),
+        GovernorError::Other { msg, .. } => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            INTERNAL_ERROR,
+            msg.unwrap_or_else(|| "rate limiting failed".to_string()),
+        ),
+    };
+
+    refuse(status, code, message)
+}
+
 async fn openapi_json() -> Json<utoipa::openapi::OpenApi> {
     Json(ApiDoc::openapi())
 }
@@ -72,6 +175,8 @@ fn api_routes() -> Router<AppState> {
         .nest("/providers", provider_routes())
         .nest("/push", push_routes())
         .nest("/data", data_routes())
+        .route("/server", get(server::handle_info))
+        .route("/jobs/exhausted", get(jobs::handle_list_exhausted))
 }
 
 fn cycle_routes() -> Router<AppState> {
@@ -125,6 +230,7 @@ fn entry_routes() -> Router<AppState> {
                 .patch(entries::handle_update)
                 .delete(entries::handle_delete),
         )
+        .route("/bulk", post(entries::handle_create_many))
         .route("/stats", get(entries::handle_stats))
         .route("/calendar", get(entries::handle_calendar))
         .route("/filter/mood/{mood}", get(entries::handle_filter_by_mood))
@@ -188,6 +294,7 @@ fn reminder_routes() -> Router<AppState> {
 
 fn media_routes() -> Router<AppState> {
     Router::new()
+        .route("/", get(media::handle_list))
         .route("/photos", post(media::handle_upload_photo))
         .route(
             "/photos/{id}",
@@ -203,6 +310,7 @@ fn media_routes() -> Router<AppState> {
 fn push_routes() -> Router<AppState> {
     Router::new()
         .route("/vapid-key", get(push::handle_vapid_key))
+        .route("/subscriptions", get(push::handle_list_subscriptions))
         .route("/subscribe", post(push::handle_subscribe))
         .route("/unsubscribe", post(push::handle_unsubscribe))
         .route("/test", post(push::handle_test))
diff --git a/crates/adapters/http-axum/src/state.rs b/crates/adapters/http-axum/src/state.rs
index 0ce0114..f6bfd7e 100644
--- a/crates/adapters/http-axum/src/state.rs
+++ b/crates/adapters/http-axum/src/state.rs
@@ -7,12 +7,13 @@ use domain::ports::{
     ActivityCommandPort, ActivityQueryPort, ApiTokenCommandPort, ApiTokenQueryPort,
     ApiTokenSecretPort, AuthServicePort, BackupReaderPort, BackupWriterPort, CascadeDeletePort,
     CycleStartCommandPort, CycleStartQueryPort, DailyMetricCommandPort, DailyMetricQueryPort,
-    EntryDimensionPort, EventPublisherPort, ExtractWriterPort, ImportSourcePort, MediaStoragePort,
-    MoodEntryCommandPort, MoodEntryQueryPort, PasswordHasherPort, ProviderConnectionCommandPort,
-    ProviderConnectionQueryPort, PushSubscriptionCommandPort, PushSubscriptionQueryPort,
-    RefreshSessionCommandPort, RefreshSessionQueryPort, RejectionCommandPort, RejectionQueryPort,
-    ReminderCommandPort, ReminderQueryPort, ReminderSenderPort, UserCommandPort,
-    UserPreferencesCommandPort, UserPreferencesQueryPort, UserQueryPort,
+    EntryDimensionPort, EventPublisherPort, ExtractWriterPort, ImportSourcePort,
+    MediaOwnershipPort, MediaStoragePort, MoodEntryCommandPort, MoodEntryQueryPort,
+    PasswordHasherPort, ProviderConnectionCommandPort, ProviderConnectionQueryPort,
+    PushSubscriptionCommandPort, PushSubscriptionQueryPort, RefreshSessionCommandPort,
+    RefreshSessionQueryPort, RejectionCommandPort, RejectionQueryPort, ReminderCommandPort,
+    ReminderQueryPort, ReminderSenderPort, UserCommandPort, UserPreferencesCommandPort,
+    UserPreferencesQueryPort, UserQueryPort,
 };
 
 #[derive(Clone)]
@@ -21,6 +22,7 @@ pub struct AppState {
     pub entry_query: Arc<dyn MoodEntryQueryPort>,
     pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
     pub weather_store: Arc<dyn EntryDimensionPort>,
+    pub activity_store: Arc<dyn EntryDimensionPort>,
     pub activity_command: Arc<dyn ActivityCommandPort>,
     pub activity_query: Arc<dyn ActivityQueryPort>,
     pub user_command: Arc<dyn UserCommandPort>,
@@ -45,6 +47,8 @@ pub struct AppState {
     pub password_hasher: Arc<dyn PasswordHasherPort>,
     pub event_publisher: Arc<dyn EventPublisherPort>,
     pub media_storage: Arc<dyn MediaStoragePort>,
+    pub media_ownership: Arc<dyn MediaOwnershipPort>,
+    pub job_view: Arc<dyn domain::ports::JobQueueQueryPort>,
     pub backup_writer: Arc<dyn BackupWriterPort>,
     pub backup_reader: Arc<dyn BackupReaderPort>,
     pub extract_writer: Arc<dyn ExtractWriterPort>,
@@ -53,6 +57,7 @@ pub struct AppState {
     pub provider_connection_query: Arc<dyn ProviderConnectionQueryPort>,
     pub credential_cipher: Option<Arc<dyn domain::provider::CredentialCipher>>,
     pub now_playing: Option<Arc<dyn domain::ports::NowPlayingPort>>,
+    pub weather_enabled: bool,
     pub recording_lookup: Arc<dyn domain::ports::RecordingLookupPort>,
     pub push_subscription_command: Arc<dyn PushSubscriptionCommandPort>,
     pub push_subscription_query: Arc<dyn PushSubscriptionQueryPort>,
diff --git a/crates/adapters/http-axum/tests/openapi_contract_test.rs b/crates/adapters/http-axum/tests/openapi_contract_test.rs
new file mode 100644
index 0000000..6c06716
--- /dev/null
+++ b/crates/adapters/http-axum/tests/openapi_contract_test.rs
@@ -0,0 +1,129 @@
+use utoipa::OpenApi;
+
+fn spec() -> serde_json::Value {
+    serde_json::to_value(http_axum::openapi::ApiDoc::openapi()).unwrap()
+}
+
+fn operations(spec: &serde_json::Value) -> Vec<(String, String, serde_json::Value)> {
+    spec["paths"]
+        .as_object()
+        .unwrap()
+        .iter()
+        .flat_map(|(path, methods)| {
+            methods
+                .as_object()
+                .unwrap()
+                .iter()
+                .map(move |(verb, op)| (verb.to_uppercase(), path.clone(), op.clone()))
+        })
+        .collect()
+}
+
+#[test]
+fn every_operation_that_can_succeed_with_a_body_declares_its_shape() {
+    let spec = spec();
+    let mut untyped = Vec::new();
+
+    for (verb, path, op) in operations(&spec) {
+        let responses = op["responses"].as_object().unwrap();
+
+        let describes_a_success = responses
+            .iter()
+            .any(|(code, response)| code.starts_with('2') && response.get("content").is_some());
+        let says_nothing_comes_back = responses.contains_key("204");
+        let serves_bytes = path.starts_with("/api/v1/media/");
+
+        if !describes_a_success && !says_nothing_comes_back && !serves_bytes {
+            untyped.push(format!("{verb} {path}"));
+        }
+    }
+
+    assert!(
+        untyped.is_empty(),
+        "a generated client cannot type these responses: {untyped:?}"
+    );
+}
+
+#[test]
+fn every_operation_documents_the_refusals_a_client_must_handle() {
+    let spec = spec();
+    let mut silent = Vec::new();
+
+    for (verb, path, op) in operations(&spec) {
+        let responses = op["responses"].as_object().unwrap();
+
+        if !responses.keys().any(|code| code.starts_with('4')) {
+            silent.push(format!("{verb} {path}"));
+        }
+    }
+
+    assert!(
+        silent.is_empty(),
+        "these operations can refuse a client but never say so: {silent:?}"
+    );
+}
+
+#[test]
+fn every_guarded_operation_says_what_a_wrong_credential_looks_like() {
+    let spec = spec();
+    let mut silent = Vec::new();
+
+    for (verb, path, op) in operations(&spec) {
+        if op.get("security").is_none() {
+            continue;
+        }
+
+        let responses = op["responses"].as_object().unwrap();
+
+        if !responses.contains_key("401") || !responses.contains_key("403") {
+            silent.push(format!("{verb} {path}"));
+        }
+    }
+
+    assert!(
+        silent.is_empty(),
+        "these need a credential but never describe refusing one: {silent:?}"
+    );
+}
+
+#[test]
+fn every_refusal_is_the_one_error_shape() {
+    let spec = spec();
+    let mut odd = Vec::new();
+
+    for (verb, path, op) in operations(&spec) {
+        for (code, response) in op["responses"].as_object().unwrap() {
+            if !code.starts_with('4') && !code.starts_with('5') {
+                continue;
+            }
+
+            let named = response["content"]["application/json"]["schema"]["$ref"]
+                .as_str()
+                .unwrap_or_default();
+
+            if named != "#/components/schemas/ErrorResponse" {
+                odd.push(format!("{verb} {path} -> {code}"));
+            }
+        }
+    }
+
+    assert!(
+        odd.is_empty(),
+        "a client should parse one error shape, not several: {odd:?}"
+    );
+}
+
+#[test]
+fn the_server_tells_a_client_what_it_allows_without_a_credential() {
+    let spec = spec();
+    let info = &spec["paths"]["/api/v1/server"]["get"];
+
+    assert!(
+        info.get("security").is_none(),
+        "a client decides whether to offer registration before anyone has signed in"
+    );
+    assert_eq!(
+        info["responses"]["200"]["content"]["application/json"]["schema"]["$ref"],
+        "#/components/schemas/ServerInfoResponse"
+    );
+}
diff --git a/crates/adapters/http-axum/tests/rate_limit_test.rs b/crates/adapters/http-axum/tests/rate_limit_test.rs
new file mode 100644
index 0000000..6b5a64c
--- /dev/null
+++ b/crates/adapters/http-axum/tests/rate_limit_test.rs
@@ -0,0 +1,119 @@
+//! The limit exists to protect the journal from being hammered. It must not
+//! also throttle the static files the browser needs to render the journal:
+//! one cold load of the client asks for a dozen or more hashed assets at once,
+//! and counting those against the same budget makes a hard refresh able to
+//! starve the app of its own code.
+
+use std::net::SocketAddr;
+
+use axum::Router;
+use axum::body::Body;
+use axum::extract::ConnectInfo;
+use axum::http::{Request, StatusCode};
+use axum::routing::get;
+use config::RateLimitConfig;
+use http_axum::router::rate_limited;
+use tower::util::ServiceExt;
+
+const CALLER: SocketAddr =
+    SocketAddr::new(std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST), 9000);
+
+/// One request allowed, then nothing until it replenishes — so a second call
+/// is refused and the difference between guarded and exempt is unmistakable.
+fn strictest() -> RateLimitConfig {
+    RateLimitConfig {
+        enabled: true,
+        requests_per_second: 1,
+        burst: 1,
+        trust_forwarded_for: false,
+    }
+}
+
+fn under_test(config: &RateLimitConfig) -> Router {
+    rate_limited(
+        Router::new().route("/api/v1/entries", get(|| async { "journal" })),
+        config,
+    )
+    .fallback(|| async { "index.html" })
+}
+
+async fn status_of(app: &Router, path: &str) -> StatusCode {
+    let mut request = Request::builder().uri(path).body(Body::empty()).unwrap();
+    request.extensions_mut().insert(ConnectInfo(CALLER));
+
+    app.clone().oneshot(request).await.unwrap().status()
+}
+
+#[tokio::test]
+async fn a_guarded_route_is_refused_once_its_budget_is_spent() {
+    let app = under_test(&strictest());
+
+    assert_eq!(status_of(&app, "/api/v1/entries").await, StatusCode::OK);
+    assert_eq!(
+        status_of(&app, "/api/v1/entries").await,
+        StatusCode::TOO_MANY_REQUESTS
+    );
+}
+
+#[tokio::test]
+async fn client_assets_keep_being_served_after_the_budget_is_spent() {
+    let app = under_test(&strictest());
+
+    // Spend the whole budget on the API.
+    assert_eq!(status_of(&app, "/api/v1/entries").await, StatusCode::OK);
+    assert_eq!(
+        status_of(&app, "/api/v1/entries").await,
+        StatusCode::TOO_MANY_REQUESTS
+    );
+
+    // The files the client is made of are still served, as many as it asks for.
+    for _ in 0..25 {
+        assert_eq!(
+            status_of(&app, "/assets/index-abc123.js").await,
+            StatusCode::OK
+        );
+    }
+}
+
+#[tokio::test]
+async fn a_switched_off_limit_guards_nothing() {
+    let off = RateLimitConfig {
+        enabled: false,
+        ..strictest()
+    };
+    let app = under_test(&off);
+
+    for _ in 0..10 {
+        assert_eq!(status_of(&app, "/api/v1/entries").await, StatusCode::OK);
+    }
+}
+
+/// `GovernorConfigBuilder::per_second` takes an interval, not a rate, so the
+/// configured figure has to be converted or it means its own opposite.
+mod replenishment {
+    use http_axum::router::replenish_interval_millis;
+
+    #[test]
+    fn a_rate_becomes_the_interval_between_replenishments() {
+        assert_eq!(replenish_interval_millis(1), 1000);
+        assert_eq!(replenish_interval_millis(10), 100);
+        assert_eq!(replenish_interval_millis(15), 66);
+    }
+
+    #[test]
+    fn a_faster_rate_waits_a_shorter_time() {
+        assert!(replenish_interval_millis(50) < replenish_interval_millis(5));
+    }
+
+    #[test]
+    fn an_interval_is_never_zero_however_high_the_rate() {
+        // The builder rejects a zero interval outright.
+        assert_eq!(replenish_interval_millis(10_000), 1);
+        assert_eq!(replenish_interval_millis(u64::MAX), 1);
+    }
+
+    #[test]
+    fn a_nonsensical_rate_of_zero_falls_back_to_one_a_second() {
+        assert_eq!(replenish_interval_millis(0), 1000);
+    }
+}
diff --git a/crates/adapters/importer/src/backup_reader.rs b/crates/adapters/importer/src/backup_reader.rs
index 619a142..ac8cfc7 100644
--- a/crates/adapters/importer/src/backup_reader.rs
+++ b/crates/adapters/importer/src/backup_reader.rs
@@ -1,10 +1,16 @@
 use api_types::dimension::DimensionPayload;
 use domain::dimension::DimensionValue;
 use domain::errors::DomainError;
+use std::collections::HashMap;
+
+use domain::attachment::ContentType;
 use domain::ports::{
-    RestorableActivity, RestorableContents, RestorableEntry, RestorableMetric, RestorableReminder,
+    RestorableActivity, RestorableContents, RestorableEntry, RestorableMedia, RestorableMetric,
+    RestorableReminder,
 };
 
+use exporter::{BackedUpMedia, PHOTO_KIND, VOICE_MEMO_KIND};
+
 use super::kmood_backup::KmoodBackupReader;
 
 pub struct KmoodBackupAdapter;
@@ -14,6 +20,7 @@ impl domain::ports::BackupReaderPort for KmoodBackupAdapter {
     async fn read(&self, data: &[u8]) -> Result<RestorableContents, DomainError> {
         let read = KmoodBackupReader::read(data)?;
         let manifest = read.manifest;
+        let types = declared_types(&manifest.media);
 
         Ok(RestorableContents {
             entries: manifest
@@ -63,8 +70,8 @@ impl domain::ports::BackupReaderPort for KmoodBackupAdapter {
                 })
                 .collect(),
             tracks_cycle: manifest.tracks_cycle,
-            photos: read.photos.into_iter().collect(),
-            voice_memos: read.voice_memos.into_iter().collect(),
+            photos: restorable(read.photos, &types, PHOTO_KIND),
+            voice_memos: restorable(read.voice_memos, &types, VOICE_MEMO_KIND),
         })
     }
 }
@@ -81,3 +88,30 @@ fn readable_dimensions(payloads: Vec<DimensionPayload>) -> Vec<DimensionValue> {
         })
         .collect()
 }
+
+fn declared_types(media: &[BackedUpMedia]) -> HashMap<(String, String), ContentType> {
+    media
+        .iter()
+        .map(|held| {
+            (
+                (held.kind.clone(), held.id.clone()),
+                ContentType::from_persistence(held.content_type.clone()),
+            )
+        })
+        .collect()
+}
+
+fn restorable(
+    blobs: HashMap<String, Vec<u8>>,
+    types: &HashMap<(String, String), ContentType>,
+    kind: &str,
+) -> Vec<RestorableMedia> {
+    blobs
+        .into_iter()
+        .map(|(id, data)| RestorableMedia {
+            content_type: types.get(&(kind.to_string(), id.clone())).cloned(),
+            id,
+            data,
+        })
+        .collect()
+}
diff --git a/crates/adapters/sqlite/src/db.rs b/crates/adapters/sqlite/src/db.rs
index 746692a..1b1f9f2 100644
--- a/crates/adapters/sqlite/src/db.rs
+++ b/crates/adapters/sqlite/src/db.rs
@@ -48,6 +48,22 @@ const MIGRATIONS: &[(&str, &str)] = &[
         "012_entry_weather",
         include_str!("migrations/012_entry_weather.sql"),
     ),
+    (
+        "013_reminder_last_sent",
+        include_str!("migrations/013_reminder_last_sent.sql"),
+    ),
+    (
+        "014_media_ownership",
+        include_str!("migrations/014_media_ownership.sql"),
+    ),
+    (
+        "015_logged_at_in_utc",
+        include_str!("migrations/015_logged_at_in_utc.sql"),
+    ),
+    (
+        "016_api_token_scopes",
+        include_str!("migrations/016_api_token_scopes.sql"),
+    ),
 ];
 
 const TAKE_THE_WRITE_LOCK_UP_FRONT: &str = "BEGIN IMMEDIATE";
@@ -57,6 +73,13 @@ const SCHEMA_MIGRATIONS_TABLE: &str = "CREATE TABLE IF NOT EXISTS schema_migrati
     applied_at TEXT NOT NULL
 )";
 
+pub fn migrations_before(name: &str) -> impl Iterator<Item = (&'static str, &'static str)> {
+    MIGRATIONS
+        .iter()
+        .take_while(move |(applied, _)| *applied != name)
+        .copied()
+}
+
 pub async fn create_pool(database_url: &str) -> Result<SqlitePool, sqlx::Error> {
     let options: SqliteConnectOptions = database_url
         .parse::<SqliteConnectOptions>()?
diff --git a/crates/adapters/sqlite/src/lib.rs b/crates/adapters/sqlite/src/lib.rs
index 95fec32..1a1506c 100644
--- a/crates/adapters/sqlite/src/lib.rs
+++ b/crates/adapters/sqlite/src/lib.rs
@@ -1,4 +1,4 @@
 mod db;
 pub mod repositories;
 
-pub use db::{create_pool, run_migrations};
+pub use db::{create_pool, migrations_before, run_migrations};
diff --git a/crates/adapters/sqlite/src/migrations/013_reminder_last_sent.sql b/crates/adapters/sqlite/src/migrations/013_reminder_last_sent.sql
new file mode 100644
index 0000000..910d64b
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/013_reminder_last_sent.sql
@@ -0,0 +1 @@
+ALTER TABLE reminders ADD COLUMN last_sent_at TEXT;
diff --git a/crates/adapters/sqlite/src/migrations/014_media_ownership.sql b/crates/adapters/sqlite/src/migrations/014_media_ownership.sql
new file mode 100644
index 0000000..767650b
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/014_media_ownership.sql
@@ -0,0 +1,19 @@
+CREATE TABLE IF NOT EXISTS media_owners (
+    kind TEXT NOT NULL,
+    media_id TEXT NOT NULL,
+    user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (kind, media_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_media_owners_user_id ON media_owners(user_id);
+
+INSERT OR IGNORE INTO media_owners (kind, media_id, user_id, created_at)
+SELECT 'photo', ep.photo_id, me.user_id, me.created_at
+FROM entry_photos ep
+JOIN mood_entries me ON me.id = ep.entry_id;
+
+INSERT OR IGNORE INTO media_owners (kind, media_id, user_id, created_at)
+SELECT 'voice_memo', evm.voice_memo_id, me.user_id, me.created_at
+FROM entry_voice_memos evm
+JOIN mood_entries me ON me.id = evm.entry_id;
diff --git a/crates/adapters/sqlite/src/migrations/015_logged_at_in_utc.sql b/crates/adapters/sqlite/src/migrations/015_logged_at_in_utc.sql
new file mode 100644
index 0000000..2149b1e
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/015_logged_at_in_utc.sql
@@ -0,0 +1,6 @@
+UPDATE mood_entries
+SET logged_at = strftime('%Y-%m-%dT%H:%M:%S+00:00', logged_at)
+WHERE logged_at NOT LIKE '%+00:00';
+
+CREATE INDEX IF NOT EXISTS idx_mood_entries_user_logged_at
+    ON mood_entries(user_id, logged_at);
diff --git a/crates/adapters/sqlite/src/migrations/016_api_token_scopes.sql b/crates/adapters/sqlite/src/migrations/016_api_token_scopes.sql
new file mode 100644
index 0000000..aa535f0
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/016_api_token_scopes.sql
@@ -0,0 +1,5 @@
+ALTER TABLE api_tokens ADD COLUMN scopes TEXT NOT NULL DEFAULT 'writeMetrics';
+
+UPDATE api_tokens SET scopes = scope WHERE scope IS NOT NULL AND scope != '';
+
+ALTER TABLE api_tokens DROP COLUMN scope;
diff --git a/crates/adapters/sqlite/src/repositories/api_token/command.rs b/crates/adapters/sqlite/src/repositories/api_token/command.rs
index 039dc44..8fa5ea5 100644
--- a/crates/adapters/sqlite/src/repositories/api_token/command.rs
+++ b/crates/adapters/sqlite/src/repositories/api_token/command.rs
@@ -35,14 +35,14 @@ impl domain::ports::ApiTokenCommandPort for SqliteApiTokenCommandRepository {
         }
 
         sqlx::query(
-            "INSERT INTO api_tokens (id, user_id, name, digest, scope, created_at, last_used_at)
+            "INSERT INTO api_tokens (id, user_id, name, digest, scopes, created_at, last_used_at)
              VALUES (?, ?, ?, ?, ?, ?, ?)",
         )
         .bind(token.id().value().to_string())
         .bind(token.user_id().value().to_string())
         .bind(token.name().value())
         .bind(token.digest().value())
-        .bind(token.scope().name())
+        .bind(token.scopes().to_persistence())
         .bind(token.created_at().to_rfc3339())
         .bind(token.last_used_at().map(|used| used.to_rfc3339()))
         .execute(&self.pool)
diff --git a/crates/adapters/sqlite/src/repositories/api_token/query.rs b/crates/adapters/sqlite/src/repositories/api_token/query.rs
index 11f7181..e522e90 100644
--- a/crates/adapters/sqlite/src/repositories/api_token/query.rs
+++ b/crates/adapters/sqlite/src/repositories/api_token/query.rs
@@ -21,7 +21,7 @@ impl SqliteApiTokenQueryRepository {
 impl domain::ports::ApiTokenQueryPort for SqliteApiTokenQueryRepository {
     async fn find_by_digest(&self, digest: &TokenDigest) -> Result<Option<ApiToken>, DomainError> {
         let row: Option<ApiTokenRow> = sqlx::query_as(
-            "SELECT id, user_id, name, digest, scope, created_at, last_used_at
+            "SELECT id, user_id, name, digest, scopes, created_at, last_used_at
              FROM api_tokens WHERE digest = ?",
         )
         .bind(digest.value())
@@ -34,7 +34,7 @@ impl domain::ports::ApiTokenQueryPort for SqliteApiTokenQueryRepository {
 
     async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<ApiToken>, DomainError> {
         let rows: Vec<ApiTokenRow> = sqlx::query_as(
-            "SELECT id, user_id, name, digest, scope, created_at, last_used_at
+            "SELECT id, user_id, name, digest, scopes, created_at, last_used_at
              FROM api_tokens WHERE user_id = ? ORDER BY created_at DESC",
         )
         .bind(user_id.value().to_string())
diff --git a/crates/adapters/sqlite/src/repositories/api_token/rows.rs b/crates/adapters/sqlite/src/repositories/api_token/rows.rs
index 79ba5c9..2218c5a 100644
--- a/crates/adapters/sqlite/src/repositories/api_token/rows.rs
+++ b/crates/adapters/sqlite/src/repositories/api_token/rows.rs
@@ -1,4 +1,4 @@
-use domain::api_token::{ApiToken, ApiTokenData, ApiTokenId, TokenDigest, TokenScope};
+use domain::api_token::{ApiToken, ApiTokenData, ApiTokenId, TokenDigest, TokenScopes};
 use domain::provider::ProviderName;
 use domain::user::UserId;
 
@@ -8,7 +8,7 @@ pub struct ApiTokenRow {
     pub user_id: String,
     pub name: String,
     pub digest: String,
-    pub scope: String,
+    pub scopes: String,
     pub created_at: String,
     pub last_used_at: Option<String>,
 }
@@ -24,7 +24,7 @@ pub fn row_to_token(row: &ApiTokenRow) -> Option<ApiToken> {
         user_id: UserId::from_uuid(row.user_id.parse().ok()?),
         name: ProviderName::from_persistence(row.name.clone()),
         digest: TokenDigest::from_persistence(row.digest.clone()),
-        scope: TokenScope::from_name(&row.scope)?,
+        scopes: TokenScopes::from_persistence(&row.scopes)?,
         created_at: row.created_at.parse().ok()?,
         last_used_at,
     }))
@@ -36,7 +36,7 @@ pub fn readable(row: &ApiTokenRow) -> Option<ApiToken> {
     if token.is_none() {
         tracing::warn!(
             token_id = %row.id,
-            scope = %row.scope,
+            scopes = %row.scopes,
             "skipped a stored api token this build cannot read"
         );
     }
diff --git a/crates/adapters/sqlite/src/repositories/cascade/mod.rs b/crates/adapters/sqlite/src/repositories/cascade/mod.rs
index 15dba21..14b8ac8 100644
--- a/crates/adapters/sqlite/src/repositories/cascade/mod.rs
+++ b/crates/adapters/sqlite/src/repositories/cascade/mod.rs
@@ -5,7 +5,17 @@ use domain::errors::DomainError;
 use domain::user::UserId;
 
 use super::entry::rows::{EntryRow, hydrate_batch};
-use super::shared::db_err;
+use super::shared::{db_err, sortable_instant};
+
+const EVERY_TABLE_THAT_HOLDS_WHAT_A_USER_LOGGED: [&str; 7] = [
+    "mood_entries",
+    "activities",
+    "reminders",
+    "daily_metrics",
+    "cycle_starts",
+    "metric_rejections",
+    "media_owners",
+];
 
 pub struct SqliteCascadeDeleteRepository {
     pool: SqlitePool,
@@ -23,29 +33,15 @@ impl domain::ports::CascadeDeletePort for SqliteCascadeDeleteRepository {
         let uid = user_id.value().to_string();
         let mut tx = self.pool.begin().await.map_err(db_err)?;
 
-        sqlx::query("DELETE FROM mood_entries WHERE user_id = ?")
-            .bind(&uid)
-            .execute(&mut *tx)
-            .await
-            .map_err(db_err)?;
-
-        sqlx::query("DELETE FROM activities WHERE user_id = ?")
-            .bind(&uid)
-            .execute(&mut *tx)
-            .await
-            .map_err(db_err)?;
-
-        sqlx::query("DELETE FROM reminders WHERE user_id = ?")
-            .bind(&uid)
-            .execute(&mut *tx)
-            .await
-            .map_err(db_err)?;
-
-        sqlx::query("DELETE FROM daily_metrics WHERE user_id = ?")
+        for table in EVERY_TABLE_THAT_HOLDS_WHAT_A_USER_LOGGED {
+            sqlx::query(sqlx::AssertSqlSafe(format!(
+                "DELETE FROM {table} WHERE user_id = ?"
+            )))
             .bind(&uid)
             .execute(&mut *tx)
             .await
             .map_err(db_err)?;
+        }
 
         tx.commit().await.map_err(db_err)?;
         Ok(())
@@ -85,6 +81,12 @@ impl domain::ports::CascadeDeletePort for SqliteCascadeDeleteRepository {
             .await
             .map_err(db_err)?;
 
+        sqlx::query("DELETE FROM media_owners WHERE user_id = ?")
+            .bind(&uid)
+            .execute(&mut *tx)
+            .await
+            .map_err(db_err)?;
+
         sqlx::query("DELETE FROM users WHERE id = ?")
             .bind(&uid)
             .execute(&mut *tx)
@@ -106,8 +108,8 @@ impl domain::ports::CascadeDeletePort for SqliteCascadeDeleteRepository {
             "SELECT * FROM mood_entries WHERE user_id = ? AND logged_at >= ? AND logged_at <= ? ORDER BY logged_at DESC",
         )
         .bind(&uid)
-        .bind(range.start().to_rfc3339())
-        .bind(range.end().to_rfc3339())
+        .bind(sortable_instant(range.start()))
+        .bind(sortable_instant(range.end()))
         .fetch_all(&self.pool)
         .await
         .map_err(db_err)?;
@@ -120,8 +122,8 @@ impl domain::ports::CascadeDeletePort for SqliteCascadeDeleteRepository {
             "DELETE FROM mood_entries WHERE user_id = ? AND logged_at >= ? AND logged_at <= ?",
         )
         .bind(&uid)
-        .bind(range.start().to_rfc3339())
-        .bind(range.end().to_rfc3339())
+        .bind(sortable_instant(range.start()))
+        .bind(sortable_instant(range.end()))
         .execute(&mut *tx)
         .await
         .map_err(db_err)?;
diff --git a/crates/adapters/sqlite/src/repositories/entry/command.rs b/crates/adapters/sqlite/src/repositories/entry/command.rs
index 394ce50..7a2663d 100644
--- a/crates/adapters/sqlite/src/repositories/entry/command.rs
+++ b/crates/adapters/sqlite/src/repositories/entry/command.rs
@@ -5,7 +5,7 @@ use domain::entry::{DateRange, MoodEntry, MoodEntryId};
 use domain::errors::DomainError;
 use domain::user::UserId;
 
-use super::super::shared::db_err;
+use super::super::shared::{db_err, sortable_instant};
 
 pub struct SqliteEntryCommandRepository {
     pool: SqlitePool,
@@ -30,7 +30,7 @@ impl domain::ports::MoodEntryCommandPort for SqliteEntryCommandRepository {
         .bind(entry.id().value().to_string())
         .bind(entry.user_id().value().to_string())
         .bind(entry.mood().value() as i32)
-        .bind(entry.logged_at().to_rfc3339())
+        .bind(sortable_instant(entry.logged_at()))
         .bind(entry.created_at().to_rfc3339())
         .bind(entry.updated_at().to_rfc3339())
         .execute(&self.pool)
@@ -56,7 +56,7 @@ impl domain::ports::MoodEntryCommandPort for SqliteEntryCommandRepository {
             .bind(&entry_id)
             .bind(entry.user_id().value().to_string())
             .bind(entry.mood().value() as i32)
-            .bind(entry.logged_at().to_rfc3339())
+            .bind(sortable_instant(entry.logged_at()))
             .bind(entry.created_at().to_rfc3339())
             .bind(entry.updated_at().to_rfc3339())
             .execute(&mut *tx)
@@ -95,8 +95,8 @@ impl domain::ports::MoodEntryCommandPort for SqliteEntryCommandRepository {
             "DELETE FROM mood_entries WHERE user_id = ? AND logged_at >= ? AND logged_at <= ?",
         )
         .bind(user_id.value().to_string())
-        .bind(range.start().to_rfc3339())
-        .bind(range.end().to_rfc3339())
+        .bind(sortable_instant(range.start()))
+        .bind(sortable_instant(range.end()))
         .execute(&self.pool)
         .await
         .map_err(db_err)?;
diff --git a/crates/adapters/sqlite/src/repositories/entry/query.rs b/crates/adapters/sqlite/src/repositories/entry/query.rs
index d3ed078..f0a9afe 100644
--- a/crates/adapters/sqlite/src/repositories/entry/query.rs
+++ b/crates/adapters/sqlite/src/repositories/entry/query.rs
@@ -1,11 +1,11 @@
 use sqlx::SqlitePool;
 
 use domain::activity::ActivityId;
-use domain::entry::{DateRange, Mood, MoodEntry, MoodEntryId};
+use domain::entry::{DateRange, EntrySelection, MoodEntry, MoodEntryId, Pagination};
 use domain::errors::DomainError;
 use domain::user::UserId;
 
-use super::super::shared::db_err;
+use super::super::shared::{db_err, sortable_instant};
 use super::rows::{EntryRow, hydrate_batch, hydrate_single};
 
 pub struct SqliteEntryQueryRepository {
@@ -33,21 +33,11 @@ impl domain::ports::MoodEntryQueryPort for SqliteEntryQueryRepository {
         }
     }
 
-    async fn find_by_user(
-        &self,
-        user_id: &UserId,
-        limit: Option<i64>,
-        offset: Option<i64>,
-    ) -> Result<Vec<MoodEntry>, DomainError> {
-        let limit = limit.unwrap_or(i64::MAX);
-        let offset = offset.unwrap_or(0);
-
+    async fn find_all_by_user(&self, user_id: &UserId) -> Result<Vec<MoodEntry>, DomainError> {
         let rows = sqlx::query_as::<_, EntryRow>(
-            "SELECT * FROM mood_entries WHERE user_id = ? ORDER BY logged_at DESC LIMIT ? OFFSET ?",
+            "SELECT * FROM mood_entries WHERE user_id = ? ORDER BY logged_at DESC",
         )
         .bind(user_id.value().to_string())
-        .bind(limit)
-        .bind(offset)
         .fetch_all(&self.pool)
         .await
         .map_err(db_err)?;
@@ -55,6 +45,47 @@ impl domain::ports::MoodEntryQueryPort for SqliteEntryQueryRepository {
         hydrate_batch(&self.pool, rows).await
     }
 
+    async fn select(
+        &self,
+        selection: &EntrySelection,
+        page: Pagination,
+    ) -> Result<Vec<MoodEntry>, DomainError> {
+        let narrowing = Narrowing::of(selection);
+
+        let sql = format!(
+            "SELECT me.* FROM mood_entries me{} WHERE {} ORDER BY me.logged_at DESC LIMIT ? OFFSET ?",
+            narrowing.join, narrowing.conditions
+        );
+
+        let mut query = sqlx::query_as::<_, EntryRow>(sqlx::AssertSqlSafe(sql));
+        query = narrowing.bind(query);
+
+        let rows = query
+            .bind(page.limit())
+            .bind(page.offset())
+            .fetch_all(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        hydrate_batch(&self.pool, rows).await
+    }
+
+    async fn count(&self, selection: &EntrySelection) -> Result<u64, DomainError> {
+        let narrowing = Narrowing::of(selection);
+
+        let sql = format!(
+            "SELECT COUNT(*) FROM mood_entries me{} WHERE {}",
+            narrowing.join, narrowing.conditions
+        );
+
+        let mut query = sqlx::query_as::<_, (i64,)>(sqlx::AssertSqlSafe(sql));
+        query = narrowing.bind(query);
+
+        let (counted,) = query.fetch_one(&self.pool).await.map_err(db_err)?;
+
+        Ok(u64::try_from(counted).unwrap_or(0))
+    }
+
     async fn find_by_date_range(
         &self,
         user_id: &UserId,
@@ -64,47 +95,79 @@ impl domain::ports::MoodEntryQueryPort for SqliteEntryQueryRepository {
             "SELECT * FROM mood_entries WHERE user_id = ? AND logged_at >= ? AND logged_at <= ? ORDER BY logged_at DESC",
         )
         .bind(user_id.value().to_string())
-        .bind(range.start().to_rfc3339())
-        .bind(range.end().to_rfc3339())
+        .bind(sortable_instant(range.start()))
+        .bind(sortable_instant(range.end()))
         .fetch_all(&self.pool).await.map_err(db_err)?;
 
         hydrate_batch(&self.pool, rows).await
     }
 
-    async fn find_by_mood(
-        &self,
-        user_id: &UserId,
-        mood: Mood,
-    ) -> Result<Vec<MoodEntry>, DomainError> {
-        let rows = sqlx::query_as::<_, EntryRow>(
-            "SELECT * FROM mood_entries WHERE user_id = ? AND mood = ? ORDER BY logged_at DESC",
-        )
-        .bind(user_id.value().to_string())
-        .bind(mood.value() as i32)
-        .fetch_all(&self.pool)
-        .await
-        .map_err(db_err)?;
+    async fn count_tagged_with(&self, activity_id: &ActivityId) -> Result<u64, DomainError> {
+        let (count,): (i64,) =
+            sqlx::query_as("SELECT COUNT(*) FROM entry_activities WHERE activity_id = ?")
+                .bind(activity_id.value().to_string())
+                .fetch_one(&self.pool)
+                .await
+                .map_err(db_err)?;
 
-        hydrate_batch(&self.pool, rows).await
-    }
-
-    async fn find_by_activity(
-        &self,
-        user_id: &UserId,
-        activity_id: &ActivityId,
-    ) -> Result<Vec<MoodEntry>, DomainError> {
-        let rows = sqlx::query_as::<_, EntryRow>(
-            "SELECT me.* FROM mood_entries me
-             INNER JOIN entry_activities ea ON ea.entry_id = me.id
-             WHERE me.user_id = ? AND ea.activity_id = ?
-             ORDER BY me.logged_at DESC",
-        )
-        .bind(user_id.value().to_string())
-        .bind(activity_id.value().to_string())
-        .fetch_all(&self.pool)
-        .await
-        .map_err(db_err)?;
-
-        hydrate_batch(&self.pool, rows).await
+        Ok(u64::try_from(count).unwrap_or(0))
+    }
+}
+
+struct Narrowing<'a> {
+    join: &'static str,
+    conditions: String,
+    selection: &'a EntrySelection,
+}
+
+impl<'a> Narrowing<'a> {
+    fn of(selection: &'a EntrySelection) -> Self {
+        let mut conditions = vec!["me.user_id = ?".to_string()];
+
+        if selection.range().is_some() {
+            conditions.push("me.logged_at >= ?".into());
+            conditions.push("me.logged_at <= ?".into());
+        }
+        if selection.mood().is_some() {
+            conditions.push("me.mood = ?".into());
+        }
+        if selection.activity().is_some() {
+            conditions.push("ea.activity_id = ?".into());
+        }
+        if selection.since().is_some() {
+            conditions.push("me.updated_at > ?".into());
+        }
+
+        Self {
+            join: match selection.activity() {
+                Some(_) => " INNER JOIN entry_activities ea ON ea.entry_id = me.id",
+                None => "",
+            },
+            conditions: conditions.join(" AND "),
+            selection,
+        }
+    }
+
+    fn bind<T>(
+        &self,
+        mut query: sqlx::query::QueryAs<'a, sqlx::Sqlite, T, sqlx::sqlite::SqliteArguments>,
+    ) -> sqlx::query::QueryAs<'a, sqlx::Sqlite, T, sqlx::sqlite::SqliteArguments> {
+        query = query.bind(self.selection.user_id().value().to_string());
+
+        if let Some(range) = self.selection.range() {
+            query = query.bind(sortable_instant(range.start()));
+            query = query.bind(sortable_instant(range.end()));
+        }
+        if let Some(mood) = self.selection.mood() {
+            query = query.bind(i32::from(mood.value()));
+        }
+        if let Some(activity_id) = self.selection.activity() {
+            query = query.bind(activity_id.value().to_string());
+        }
+        if let Some(since) = self.selection.since() {
+            query = query.bind(since.to_rfc3339());
+        }
+
+        query
     }
 }
diff --git a/crates/adapters/sqlite/src/repositories/job/backfill.rs b/crates/adapters/sqlite/src/repositories/job/backfill.rs
index ed58f4f..e25ceee 100644
--- a/crates/adapters/sqlite/src/repositories/job/backfill.rs
+++ b/crates/adapters/sqlite/src/repositories/job/backfill.rs
@@ -48,6 +48,24 @@ impl domain::ports::RecordingBackfillQueryPort for SqliteRecordingBackfillReposi
         Ok(rows.iter().filter_map(readable).collect())
     }
 
+    async fn find_song_without_a_recording(
+        &self,
+        entry_id: &MoodEntryId,
+    ) -> Result<Option<UnidentifiedSong>, DomainError> {
+        let row: Option<UnidentifiedSongRow> = sqlx::query_as(
+            "SELECT s.entry_id, e.user_id, s.title, s.artist
+             FROM entry_song s
+             JOIN mood_entries e ON e.id = s.entry_id
+             WHERE s.recording_id IS NULL AND s.entry_id = ?",
+        )
+        .bind(entry_id.value().to_string())
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(row.as_ref().and_then(readable))
+    }
+
     async fn record_identity(
         &self,
         entry_id: &MoodEntryId,
diff --git a/crates/adapters/sqlite/src/repositories/job/weather.rs b/crates/adapters/sqlite/src/repositories/job/weather.rs
index 9e867cb..d1e6500 100644
--- a/crates/adapters/sqlite/src/repositories/job/weather.rs
+++ b/crates/adapters/sqlite/src/repositories/job/weather.rs
@@ -47,6 +47,25 @@ impl domain::ports::WeatherBacklogQueryPort for SqliteWeatherBacklogRepository {
 
         Ok(rows.iter().filter_map(readable).collect())
     }
+
+    async fn find_place_without_weather(
+        &self,
+        entry_id: &MoodEntryId,
+    ) -> Result<Option<UnwatchedPlace>, DomainError> {
+        let row: Option<UnwatchedPlaceRow> = sqlx::query_as(
+            "SELECT l.entry_id, l.latitude, l.longitude, e.logged_at
+             FROM entry_location l
+             JOIN mood_entries e ON e.id = l.entry_id
+             LEFT JOIN entry_weather w ON w.entry_id = l.entry_id
+             WHERE w.entry_id IS NULL AND l.entry_id = ?",
+        )
+        .bind(entry_id.value().to_string())
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(row.as_ref().and_then(readable))
+    }
 }
 
 fn readable(row: &UnwatchedPlaceRow) -> Option<UnwatchedPlace> {
diff --git a/crates/adapters/sqlite/src/repositories/media/mod.rs b/crates/adapters/sqlite/src/repositories/media/mod.rs
new file mode 100644
index 0000000..893df93
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/media/mod.rs
@@ -0,0 +1,3 @@
+mod ownership;
+
+pub use ownership::SqliteMediaOwnershipRepository;
diff --git a/crates/adapters/sqlite/src/repositories/media/ownership.rs b/crates/adapters/sqlite/src/repositories/media/ownership.rs
new file mode 100644
index 0000000..e1d581e
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/media/ownership.rs
@@ -0,0 +1,95 @@
+use chrono::Utc;
+use sqlx::SqlitePool;
+
+use domain::attachment::{MediaKind, MediaRef, PhotoId, VoiceMemoId};
+use domain::errors::DomainError;
+use domain::user::UserId;
+
+use super::super::shared::db_err;
+
+pub struct SqliteMediaOwnershipRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteMediaOwnershipRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::MediaOwnershipPort for SqliteMediaOwnershipRepository {
+    async fn remember(&self, owner: &UserId, media: MediaRef) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO media_owners (kind, media_id, user_id, created_at)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(kind, media_id) DO UPDATE SET user_id = excluded.user_id",
+        )
+        .bind(media.kind().name())
+        .bind(media.id().to_string())
+        .bind(owner.value().to_string())
+        .bind(Utc::now().to_rfc3339())
+        .execute(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(())
+    }
+
+    async fn owner_of(&self, media: MediaRef) -> Result<Option<UserId>, DomainError> {
+        let found: Option<(String,)> =
+            sqlx::query_as("SELECT user_id FROM media_owners WHERE kind = ? AND media_id = ?")
+                .bind(media.kind().name())
+                .bind(media.id().to_string())
+                .fetch_optional(&self.pool)
+                .await
+                .map_err(db_err)?;
+
+        Ok(found
+            .and_then(|(user_id,)| user_id.parse().ok())
+            .map(UserId::from_uuid))
+    }
+
+    async fn owned_by(&self, owner: &UserId) -> Result<Vec<MediaRef>, DomainError> {
+        let rows: Vec<(String, String)> =
+            sqlx::query_as("SELECT kind, media_id FROM media_owners WHERE user_id = ?")
+                .bind(owner.value().to_string())
+                .fetch_all(&self.pool)
+                .await
+                .map_err(db_err)?;
+
+        Ok(rows.iter().filter_map(readable).collect())
+    }
+
+    async fn forget(&self, media: MediaRef) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM media_owners WHERE kind = ? AND media_id = ?")
+            .bind(media.kind().name())
+            .bind(media.id().to_string())
+            .execute(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        Ok(())
+    }
+
+    async fn forget_all_by_user(&self, owner: &UserId) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM media_owners WHERE user_id = ?")
+            .bind(owner.value().to_string())
+            .execute(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        Ok(())
+    }
+}
+
+fn readable(row: &(String, String)) -> Option<MediaRef> {
+    let (kind, media_id) = row;
+
+    match MediaKind::from_name(kind)? {
+        MediaKind::Photo => Some(MediaRef::from(&PhotoId::from_uuid(media_id.parse().ok()?))),
+        MediaKind::VoiceMemo => Some(MediaRef::from(&VoiceMemoId::from_uuid(
+            media_id.parse().ok()?,
+        ))),
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/mod.rs b/crates/adapters/sqlite/src/repositories/mod.rs
index 9aea842..8928dcd 100644
--- a/crates/adapters/sqlite/src/repositories/mod.rs
+++ b/crates/adapters/sqlite/src/repositories/mod.rs
@@ -8,6 +8,7 @@ mod daily_metric;
 mod dimension;
 mod entry;
 mod job;
+mod media;
 mod provider_connection;
 mod push_subscription;
 mod refresh_session;
@@ -29,6 +30,7 @@ pub use entry::{SqliteEntryCommandRepository, SqliteEntryQueryRepository};
 pub use job::{
     SqliteJobQueueRepository, SqliteRecordingBackfillRepository, SqliteWeatherBacklogRepository,
 };
+pub use media::SqliteMediaOwnershipRepository;
 pub use provider_connection::{
     SqliteProviderConnectionCommandRepository, SqliteProviderConnectionQueryRepository,
 };
diff --git a/crates/adapters/sqlite/src/repositories/push_subscription/command.rs b/crates/adapters/sqlite/src/repositories/push_subscription/command.rs
index b3ee51b..48f7cfd 100644
--- a/crates/adapters/sqlite/src/repositories/push_subscription/command.rs
+++ b/crates/adapters/sqlite/src/repositories/push_subscription/command.rs
@@ -48,8 +48,13 @@ impl domain::ports::PushSubscriptionCommandPort for SqlitePushSubscriptionComman
         Ok(())
     }
 
-    async fn delete_by_endpoint(&self, endpoint: &str) -> Result<(), DomainError> {
-        sqlx::query("DELETE FROM push_subscriptions WHERE endpoint = ?")
+    async fn delete_by_endpoint(
+        &self,
+        user_id: &UserId,
+        endpoint: &str,
+    ) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM push_subscriptions WHERE user_id = ? AND endpoint = ?")
+            .bind(user_id.value().to_string())
             .bind(endpoint)
             .execute(&self.pool)
             .await
diff --git a/crates/adapters/sqlite/src/repositories/reminder/command.rs b/crates/adapters/sqlite/src/repositories/reminder/command.rs
index 8c942aa..19bd15b 100644
--- a/crates/adapters/sqlite/src/repositories/reminder/command.rs
+++ b/crates/adapters/sqlite/src/repositories/reminder/command.rs
@@ -22,13 +22,14 @@ impl SqliteReminderCommandRepository {
 impl domain::ports::ReminderCommandPort for SqliteReminderCommandRepository {
     async fn save(&self, reminder: &Reminder) -> Result<(), DomainError> {
         sqlx::query(
-            "INSERT INTO reminders (id, user_id, monday, tuesday, wednesday, thursday, friday, saturday, sunday, enabled, created_at)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            "INSERT INTO reminders (id, user_id, monday, tuesday, wednesday, thursday, friday, saturday, sunday, enabled, created_at, last_sent_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
              ON CONFLICT(id) DO UPDATE SET
                 monday = excluded.monday, tuesday = excluded.tuesday,
                 wednesday = excluded.wednesday, thursday = excluded.thursday,
                 friday = excluded.friday, saturday = excluded.saturday,
-                sunday = excluded.sunday, enabled = excluded.enabled"
+                sunday = excluded.sunday, enabled = excluded.enabled,
+                last_sent_at = excluded.last_sent_at"
         )
         .bind(reminder.id().value().to_string())
         .bind(reminder.user_id().value().to_string())
@@ -41,6 +42,7 @@ impl domain::ports::ReminderCommandPort for SqliteReminderCommandRepository {
         .bind(reminder.schedule().time_for(Weekday::Sun).map(format_time))
         .bind(reminder.is_enabled())
         .bind(reminder.created_at().to_rfc3339())
+        .bind(reminder.last_sent_at().map(|sent| sent.to_rfc3339()))
         .execute(&self.pool).await.map_err(db_err)?;
         Ok(())
     }
diff --git a/crates/adapters/sqlite/src/repositories/reminder/rows.rs b/crates/adapters/sqlite/src/repositories/reminder/rows.rs
index c449134..09f4845 100644
--- a/crates/adapters/sqlite/src/repositories/reminder/rows.rs
+++ b/crates/adapters/sqlite/src/repositories/reminder/rows.rs
@@ -16,6 +16,7 @@ pub struct ReminderRow {
     pub sunday: Option<String>,
     pub enabled: bool,
     pub created_at: String,
+    pub last_sent_at: Option<String>,
 }
 
 impl ReminderRow {
@@ -36,6 +37,7 @@ impl ReminderRow {
             schedule,
             self.enabled,
             self.created_at.parse().unwrap(),
+            self.last_sent_at.and_then(|sent| sent.parse().ok()),
         )
     }
 }
diff --git a/crates/adapters/sqlite/src/repositories/shared.rs b/crates/adapters/sqlite/src/repositories/shared.rs
index 6de2d1f..793a892 100644
--- a/crates/adapters/sqlite/src/repositories/shared.rs
+++ b/crates/adapters/sqlite/src/repositories/shared.rs
@@ -1,5 +1,13 @@
+use chrono::{DateTime, FixedOffset, SecondsFormat, Utc};
+
 use domain::errors::DomainError;
 
 pub fn db_err(e: sqlx::Error) -> DomainError {
     DomainError::InvalidInput(format!("database error: {e}"))
 }
+
+pub fn sortable_instant(instant: &DateTime<FixedOffset>) -> String {
+    instant
+        .with_timezone(&Utc)
+        .to_rfc3339_opts(SecondsFormat::Secs, false)
+}
diff --git a/crates/adapters/sqlite/tests/api_token_test.rs b/crates/adapters/sqlite/tests/api_token_test.rs
index 935186a..9f0e57f 100644
--- a/crates/adapters/sqlite/tests/api_token_test.rs
+++ b/crates/adapters/sqlite/tests/api_token_test.rs
@@ -1,6 +1,6 @@
 use sqlx::sqlite::SqlitePoolOptions;
 
-use domain::api_token::{ApiToken, TokenDigest};
+use domain::api_token::{ApiToken, TokenDigest, TokenScope, TokenScopes};
 use domain::ports::{ApiTokenCommandPort, ApiTokenQueryPort, CascadeDeletePort, UserCommandPort};
 use domain::provider::ProviderName;
 use domain::testing::test_user;
@@ -33,6 +33,7 @@ fn a_token(owner: &UserId, name: &str, digest: &str) -> ApiToken {
         owner.clone(),
         ProviderName::new(name).unwrap(),
         TokenDigest::from_persistence(digest.into()),
+        TokenScopes::new([TokenScope::WriteMetrics]).unwrap(),
     )
 }
 
@@ -152,7 +153,7 @@ async fn a_row_with_a_scope_this_build_does_not_know_authenticates_nothing() {
     let (pool, user) = a_pool_with_a_user().await;
 
     sqlx::query(
-        "INSERT INTO api_tokens (id, user_id, name, digest, scope, created_at, last_used_at)
+        "INSERT INTO api_tokens (id, user_id, name, digest, scopes, created_at, last_used_at)
          VALUES (?, ?, ?, ?, ?, ?, NULL)",
     )
     .bind(uuid::Uuid::new_v4().to_string())
diff --git a/crates/adapters/sqlite/tests/cascade_test.rs b/crates/adapters/sqlite/tests/cascade_test.rs
index cb99d9f..71f0330 100644
--- a/crates/adapters/sqlite/tests/cascade_test.rs
+++ b/crates/adapters/sqlite/tests/cascade_test.rs
@@ -283,3 +283,170 @@ fn remove(path: &str) {
     let _ = std::fs::remove_file(format!("{path}-wal"));
     let _ = std::fs::remove_file(format!("{path}-shm"));
 }
+
+const EVERY_TABLE_A_USER_FILLS: [&str; 7] = [
+    "mood_entries",
+    "activities",
+    "reminders",
+    "daily_metrics",
+    "cycle_starts",
+    "metric_rejections",
+    "media_owners",
+];
+
+async fn fill_every_table_for(pool: &SqlitePool, user: &User) {
+    let entry = MoodEntry::new(
+        user.id().clone(),
+        Mood::Good,
+        chrono::DateTime::parse_from_rfc3339("2026-08-20T12:00:00+02:00").unwrap(),
+    );
+    SqliteEntryCommandRepository::new(pool.clone())
+        .save(&entry)
+        .await
+        .unwrap();
+
+    domain::ports::ActivityCommandPort::save(
+        &sqlite::repositories::SqliteActivityCommandRepository::new(pool.clone()),
+        &domain::testing::test_activity(user.id().clone(), "gaming"),
+    )
+    .await
+    .unwrap();
+
+    domain::ports::ReminderCommandPort::save(
+        &sqlite::repositories::SqliteReminderCommandRepository::new(pool.clone()),
+        &domain::testing::test_reminder(user.id().clone()),
+    )
+    .await
+    .unwrap();
+
+    domain::ports::DailyMetricCommandPort::save(
+        &sqlite::repositories::SqliteDailyMetricCommandRepository::new(pool.clone()),
+        &[domain::metric::DailyMetric::new(
+            user.id().clone(),
+            a_date("2026-08-20"),
+            domain::metric::MetricValue::Steps(domain::metric::Steps::new(8_412).unwrap()),
+            domain::metric::Source::Manual,
+        )],
+    )
+    .await
+    .unwrap();
+
+    domain::ports::CycleStartCommandPort::record(
+        &sqlite::repositories::SqliteCycleStartRepository::new(pool.clone()),
+        user.id(),
+        &a_date("2026-08-01"),
+    )
+    .await
+    .unwrap();
+
+    domain::ports::RejectionCommandPort::record(
+        &sqlite::repositories::SqliteRejectionRepository::new(pool.clone(), 100),
+        &[domain::rejection::RejectedMetric::new(
+            user.id().clone(),
+            domain::rejection::RejectionOrigin::Import,
+            domain::rejection::RejectionDetail::new(
+                None,
+                Some(a_date("2026-08-19")),
+                "steps",
+                Some(-1),
+            ),
+            String::from("steps cannot be negative"),
+        )],
+    )
+    .await
+    .unwrap();
+
+    domain::ports::MediaOwnershipPort::remember(
+        &sqlite::repositories::SqliteMediaOwnershipRepository::new(pool.clone()),
+        user.id(),
+        (&domain::attachment::PhotoId::generate()).into(),
+    )
+    .await
+    .unwrap();
+}
+
+fn a_date(day: &str) -> domain::entry::Date {
+    domain::entry::Date::from_persistence(day.parse().unwrap())
+}
+
+#[tokio::test]
+async fn clearing_a_users_data_empties_every_table_they_fill() {
+    let path = a_file().await;
+    let pool = sqlite::create_pool(&format!("sqlite://{path}"))
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let user = test_user("alice");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&user)
+        .await
+        .unwrap();
+    fill_every_table_for(&pool, &user).await;
+
+    for table in EVERY_TABLE_A_USER_FILLS {
+        assert_eq!(rows_in(&pool, table).await, 1, "{table} should be seeded");
+    }
+
+    domain::ports::CascadeDeletePort::delete_all_user_data(
+        &sqlite::repositories::SqliteCascadeDeleteRepository::new(pool.clone()),
+        user.id(),
+    )
+    .await
+    .unwrap();
+
+    for table in EVERY_TABLE_A_USER_FILLS {
+        assert_eq!(
+            rows_in(&pool, table).await,
+            0,
+            "{table} still holds data the user asked to be cleared"
+        );
+    }
+
+    let users: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM users")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(users.0, 1, "clearing data is not deleting the account");
+
+    remove(&path);
+}
+
+#[tokio::test]
+async fn deleting_an_account_empties_every_table_they_fill() {
+    let path = a_file().await;
+    let pool = sqlite::create_pool(&format!("sqlite://{path}"))
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let user = test_user("alice");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&user)
+        .await
+        .unwrap();
+    fill_every_table_for(&pool, &user).await;
+
+    domain::ports::CascadeDeletePort::delete_user_account(
+        &sqlite::repositories::SqliteCascadeDeleteRepository::new(pool.clone()),
+        user.id(),
+    )
+    .await
+    .unwrap();
+
+    for table in EVERY_TABLE_A_USER_FILLS {
+        assert_eq!(
+            rows_in(&pool, table).await,
+            0,
+            "{table} outlived the account it belonged to"
+        );
+    }
+
+    let users: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM users")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(users.0, 0);
+
+    remove(&path);
+}
diff --git a/crates/adapters/sqlite/tests/entry_instant_test.rs b/crates/adapters/sqlite/tests/entry_instant_test.rs
new file mode 100644
index 0000000..b8398ed
--- /dev/null
+++ b/crates/adapters/sqlite/tests/entry_instant_test.rs
@@ -0,0 +1,142 @@
+use chrono::{DateTime, FixedOffset};
+use sqlx::SqlitePool;
+
+use domain::entry::{DateRange, Mood, MoodEntry};
+use domain::ports::{MoodEntryCommandPort, MoodEntryQueryPort, UserCommandPort};
+use domain::testing::test_user;
+use domain::user::User;
+
+use sqlite::repositories::{
+    SqliteEntryCommandRepository, SqliteEntryQueryRepository, SqliteUserCommandRepository,
+};
+
+fn a_file() -> String {
+    let name = format!("k-mood-instants-{}.sqlite", uuid::Uuid::new_v4());
+
+    std::env::temp_dir()
+        .join(name)
+        .to_string_lossy()
+        .to_string()
+}
+
+async fn a_pool_with_a_user() -> (SqlitePool, User) {
+    let path = a_file();
+    let pool = sqlite::create_pool(&format!("sqlite://{path}"))
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let user = test_user("alice");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&user)
+        .await
+        .unwrap();
+
+    (pool, user)
+}
+
+fn instant(text: &str) -> DateTime<FixedOffset> {
+    DateTime::parse_from_rfc3339(text).unwrap()
+}
+
+async fn save(pool: &SqlitePool, user: &User, logged_at: &str) -> MoodEntry {
+    let entry = MoodEntry::new(user.id().clone(), Mood::Good, instant(logged_at));
+    SqliteEntryCommandRepository::new(pool.clone())
+        .save(&entry)
+        .await
+        .unwrap();
+
+    entry
+}
+
+async fn stored_text(pool: &SqlitePool, entry: &MoodEntry) -> String {
+    let (held,): (String,) = sqlx::query_as("SELECT logged_at FROM mood_entries WHERE id = ?")
+        .bind(entry.id().value().to_string())
+        .fetch_one(pool)
+        .await
+        .unwrap();
+
+    held
+}
+
+#[tokio::test]
+async fn an_instant_is_held_in_utc_whatever_offset_it_arrived_in() {
+    let (pool, user) = a_pool_with_a_user().await;
+
+    let entry = save(&pool, &user, "2026-08-25T20:00:00+02:00").await;
+
+    assert_eq!(
+        stored_text(&pool, &entry).await,
+        "2026-08-25T18:00:00+00:00",
+        "one canonical form makes the column sortable"
+    );
+}
+
+#[tokio::test]
+async fn an_instant_survives_the_round_trip_unchanged() {
+    let (pool, user) = a_pool_with_a_user().await;
+
+    let entry = save(&pool, &user, "2026-08-25T20:00:00+02:00").await;
+
+    let read = SqliteEntryQueryRepository::new(pool.clone())
+        .find_by_id(entry.id())
+        .await
+        .unwrap()
+        .unwrap();
+
+    assert_eq!(
+        read.logged_at(),
+        entry.logged_at(),
+        "the instant is the fact; the offset it was written in is not"
+    );
+}
+
+#[tokio::test]
+async fn a_range_finds_entries_written_in_other_offsets() {
+    let (pool, user) = a_pool_with_a_user().await;
+
+    let eastern = save(&pool, &user, "2026-08-25T01:30:00+03:00").await;
+    let western = save(&pool, &user, "2026-08-24T21:30:00-04:00").await;
+
+    let whole_of_the_24th_utc = DateRange::new(
+        instant("2026-08-24T00:00:00+00:00"),
+        instant("2026-08-24T23:59:59+00:00"),
+    )
+    .unwrap();
+
+    let found = SqliteEntryQueryRepository::new(pool.clone())
+        .find_by_date_range(user.id(), &whole_of_the_24th_utc)
+        .await
+        .unwrap();
+
+    let ids: Vec<_> = found.iter().map(|entry| entry.id().clone()).collect();
+
+    assert!(
+        ids.contains(eastern.id()),
+        "01:30+03:00 is 22:30Z on the 24th and belongs in the range"
+    );
+    assert!(
+        !ids.contains(western.id()),
+        "21:30-04:00 is 01:30Z on the 25th, so it falls outside the range"
+    );
+}
+
+#[tokio::test]
+async fn entries_come_back_newest_first_across_mixed_offsets() {
+    let (pool, user) = a_pool_with_a_user().await;
+
+    let earlier = save(&pool, &user, "2026-08-25T00:30:00+02:00").await;
+    let later = save(&pool, &user, "2026-08-25T00:00:00+00:00").await;
+
+    let found = SqliteEntryQueryRepository::new(pool.clone())
+        .find_all_by_user(user.id())
+        .await
+        .unwrap();
+
+    assert_eq!(
+        found[0].id(),
+        later.id(),
+        "22:30Z precedes 00:00Z, however the offsets sort as text"
+    );
+    assert_eq!(found[1].id(), earlier.id());
+}
diff --git a/crates/adapters/sqlite/tests/migration_check.rs b/crates/adapters/sqlite/tests/migration_check.rs
index 099c04f..9652d64 100644
--- a/crates/adapters/sqlite/tests/migration_check.rs
+++ b/crates/adapters/sqlite/tests/migration_check.rs
@@ -140,3 +140,106 @@ async fn a_process_joining_a_migrated_database_applies_nothing() {
 
     forget(&path);
 }
+
+#[tokio::test]
+async fn legacy_instants_are_rewritten_into_one_sortable_form() {
+    let pool = fresh_pool().await;
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let user = domain::testing::test_user("alice");
+    domain::ports::UserCommandPort::save(
+        &sqlite::repositories::SqliteUserCommandRepository::new(pool.clone()),
+        &user,
+    )
+    .await
+    .unwrap();
+
+    let legacy = [
+        ("2026-08-25T20:00:00+02:00", "2026-08-25T18:00:00+00:00"),
+        ("2026-08-24T21:30:00-04:00", "2026-08-25T01:30:00+00:00"),
+        ("2026-08-23T09:00:00+00:00", "2026-08-23T09:00:00+00:00"),
+    ];
+
+    for (index, (written, _)) in legacy.iter().enumerate() {
+        sqlx::query(
+            "INSERT INTO mood_entries (id, user_id, mood, logged_at, created_at, updated_at)
+             VALUES (?, ?, 3, ?, ?, ?)",
+        )
+        .bind(format!("00000000-0000-0000-0000-00000000000{index}"))
+        .bind(user.id().value().to_string())
+        .bind(written)
+        .bind(written)
+        .bind(written)
+        .execute(&pool)
+        .await
+        .unwrap();
+    }
+
+    sqlx::raw_sql(include_str!("../src/migrations/015_logged_at_in_utc.sql"))
+        .execute(&pool)
+        .await
+        .unwrap();
+
+    for (index, (written, expected)) in legacy.iter().enumerate() {
+        let (held,): (String,) = sqlx::query_as("SELECT logged_at FROM mood_entries WHERE id = ?")
+            .bind(format!("00000000-0000-0000-0000-00000000000{index}"))
+            .fetch_one(&pool)
+            .await
+            .unwrap();
+
+        assert_eq!(held, *expected, "{written} should normalise to {expected}");
+    }
+}
+
+#[tokio::test]
+async fn a_token_minted_before_scopes_existed_still_writes_metrics() {
+    let pool = fresh_pool().await;
+
+    for (name, sql) in sqlite::migrations_before("016_api_token_scopes") {
+        sqlx::raw_sql(sql)
+            .execute(&pool)
+            .await
+            .unwrap_or_else(|error| panic!("{name} failed: {error}"));
+    }
+
+    let user = domain::testing::test_user("alice");
+    domain::ports::UserCommandPort::save(
+        &sqlite::repositories::SqliteUserCommandRepository::new(pool.clone()),
+        &user,
+    )
+    .await
+    .unwrap();
+
+    sqlx::query(
+        "INSERT INTO api_tokens (id, user_id, name, digest, scope, created_at)
+         VALUES (?, ?, 'tasker', 'abc123', 'writeMetrics', ?)",
+    )
+    .bind(uuid::Uuid::new_v4().to_string())
+    .bind(user.id().value().to_string())
+    .bind(chrono::Utc::now().to_rfc3339())
+    .execute(&pool)
+    .await
+    .unwrap();
+
+    sqlx::raw_sql(include_str!("../src/migrations/016_api_token_scopes.sql"))
+        .execute(&pool)
+        .await
+        .unwrap();
+
+    let found = domain::ports::ApiTokenQueryPort::find_by_digest(
+        &sqlite::repositories::SqliteApiTokenQueryRepository::new(pool.clone()),
+        &domain::api_token::TokenDigest::from_persistence("abc123".into()),
+    )
+    .await
+    .unwrap()
+    .expect("the token should have survived the migration");
+
+    assert!(
+        found.allows(domain::api_token::TokenScope::WriteMetrics),
+        "a token minted before scopes existed keeps doing what it always did"
+    );
+    assert!(
+        !found.allows(domain::api_token::TokenScope::ReadJournal),
+        "and gains nothing it was never granted"
+    );
+}
diff --git a/crates/adapters/web-push/src/lib.rs b/crates/adapters/web-push/src/lib.rs
index c5fbd96..f722bb4 100644
--- a/crates/adapters/web-push/src/lib.rs
+++ b/crates/adapters/web-push/src/lib.rs
@@ -138,7 +138,7 @@ impl WebPushSender {
     async fn forget(&self, sub: &PushSubscription) {
         if let Err(e) = self
             .subscription_command
-            .delete_by_endpoint(sub.endpoint())
+            .delete_by_endpoint(sub.user_id(), sub.endpoint())
             .await
         {
             tracing::warn!(endpoint = sub.endpoint(), error = %e, "failed to drop push subscription");
diff --git a/crates/api-types/src/lib.rs b/crates/api-types/src/lib.rs
index 2d48b8a..141f794 100644
--- a/crates/api-types/src/lib.rs
+++ b/crates/api-types/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod dimension;
 pub mod errors;
 pub mod mappers;
+pub mod params;
 pub mod requests;
 pub mod responses;
diff --git a/crates/api-types/src/mappers/api_token.rs b/crates/api-types/src/mappers/api_token.rs
index fd22111..5c5b565 100644
--- a/crates/api-types/src/mappers/api_token.rs
+++ b/crates/api-types/src/mappers/api_token.rs
@@ -7,7 +7,12 @@ impl From<ApiToken> for ApiTokenResponse {
         Self {
             id: token.id().value().to_string(),
             name: token.name().value().to_string(),
-            scope: token.scope().name().to_string(),
+            scopes: token
+                .scopes()
+                .names()
+                .iter()
+                .map(|n| n.to_string())
+                .collect(),
             created_at: *token.created_at(),
             last_used_at: token.last_used_at().copied(),
         }
diff --git a/crates/api-types/src/mappers/calendar.rs b/crates/api-types/src/mappers/calendar.rs
index 7424002..ac7d75c 100644
--- a/crates/api-types/src/mappers/calendar.rs
+++ b/crates/api-types/src/mappers/calendar.rs
@@ -8,7 +8,7 @@ impl From<CalendarDay> for CalendarDayResponse {
             date: day.date.value(),
             day_mood: day.day_mood.map(|mood| mood.value()),
             mood: day.day_mood.map(|mood| mood.rounded().value()),
-            mood_label: day.day_mood.map(|mood| format!("{:?}", mood.rounded())),
+            mood_label: day.day_mood.map(|mood| mood.rounded().label().to_string()),
             cycle_day: day.cycle_day.map(|cycle| cycle.value()),
             entries: day.entries.into_iter().map(EntryResponse::from).collect(),
         }
diff --git a/crates/api-types/src/mappers/entry.rs b/crates/api-types/src/mappers/entry.rs
index 67f749b..2bb8283 100644
--- a/crates/api-types/src/mappers/entry.rs
+++ b/crates/api-types/src/mappers/entry.rs
@@ -1,18 +1,18 @@
 use chrono::Utc;
 
 use config::EntryConfig;
+use domain::activity::ActivityId;
 use domain::dimension::{ComposedEntry, DimensionValue};
-use domain::entry::{DateRange, Mood, MoodEntryId};
+use domain::entry::{DateRange, EntrySelection, Mood, MoodEntryId, Pagination};
 use domain::user::UserId;
 
 use application::entry::commands::{CreateEntryCommand, UpdateEntryCommand};
-use application::entry::queries::{
-    FilterByActivityQuery, FilterByMoodQuery, ListEntriesQuery, MoodStatsQuery,
-};
+use application::entry::queries::{ListEntriesQuery, MoodStatsQuery};
 
 use crate::dimension::DimensionPayload;
 use crate::errors::ApiValidationError;
-use crate::requests::{CreateEntryRequest, DateRangeParams, ListEntriesParams, UpdateEntryRequest};
+use crate::params::{DateRangeParams, ListEntriesParams};
+use crate::requests::{CreateEntryRequest, UpdateEntryRequest};
 use crate::responses::EntryResponse;
 
 use super::shared::{parse_datetime, validate_content_length};
@@ -45,9 +45,13 @@ impl UpdateEntryRequest {
         entry_id: MoodEntryId,
         config: &EntryConfig,
     ) -> Result<UpdateEntryCommand, ApiValidationError> {
-        let mood = Mood::try_from(self.mood)?;
+        let mood = self.mood.map(Mood::try_from).transpose()?;
         let logged_at = self.logged_at.as_deref().map(parse_datetime).transpose()?;
-        let dimensions = parse_dimensions(self.dimensions, config)?;
+
+        let dimensions = match self.dimensions {
+            Some(named) => Some(parse_dimensions(Some(named), config)?),
+            None => None,
+        };
 
         Ok(UpdateEntryCommand {
             entry_id,
@@ -59,7 +63,11 @@ impl UpdateEntryRequest {
 }
 
 impl ListEntriesParams {
-    pub fn into_query(self, user_id: UserId) -> Result<ListEntriesQuery, ApiValidationError> {
+    pub fn into_query(
+        self,
+        user_id: UserId,
+        config: &EntryConfig,
+    ) -> Result<ListEntriesQuery, ApiValidationError> {
         let range = match (self.from, self.to) {
             (Some(from), Some(to)) => Some(DateRange::new(
                 parse_datetime(&from)?,
@@ -67,15 +75,43 @@ impl ListEntriesParams {
             )?),
             _ => None,
         };
-        Ok(ListEntriesQuery {
-            user_id,
-            range,
-            limit: self.limit,
-            offset: self.offset,
-        })
+
+        let activity = self
+            .activity
+            .as_deref()
+            .map(parse_activity_id)
+            .transpose()?;
+
+        let updated_since = self
+            .updated_since
+            .as_deref()
+            .map(parse_datetime)
+            .transpose()?
+            .map(|instant| instant.with_timezone(&Utc));
+
+        let selection = EntrySelection::everything_of(user_id)
+            .logged_within(range)
+            .of_mood(self.mood.map(Mood::try_from).transpose()?)
+            .tagged_with(activity)
+            .changed_since(updated_since);
+
+        let page = Pagination::new(
+            self.limit.unwrap_or(config.max_entries_per_page),
+            self.offset.unwrap_or(0),
+            config.max_entries_per_page,
+        )?;
+
+        Ok(ListEntriesQuery { selection, page })
     }
 }
 
+fn parse_activity_id(named: &str) -> Result<ActivityId, ApiValidationError> {
+    named
+        .parse()
+        .map(ActivityId::from_uuid)
+        .map_err(|_| ApiValidationError::Invalid(format!("{named} is not an activity id")))
+}
+
 impl DateRangeParams {
     pub fn into_date_range(self) -> Result<DateRange, ApiValidationError> {
         let from = parse_datetime(&self.from)?;
@@ -87,27 +123,6 @@ impl DateRangeParams {
         let range = Some(self.into_date_range()?);
         Ok(MoodStatsQuery { user_id, range })
     }
-
-    pub fn into_mood_filter(
-        self,
-        user_id: UserId,
-        mood: u8,
-    ) -> Result<FilterByMoodQuery, ApiValidationError> {
-        let mood = Mood::try_from(mood)?;
-        Ok(FilterByMoodQuery { user_id, mood })
-    }
-
-    pub fn into_activity_filter(
-        self,
-        user_id: UserId,
-        activity_id: &str,
-    ) -> Result<FilterByActivityQuery, ApiValidationError> {
-        let activity_id = super::shared::parse_uuid(activity_id)?.into();
-        Ok(FilterByActivityQuery {
-            user_id,
-            activity_id,
-        })
-    }
 }
 
 impl From<ComposedEntry> for EntryResponse {
@@ -118,7 +133,7 @@ impl From<ComposedEntry> for EntryResponse {
             id: entry.id().value(),
             user_id: entry.user_id().value(),
             mood: entry.mood().value(),
-            mood_label: format!("{:?}", entry.mood()),
+            mood_label: entry.mood().label().to_string(),
             logged_at: *entry.logged_at(),
             photo_urls: composed
                 .photos()
diff --git a/crates/api-types/src/mappers/job.rs b/crates/api-types/src/mappers/job.rs
new file mode 100644
index 0000000..19e254e
--- /dev/null
+++ b/crates/api-types/src/mappers/job.rs
@@ -0,0 +1,19 @@
+use domain::job::{Job, JobSubject};
+
+use crate::responses::ExhaustedJobResponse;
+
+impl From<Job> for ExhaustedJobResponse {
+    fn from(job: Job) -> Self {
+        let JobSubject::Entry(entry_id) = job.subject();
+
+        Self {
+            id: job.id().value().to_string(),
+            kind: job.kind().name().to_string(),
+            subject: entry_id.value().to_string(),
+            attempts: job.attempts(),
+            last_error: job.last_error().map(|reason| reason.to_string()),
+            enqueued_at: *job.enqueued_at(),
+            updated_at: *job.updated_at(),
+        }
+    }
+}
diff --git a/crates/api-types/src/mappers/media.rs b/crates/api-types/src/mappers/media.rs
index 3c0126a..d76294e 100644
--- a/crates/api-types/src/mappers/media.rs
+++ b/crates/api-types/src/mappers/media.rs
@@ -1,6 +1,6 @@
-use domain::attachment::{PhotoId, VoiceMemoId};
+use domain::attachment::{MediaKind, MediaRef, PhotoId, VoiceMemoId};
 
-use crate::responses::MediaIdResponse;
+use crate::responses::{MediaIdResponse, OwnedMediaResponse};
 
 impl From<PhotoId> for MediaIdResponse {
     fn from(id: PhotoId) -> Self {
@@ -13,3 +13,18 @@ impl From<VoiceMemoId> for MediaIdResponse {
         Self { id: id.value() }
     }
 }
+
+impl From<MediaRef> for OwnedMediaResponse {
+    fn from(media: MediaRef) -> Self {
+        let path = match media.kind() {
+            MediaKind::Photo => "photos",
+            MediaKind::VoiceMemo => "voice-memos",
+        };
+
+        Self {
+            url: format!("/api/v1/media/{path}/{}", media.id()),
+            id: media.id().to_string(),
+            kind: media.kind().name().to_string(),
+        }
+    }
+}
diff --git a/crates/api-types/src/mappers/metric.rs b/crates/api-types/src/mappers/metric.rs
index 5082e2a..fa64e8b 100644
--- a/crates/api-types/src/mappers/metric.rs
+++ b/crates/api-types/src/mappers/metric.rs
@@ -3,7 +3,8 @@ use domain::entry::{Date, DateSpan};
 use domain::metric::{DailyMetric, MetricKind, MetricValue};
 
 use crate::errors::ApiValidationError;
-use crate::requests::{DateSpanParams, MetricPayload};
+use crate::params::DateSpanParams;
+use crate::requests::MetricPayload;
 use crate::responses::DailyMetricResponse;
 
 impl From<DailyMetric> for DailyMetricResponse {
diff --git a/crates/api-types/src/mappers/mod.rs b/crates/api-types/src/mappers/mod.rs
index c0905c3..4730763 100644
--- a/crates/api-types/src/mappers/mod.rs
+++ b/crates/api-types/src/mappers/mod.rs
@@ -6,9 +6,11 @@ mod correlation;
 mod cycle;
 mod entry;
 mod import_metrics;
+mod job;
 mod media;
 mod metric;
 mod provider;
+mod push;
 mod reminder;
 mod restore;
 pub mod shared;
diff --git a/crates/api-types/src/mappers/push.rs b/crates/api-types/src/mappers/push.rs
new file mode 100644
index 0000000..720c171
--- /dev/null
+++ b/crates/api-types/src/mappers/push.rs
@@ -0,0 +1,13 @@
+use domain::push::PushSubscription;
+
+use crate::responses::PushSubscriptionResponse;
+
+impl From<PushSubscription> for PushSubscriptionResponse {
+    fn from(subscription: PushSubscription) -> Self {
+        Self {
+            id: subscription.id().value().to_string(),
+            endpoint: subscription.endpoint().to_string(),
+            created_at: *subscription.created_at(),
+        }
+    }
+}
diff --git a/crates/api-types/src/mappers/restore.rs b/crates/api-types/src/mappers/restore.rs
index 3341c3f..712a53e 100644
--- a/crates/api-types/src/mappers/restore.rs
+++ b/crates/api-types/src/mappers/restore.rs
@@ -11,6 +11,7 @@ impl From<RestoreOutcome> for RestoreOutcomeResponse {
             activities: outcome.activities,
             reminders: outcome.reminders,
             media: outcome.media,
+            skipped: outcome.skipped,
             unreadable: outcome.unreadable,
         }
     }
diff --git a/crates/api-types/src/mappers/stats.rs b/crates/api-types/src/mappers/stats.rs
index 9de40ab..f14dbd4 100644
--- a/crates/api-types/src/mappers/stats.rs
+++ b/crates/api-types/src/mappers/stats.rs
@@ -1,6 +1,6 @@
 use application::entry::use_cases::get_mood_stats::MoodStats;
 
-use crate::responses::{MoodFrequency, MoodStatsResponse};
+use crate::responses::{MoodFrequencyResponse, MoodStatsResponse};
 
 impl From<MoodStats> for MoodStatsResponse {
     fn from(stats: MoodStats) -> Self {
@@ -9,14 +9,16 @@ impl From<MoodStats> for MoodStatsResponse {
             frequency: stats
                 .frequency
                 .into_iter()
-                .map(|(mood, count)| MoodFrequency {
+                .map(|(mood, count)| MoodFrequencyResponse {
                     mood: mood.value(),
-                    mood_label: format!("{mood:?}"),
+                    mood_label: mood.label().to_string(),
                     count,
                 })
                 .collect(),
             current_streak: stats.current_streak,
             total_entries: stats.total_entries,
+            first_logged_on: stats.first_logged_on.map(|date| date.to_string()),
+            last_logged_on: stats.last_logged_on.map(|date| date.to_string()),
         }
     }
 }
diff --git a/crates/api-types/src/params/activity.rs b/crates/api-types/src/params/activity.rs
new file mode 100644
index 0000000..2973070
--- /dev/null
+++ b/crates/api-types/src/params/activity.rs
@@ -0,0 +1,5 @@
+#[derive(Debug, Default, serde::Deserialize, utoipa::ToSchema, utoipa::IntoParams)]
+#[serde(rename_all = "camelCase")]
+pub struct ListActivitiesParams {
+    pub include_archived: Option<bool>,
+}
diff --git a/crates/api-types/src/params/entry.rs b/crates/api-types/src/params/entry.rs
new file mode 100644
index 0000000..5ebaed9
--- /dev/null
+++ b/crates/api-types/src/params/entry.rs
@@ -0,0 +1,18 @@
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema, utoipa::IntoParams)]
+#[serde(rename_all = "camelCase")]
+pub struct ListEntriesParams {
+    pub from: Option<String>,
+    pub to: Option<String>,
+    pub mood: Option<u8>,
+    pub activity: Option<String>,
+    pub updated_since: Option<String>,
+    pub limit: Option<i64>,
+    pub offset: Option<i64>,
+}
+
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema, utoipa::IntoParams)]
+#[serde(rename_all = "camelCase")]
+pub struct DateRangeParams {
+    pub from: String,
+    pub to: String,
+}
diff --git a/crates/api-types/src/params/metric.rs b/crates/api-types/src/params/metric.rs
new file mode 100644
index 0000000..87f6415
--- /dev/null
+++ b/crates/api-types/src/params/metric.rs
@@ -0,0 +1,6 @@
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema, utoipa::IntoParams)]
+#[serde(rename_all = "camelCase")]
+pub struct DateSpanParams {
+    pub from: String,
+    pub to: String,
+}
diff --git a/crates/api-types/src/params/mod.rs b/crates/api-types/src/params/mod.rs
new file mode 100644
index 0000000..5c1e33b
--- /dev/null
+++ b/crates/api-types/src/params/mod.rs
@@ -0,0 +1,7 @@
+mod activity;
+mod entry;
+mod metric;
+
+pub use activity::ListActivitiesParams;
+pub use entry::{DateRangeParams, ListEntriesParams};
+pub use metric::DateSpanParams;
diff --git a/crates/api-types/src/requests/api_token.rs b/crates/api-types/src/requests/api_token.rs
index 3d139dc..8a0a703 100644
--- a/crates/api-types/src/requests/api_token.rs
+++ b/crates/api-types/src/requests/api_token.rs
@@ -2,4 +2,5 @@
 #[serde(rename_all = "camelCase")]
 pub struct MintApiTokenRequest {
     pub name: String,
+    pub scopes: Vec<String>,
 }
diff --git a/crates/api-types/src/requests/entry.rs b/crates/api-types/src/requests/entry.rs
index 52b2a76..333b504 100644
--- a/crates/api-types/src/requests/entry.rs
+++ b/crates/api-types/src/requests/entry.rs
@@ -1,33 +1,25 @@
+use crate::dimension::DimensionPayload;
+
 #[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct CreateEntryRequest {
     pub mood: u8,
     pub logged_at: Option<String>,
-    pub dimensions: Option<Vec<crate::dimension::DimensionPayload>>,
+    pub dimensions: Option<Vec<DimensionPayload>>,
+}
+
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateEntriesRequest {
+    pub entries: Vec<CreateEntryRequest>,
 }
 
 #[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct UpdateEntryRequest {
-    pub mood: u8,
+    pub mood: Option<u8>,
     pub logged_at: Option<String>,
-    pub dimensions: Option<Vec<crate::dimension::DimensionPayload>>,
-}
-
-#[derive(Debug, serde::Deserialize, utoipa::ToSchema, utoipa::IntoParams)]
-#[serde(rename_all = "camelCase")]
-pub struct ListEntriesParams {
-    pub from: Option<String>,
-    pub to: Option<String>,
-    pub limit: Option<i64>,
-    pub offset: Option<i64>,
-}
-
-#[derive(Debug, serde::Deserialize, utoipa::ToSchema, utoipa::IntoParams)]
-#[serde(rename_all = "camelCase")]
-pub struct DateRangeParams {
-    pub from: String,
-    pub to: String,
+    pub dimensions: Option<Vec<DimensionPayload>>,
 }
 
 #[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
diff --git a/crates/api-types/src/requests/metric.rs b/crates/api-types/src/requests/metric.rs
index c06f3a0..59f2022 100644
--- a/crates/api-types/src/requests/metric.rs
+++ b/crates/api-types/src/requests/metric.rs
@@ -10,10 +10,3 @@ pub struct MetricPayload {
     pub kind: String,
     pub value: Option<i64>,
 }
-
-#[derive(Debug, serde::Deserialize, utoipa::ToSchema, utoipa::IntoParams)]
-#[serde(rename_all = "camelCase")]
-pub struct DateSpanParams {
-    pub from: String,
-    pub to: String,
-}
diff --git a/crates/api-types/src/requests/mod.rs b/crates/api-types/src/requests/mod.rs
index 755f165..0689801 100644
--- a/crates/api-types/src/requests/mod.rs
+++ b/crates/api-types/src/requests/mod.rs
@@ -13,11 +13,10 @@ pub use activity::{CreateActivityRequest, RenameActivityRequest, SetCategoryRequ
 pub use api_token::MintApiTokenRequest;
 pub use cycle::SetPreferencesRequest;
 pub use entry::{
-    CreateEntryRequest, DateRangeParams, ListEntriesParams, ReplaceActivityRequest,
-    UpdateEntryRequest,
+    CreateEntriesRequest, CreateEntryRequest, ReplaceActivityRequest, UpdateEntryRequest,
 };
 pub use import::{ImportDailyMetricsRequest, ImportedDayPayload, ImportedMetricPayload};
-pub use metric::{DateSpanParams, MetricPayload, SetDailyMetricsRequest};
+pub use metric::{MetricPayload, SetDailyMetricsRequest};
 pub use provider::ConnectProviderRequest;
 pub use push::{PushSubscribeRequest, PushUnsubscribeRequest};
 pub use reminder::{CreateReminderRequest, UpdateReminderRequest};
diff --git a/crates/api-types/src/requests/push.rs b/crates/api-types/src/requests/push.rs
index 39bee63..6f298f2 100644
--- a/crates/api-types/src/requests/push.rs
+++ b/crates/api-types/src/requests/push.rs
@@ -25,8 +25,9 @@ pub struct PushUnsubscribeRequest {
 }
 
 impl PushUnsubscribeRequest {
-    pub fn into_command(self) -> UnsubscribePushCommand {
+    pub fn into_command(self, user_id: UserId) -> UnsubscribePushCommand {
         UnsubscribePushCommand {
+            user_id,
             endpoint: self.endpoint,
         }
     }
diff --git a/crates/api-types/src/responses/api_token.rs b/crates/api-types/src/responses/api_token.rs
index 9055efc..8c893a2 100644
--- a/crates/api-types/src/responses/api_token.rs
+++ b/crates/api-types/src/responses/api_token.rs
@@ -5,7 +5,7 @@ use chrono::{DateTime, Utc};
 pub struct ApiTokenResponse {
     pub id: String,
     pub name: String,
-    pub scope: String,
+    pub scopes: Vec<String>,
     pub created_at: DateTime<Utc>,
     pub last_used_at: Option<DateTime<Utc>>,
 }
diff --git a/crates/api-types/src/responses/auth.rs b/crates/api-types/src/responses/auth.rs
new file mode 100644
index 0000000..920258b
--- /dev/null
+++ b/crates/api-types/src/responses/auth.rs
@@ -0,0 +1,26 @@
+use chrono::{DateTime, Utc};
+
+use super::UserResponse;
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct SignedInResponse {
+    pub access_token: String,
+    pub refresh_token: String,
+    pub expires_at: DateTime<Utc>,
+    pub user: UserResponse,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct RefreshedResponse {
+    pub access_token: String,
+    pub refresh_token: String,
+    pub expires_at: DateTime<Utc>,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct VapidKeyResponse {
+    pub public_key: String,
+}
diff --git a/crates/api-types/src/responses/bulk.rs b/crates/api-types/src/responses/bulk.rs
deleted file mode 100644
index 0143343..0000000
--- a/crates/api-types/src/responses/bulk.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use uuid::Uuid;
-
-#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct BulkActionResponse {
-    pub affected_count: u64,
-}
-
-#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ImportResultResponse {
-    pub imported: u64,
-    pub skipped: u64,
-    pub errors: Vec<String>,
-}
-
-#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct MediaIdResponse {
-    pub id: Uuid,
-}
diff --git a/crates/api-types/src/responses/bulk_action.rs b/crates/api-types/src/responses/bulk_action.rs
new file mode 100644
index 0000000..c196206
--- /dev/null
+++ b/crates/api-types/src/responses/bulk_action.rs
@@ -0,0 +1,5 @@
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct BulkActionResponse {
+    pub affected_count: u64,
+}
diff --git a/crates/api-types/src/responses/error.rs b/crates/api-types/src/responses/error.rs
new file mode 100644
index 0000000..75a7caa
--- /dev/null
+++ b/crates/api-types/src/responses/error.rs
@@ -0,0 +1,23 @@
+#[derive(Debug, serde::Serialize, serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ErrorResponse {
+    pub error: ErrorDetailResponse,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ErrorDetailResponse {
+    pub code: String,
+    pub message: String,
+}
+
+impl ErrorResponse {
+    pub fn new(code: &str, message: impl Into<String>) -> Self {
+        Self {
+            error: ErrorDetailResponse {
+                code: code.to_string(),
+                message: message.into(),
+            },
+        }
+    }
+}
diff --git a/crates/api-types/src/responses/import_result.rs b/crates/api-types/src/responses/import_result.rs
new file mode 100644
index 0000000..af9a3c8
--- /dev/null
+++ b/crates/api-types/src/responses/import_result.rs
@@ -0,0 +1,7 @@
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ImportResultResponse {
+    pub imported: u64,
+    pub skipped: u64,
+    pub errors: Vec<String>,
+}
diff --git a/crates/api-types/src/responses/job.rs b/crates/api-types/src/responses/job.rs
new file mode 100644
index 0000000..da81b13
--- /dev/null
+++ b/crates/api-types/src/responses/job.rs
@@ -0,0 +1,13 @@
+use chrono::{DateTime, Utc};
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ExhaustedJobResponse {
+    pub id: String,
+    pub kind: String,
+    pub subject: String,
+    pub attempts: u32,
+    pub last_error: Option<String>,
+    pub enqueued_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
diff --git a/crates/api-types/src/responses/media.rs b/crates/api-types/src/responses/media.rs
new file mode 100644
index 0000000..ca76488
--- /dev/null
+++ b/crates/api-types/src/responses/media.rs
@@ -0,0 +1,13 @@
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct MediaIdResponse {
+    pub id: uuid::Uuid,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct OwnedMediaResponse {
+    pub id: String,
+    pub kind: String,
+    pub url: String,
+}
diff --git a/crates/api-types/src/responses/mod.rs b/crates/api-types/src/responses/mod.rs
index 1bc0fc4..64f04d3 100644
--- a/crates/api-types/src/responses/mod.rs
+++ b/crates/api-types/src/responses/mod.rs
@@ -1,31 +1,49 @@
 mod activity;
 mod api_token;
-mod bulk;
+mod auth;
+mod bulk_action;
 mod calendar;
 mod correlation;
 mod cycle;
 mod entry;
+mod error;
 mod import;
+mod import_result;
+mod job;
+mod media;
 mod metric;
+mod page;
 mod provider;
+mod push;
 mod reminder;
 mod restore;
+mod server;
 mod stats;
 mod user;
 
 pub use activity::ActivityResponse;
 pub use api_token::{ApiTokenResponse, MintedApiTokenResponse};
-pub use bulk::{BulkActionResponse, ImportResultResponse, MediaIdResponse};
+pub use auth::{RefreshedResponse, SignedInResponse, VapidKeyResponse};
+pub use bulk_action::BulkActionResponse;
 pub use calendar::CalendarDayResponse;
 pub use correlation::{
     AgreementResponse, CorrelationInputResponse, CorrelationRowResponse, StrategyScoreResponse,
 };
 pub use cycle::{CyclePositionResponse, CycleViewResponse, PreferencesResponse};
 pub use entry::EntryResponse;
+pub use error::{ErrorDetailResponse, ErrorResponse};
 pub use import::{ImportOutcomeResponse, RejectedMetricResponse, RejectionResponse};
+pub use import_result::ImportResultResponse;
+pub use job::ExhaustedJobResponse;
+pub use media::{MediaIdResponse, OwnedMediaResponse};
 pub use metric::DailyMetricResponse;
+pub use page::EntryPageResponse;
 pub use provider::ProviderConnectionResponse;
+pub use push::PushSubscriptionResponse;
 pub use reminder::{DayScheduleResponse, ReminderResponse};
 pub use restore::RestoreOutcomeResponse;
-pub use stats::{MoodFrequency, MoodStatsResponse};
+pub use server::{
+    MetricKindResponse, MoodResponse, ServerInfoResponse, ServerLimitsResponse, TokenScopeResponse,
+};
+pub use stats::{MoodFrequencyResponse, MoodStatsResponse};
 pub use user::UserResponse;
diff --git a/crates/api-types/src/responses/page.rs b/crates/api-types/src/responses/page.rs
new file mode 100644
index 0000000..547a408
--- /dev/null
+++ b/crates/api-types/src/responses/page.rs
@@ -0,0 +1,11 @@
+use super::EntryResponse;
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct EntryPageResponse {
+    pub items: Vec<EntryResponse>,
+    pub total: u64,
+    pub limit: i64,
+    pub offset: i64,
+    pub has_more: bool,
+}
diff --git a/crates/api-types/src/responses/push.rs b/crates/api-types/src/responses/push.rs
new file mode 100644
index 0000000..5d53492
--- /dev/null
+++ b/crates/api-types/src/responses/push.rs
@@ -0,0 +1,9 @@
+use chrono::{DateTime, Utc};
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct PushSubscriptionResponse {
+    pub id: String,
+    pub endpoint: String,
+    pub created_at: DateTime<Utc>,
+}
diff --git a/crates/api-types/src/responses/restore.rs b/crates/api-types/src/responses/restore.rs
index cc57706..c11a348 100644
--- a/crates/api-types/src/responses/restore.rs
+++ b/crates/api-types/src/responses/restore.rs
@@ -7,5 +7,6 @@ pub struct RestoreOutcomeResponse {
     pub activities: usize,
     pub reminders: usize,
     pub media: usize,
+    pub skipped: usize,
     pub unreadable: Vec<String>,
 }
diff --git a/crates/api-types/src/responses/server.rs b/crates/api-types/src/responses/server.rs
new file mode 100644
index 0000000..52260c8
--- /dev/null
+++ b/crates/api-types/src/responses/server.rs
@@ -0,0 +1,50 @@
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ServerInfoResponse {
+    pub version: String,
+    pub registration_open: bool,
+    pub push_enabled: bool,
+    pub weather_enabled: bool,
+    pub now_playing_provider: Option<String>,
+    pub access_token_ttl_seconds: u64,
+    pub limits: ServerLimitsResponse,
+    pub token_scopes: Vec<TokenScopeResponse>,
+    pub metric_kinds: Vec<MetricKindResponse>,
+    pub moods: Vec<MoodResponse>,
+    pub weather_conditions: Vec<String>,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ServerLimitsResponse {
+    pub max_body_size: usize,
+    pub max_content_length: usize,
+    pub max_photos: usize,
+    pub max_voice_memos: usize,
+    pub max_activities_per_entry: usize,
+    pub max_entries_per_page: i64,
+    pub max_import_days: usize,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct TokenScopeResponse {
+    pub name: String,
+    pub describes: String,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct MetricKindResponse {
+    pub name: String,
+    pub unit: String,
+    pub minimum: i64,
+    pub maximum: i64,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct MoodResponse {
+    pub value: u8,
+    pub label: String,
+}
diff --git a/crates/api-types/src/responses/stats.rs b/crates/api-types/src/responses/stats.rs
index b65979b..9792028 100644
--- a/crates/api-types/src/responses/stats.rs
+++ b/crates/api-types/src/responses/stats.rs
@@ -1,6 +1,6 @@
 #[derive(Debug, serde::Serialize, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct MoodFrequency {
+pub struct MoodFrequencyResponse {
     pub mood: u8,
     pub mood_label: String,
     pub count: usize,
@@ -10,7 +10,9 @@ pub struct MoodFrequency {
 #[serde(rename_all = "camelCase")]
 pub struct MoodStatsResponse {
     pub average: Option<f64>,
-    pub frequency: Vec<MoodFrequency>,
+    pub frequency: Vec<MoodFrequencyResponse>,
     pub current_streak: usize,
     pub total_entries: usize,
+    pub first_logged_on: Option<String>,
+    pub last_logged_on: Option<String>,
 }
diff --git a/crates/application/src/activity/use_cases/delete_activity.rs b/crates/application/src/activity/use_cases/delete_activity.rs
index 270ab19..7f2f82e 100644
--- a/crates/application/src/activity/use_cases/delete_activity.rs
+++ b/crates/application/src/activity/use_cases/delete_activity.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use domain::activity::ActivityId;
 use domain::errors::DomainError;
-use domain::ports::{ActivityCommandPort, ActivityQueryPort};
+use domain::ports::{ActivityCommandPort, ActivityQueryPort, MoodEntryQueryPort};
 use domain::user::UserId;
 
 use crate::authorization::verify_ownership;
@@ -11,6 +11,7 @@ use crate::errors::ApplicationError;
 pub struct Deps {
     pub command: Arc<dyn ActivityCommandPort>,
     pub query: Arc<dyn ActivityQueryPort>,
+    pub entries: Arc<dyn MoodEntryQueryPort>,
 }
 
 #[tracing::instrument(skip(deps))]
@@ -26,8 +27,24 @@ pub async fn execute(
         .ok_or_else(|| DomainError::NotFound("activity not found".into()))?;
 
     verify_ownership(activity.user_id(), &caller_id)?;
+    refuse_while_entries_still_wear_it(&activity_id, deps).await?;
 
     deps.command.delete(&activity_id).await?;
 
     Ok(())
 }
+
+async fn refuse_while_entries_still_wear_it(
+    activity_id: &ActivityId,
+    deps: &Deps,
+) -> Result<(), ApplicationError> {
+    let tagged = deps.entries.count_tagged_with(activity_id).await?;
+
+    if tagged > 0 {
+        return Err(ApplicationError::Validation(format!(
+            "{tagged} entries are tagged with this activity, so deleting it would rewrite them: archive it instead"
+        )));
+    }
+
+    Ok(())
+}
diff --git a/crates/application/src/api_token/commands.rs b/crates/application/src/api_token/commands.rs
index 6aecd30..7c54691 100644
--- a/crates/application/src/api_token/commands.rs
+++ b/crates/application/src/api_token/commands.rs
@@ -1,3 +1,4 @@
+use domain::api_token::TokenScopes;
 use domain::provider::ProviderName;
 use domain::user::UserId;
 
@@ -5,4 +6,5 @@ use domain::user::UserId;
 pub struct MintApiTokenCommand {
     pub user_id: UserId,
     pub name: ProviderName,
+    pub scopes: TokenScopes,
 }
diff --git a/crates/application/src/api_token/use_cases/authenticate_api_token.rs b/crates/application/src/api_token/use_cases/authenticate_api_token.rs
index 451efd5..d98235e 100644
--- a/crates/application/src/api_token/use_cases/authenticate_api_token.rs
+++ b/crates/application/src/api_token/use_cases/authenticate_api_token.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use domain::api_token::ApiToken;
+use domain::api_token::{ApiToken, TokenScope};
 use domain::errors::DomainError;
 use domain::ports::{ApiTokenCommandPort, ApiTokenQueryPort, ApiTokenSecretPort};
 
@@ -13,7 +13,11 @@ pub struct Deps {
 }
 
 #[tracing::instrument(skip(secret, deps))]
-pub async fn execute(secret: &str, deps: &Deps) -> Result<ApiToken, ApplicationError> {
+pub async fn execute(
+    secret: &str,
+    needed: TokenScope,
+    deps: &Deps,
+) -> Result<ApiToken, ApplicationError> {
     let digest = deps.secrets.digest(secret);
 
     let token = deps
@@ -22,6 +26,17 @@ pub async fn execute(secret: &str, deps: &Deps) -> Result<ApiToken, ApplicationE
         .await?
         .ok_or_else(|| DomainError::Unauthorized("this api token is not valid".into()))?;
 
+    if !token.allows(needed) {
+        tracing::warn!(
+            token_id = %token.id(),
+            %needed,
+            granted = %token.scopes(),
+            "an api token was presented for something it does not grant"
+        );
+
+        return Err(DomainError::Forbidden(format!("this token does not grant {needed}")).into());
+    }
+
     if let Err(error) = deps.command.mark_used(token.id()).await {
         tracing::warn!(token_id = %token.id(), %error, "could not record that a token was used");
     }
diff --git a/crates/application/src/api_token/use_cases/mint_api_token.rs b/crates/application/src/api_token/use_cases/mint_api_token.rs
index a7fb9cc..8f28623 100644
--- a/crates/application/src/api_token/use_cases/mint_api_token.rs
+++ b/crates/application/src/api_token/use_cases/mint_api_token.rs
@@ -19,10 +19,15 @@ pub async fn execute(
     let secret = deps.secrets.mint();
     let digest = deps.secrets.digest(&secret);
 
-    let token = ApiToken::new(command.user_id, command.name, digest);
+    let token = ApiToken::new(command.user_id, command.name, digest, command.scopes);
     deps.command.save(&token).await?;
 
-    tracing::info!(token_id = %token.id(), name = token.name().value(), "minted an api token");
+    tracing::info!(
+        token_id = %token.id(),
+        name = token.name().value(),
+        scopes = %token.scopes(),
+        "minted an api token"
+    );
 
     Ok(MintedApiToken::new(token, secret))
 }
diff --git a/crates/application/src/correlation/use_cases/get_correlations.rs b/crates/application/src/correlation/use_cases/get_correlations.rs
index 84a329e..26755ac 100644
--- a/crates/application/src/correlation/use_cases/get_correlations.rs
+++ b/crates/application/src/correlation/use_cases/get_correlations.rs
@@ -6,18 +6,20 @@ use domain::correlation::{
     Adjustment, Agreement, Coefficient, CorrelationInput, CorrelationStrategy, Observation, PValue,
     Tested,
 };
+use domain::dimension::ComposedEntry;
 use domain::entry::{Date, DayMood};
 use domain::metric::MetricKind;
 use domain::moon::MoonPhase;
 use domain::ports::{
-    ActivityQueryPort, CycleStartQueryPort, DailyMetricQueryPort, MoodEntryQueryPort,
-    UserPreferencesQueryPort, UserQueryPort,
+    ActivityQueryPort, CycleStartQueryPort, DailyMetricQueryPort, EntryDimensionPort,
+    MoodEntryQueryPort, UserPreferencesQueryPort, UserQueryPort,
 };
-use domain::user::{Timezone, UserId};
+use domain::user::Timezone;
 
 use crate::correlation::queries::CorrelationQuery;
 use crate::cycle::use_cases::read_cycle::calendar_of;
 use crate::day::{date_of, day_moods, instants_of, timezone_for};
+use crate::entry::composition::EntryComposer;
 use crate::errors::ApplicationError;
 use crate::user::preferences::preferences_of;
 
@@ -43,7 +45,8 @@ pub struct Deps {
     pub metrics: Arc<dyn DailyMetricQueryPort>,
     pub activities: Arc<dyn ActivityQueryPort>,
     pub cycles: Arc<dyn CycleStartQueryPort>,
-    pub weather_store: Arc<dyn domain::ports::EntryDimensionPort>,
+    pub weather_store: Arc<dyn EntryDimensionPort>,
+    pub activity_store: Arc<dyn EntryDimensionPort>,
     pub preferences: Arc<dyn UserPreferencesQueryPort>,
     pub users: Arc<dyn UserQueryPort>,
 }
@@ -63,6 +66,13 @@ pub async fn execute(
     let mut moods = day_moods(&entries, &timezone);
     moods.retain(|date, _| query.span.contains(date));
 
+    let composed = EntryComposer::new(vec![
+        deps.weather_store.clone(),
+        deps.activity_store.clone(),
+    ])
+    .compose(entries)
+    .await?;
+
     let mut scored = metric_rows(&query, deps, &moods).await?;
 
     let lunar = paired(&moods, |date| Some(MoonPhase::on(date).illumination()));
@@ -77,9 +87,9 @@ pub async fn execute(
         scored.push(cycle);
     }
 
-    scored.push(temperature_row(&query, deps, &moods, &timezone).await?);
+    scored.push(temperature_row(&query, &composed, &moods, &timezone));
 
-    scored.extend(activity_rows(&query, deps, &moods, &timezone).await?);
+    scored.extend(activity_rows(&query, deps, &composed, &moods, &timezone).await?);
 
     Ok(mark_what_holds_up(scored, query.false_discovery_rate))
 }
@@ -144,56 +154,60 @@ async fn cycle_row(
     )))
 }
 
-async fn temperature_row(
+fn temperature_row(
     query: &CorrelationQuery,
-    deps: &Deps,
+    composed: &[ComposedEntry],
     moods: &BTreeMap<Date, DayMood>,
     timezone: &Timezone,
-) -> Result<Pending, ApplicationError> {
-    let entries = deps
-        .entries
-        .find_by_date_range(&query.user_id, &instants_of(&query.span))
-        .await?;
-
-    let composed = crate::entry::composition::EntryComposer::new(vec![deps.weather_store.clone()])
-        .compose(entries)
-        .await?;
-
-    let mut warmest: BTreeMap<Date, f64> = BTreeMap::new();
-    for entry in &composed {
-        if let Some(weather) = entry.weather() {
-            warmest.insert(
-                date_of(&entry.entry, timezone),
-                weather.temperature().value(),
-            );
-        }
-    }
-
+) -> Pending {
+    let warmest = warmest_by_date(composed, timezone);
     let observations = paired(moods, |date| warmest.get(date).copied());
 
-    Ok(row(
+    row(
         CorrelationInput::Temperature,
         None,
         &observations,
         query.minimum_sample_size,
-    ))
+    )
+}
+
+fn warmest_by_date(composed: &[ComposedEntry], timezone: &Timezone) -> BTreeMap<Date, f64> {
+    let mut warmest: BTreeMap<Date, f64> = BTreeMap::new();
+
+    for entry in composed {
+        let Some(weather) = entry.weather() else {
+            continue;
+        };
+
+        let date = date_of(&entry.entry, timezone);
+        let temperature = weather.temperature().value();
+
+        warmest
+            .entry(date)
+            .and_modify(|highest| *highest = highest.max(temperature))
+            .or_insert(temperature);
+    }
+
+    warmest
 }
 
 async fn activity_rows(
     query: &CorrelationQuery,
     deps: &Deps,
+    composed: &[ComposedEntry],
     moods: &BTreeMap<Date, DayMood>,
     timezone: &Timezone,
 ) -> Result<Vec<Pending>, ApplicationError> {
-    let catalog = deps.activities.find_active_by_user(&query.user_id).await?;
-    let mut rows = Vec::with_capacity(catalog.len());
+    let catalogue = deps.activities.find_active_by_user(&query.user_id).await?;
+    let tagged = days_tagged_by_activity(composed, timezone);
+    let mut rows = Vec::with_capacity(catalogue.len());
 
-    for activity in catalog {
-        let days = days_tagged_with(&query.user_id, activity.id(), deps, timezone).await?;
+    for activity in catalogue {
+        let days = tagged.get(activity.id());
 
-        if never_logged(&days, moods) {
+        let Some(days) = days.filter(|days| ever_logged(days, moods)) else {
             continue;
-        }
+        };
 
         let observations = paired(moods, |date| {
             Some(if days.contains(date) { PRESENT } else { ABSENT })
@@ -210,22 +224,25 @@ async fn activity_rows(
     Ok(rows)
 }
 
-fn never_logged(days: &BTreeSet<Date>, moods: &BTreeMap<Date, DayMood>) -> bool {
-    !days.iter().any(|date| moods.contains_key(date))
+fn days_tagged_by_activity(
+    composed: &[ComposedEntry],
+    timezone: &Timezone,
+) -> BTreeMap<ActivityId, BTreeSet<Date>> {
+    let mut tagged: BTreeMap<ActivityId, BTreeSet<Date>> = BTreeMap::new();
+
+    for entry in composed {
+        let date = date_of(&entry.entry, timezone);
+
+        for activity_id in entry.activities() {
+            tagged.entry(activity_id.clone()).or_default().insert(date);
+        }
+    }
+
+    tagged
 }
 
-async fn days_tagged_with(
-    user_id: &UserId,
-    activity_id: &ActivityId,
-    deps: &Deps,
-    timezone: &Timezone,
-) -> Result<BTreeSet<Date>, ApplicationError> {
-    let tagged = deps.entries.find_by_activity(user_id, activity_id).await?;
-
-    Ok(tagged
-        .iter()
-        .map(|entry| date_of(entry, timezone))
-        .collect())
+fn ever_logged(days: &BTreeSet<Date>, moods: &BTreeMap<Date, DayMood>) -> bool {
+    days.iter().any(|date| moods.contains_key(date))
 }
 
 fn paired(
@@ -249,15 +266,14 @@ fn mark_what_holds_up(pending: Vec<Pending>, false_discovery_rate: f64) -> Vec<C
 
     let tested: Vec<Tested> = places
         .iter()
-        .map(|(row_index, score_index)| {
+        .filter_map(|(row_index, score_index)| {
             let entry = &pending[*row_index];
 
-            Tested {
+            Some(Tested {
                 family: entry.row.input.family(),
                 strategy: entry.row.scores[*score_index].strategy,
-                p_value: entry.significance[*score_index]
-                    .expect("only places with a p-value are collected"),
-            }
+                p_value: entry.significance[*score_index]?,
+            })
         })
         .collect();
 
diff --git a/crates/application/src/entry/commands.rs b/crates/application/src/entry/commands.rs
index 8ec4a62..18a6547 100644
--- a/crates/application/src/entry/commands.rs
+++ b/crates/application/src/entry/commands.rs
@@ -15,7 +15,7 @@ pub struct CreateEntryCommand {
 #[derive(Debug)]
 pub struct UpdateEntryCommand {
     pub entry_id: MoodEntryId,
-    pub mood: Mood,
+    pub mood: Option<Mood>,
     pub logged_at: Option<DateTime<FixedOffset>>,
-    pub dimensions: Vec<DimensionValue>,
+    pub dimensions: Option<Vec<DimensionValue>>,
 }
diff --git a/crates/application/src/entry/mod.rs b/crates/application/src/entry/mod.rs
index ae5c46e..93dffb9 100644
--- a/crates/application/src/entry/mod.rs
+++ b/crates/application/src/entry/mod.rs
@@ -1,4 +1,5 @@
 pub mod commands;
 pub mod composition;
 pub mod queries;
+pub mod tagging;
 pub mod use_cases;
diff --git a/crates/application/src/entry/queries.rs b/crates/application/src/entry/queries.rs
index 458fdc1..d8352ac 100644
--- a/crates/application/src/entry/queries.rs
+++ b/crates/application/src/entry/queries.rs
@@ -1,25 +1,10 @@
-use domain::activity::ActivityId;
-use domain::entry::{DateRange, Mood};
+use domain::entry::{DateRange, EntrySelection, Pagination};
 use domain::user::UserId;
 
 #[derive(Debug)]
 pub struct ListEntriesQuery {
-    pub user_id: UserId,
-    pub range: Option<DateRange>,
-    pub limit: Option<i64>,
-    pub offset: Option<i64>,
-}
-
-#[derive(Debug)]
-pub struct FilterByMoodQuery {
-    pub user_id: UserId,
-    pub mood: Mood,
-}
-
-#[derive(Debug)]
-pub struct FilterByActivityQuery {
-    pub user_id: UserId,
-    pub activity_id: ActivityId,
+    pub selection: EntrySelection,
+    pub page: Pagination,
 }
 
 #[derive(Debug)]
diff --git a/crates/application/src/entry/tagging.rs b/crates/application/src/entry/tagging.rs
new file mode 100644
index 0000000..a96e4cd
--- /dev/null
+++ b/crates/application/src/entry/tagging.rs
@@ -0,0 +1,63 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use domain::activity::{Activity, ActivityId};
+use domain::dimension::{DimensionValue, lookup};
+use domain::errors::DomainError;
+use domain::ports::ActivityQueryPort;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub async fn verify_activities_may_be_tagged(
+    owner: &UserId,
+    wanted: &[DimensionValue],
+    already_worn: &[ActivityId],
+    activities: &Arc<dyn ActivityQueryPort>,
+) -> Result<(), ApplicationError> {
+    let tagged = lookup::activities_in(wanted);
+
+    if tagged.is_empty() {
+        return Ok(());
+    }
+
+    let catalogue = catalogue_of(owner, activities).await?;
+
+    for activity_id in tagged {
+        let activity = catalogue
+            .get(activity_id)
+            .ok_or_else(|| not_in_this_catalogue(activity_id))?;
+
+        if activity.is_archived() && !already_worn.contains(activity_id) {
+            return Err(retired(activity));
+        }
+    }
+
+    Ok(())
+}
+
+async fn catalogue_of(
+    owner: &UserId,
+    activities: &Arc<dyn ActivityQueryPort>,
+) -> Result<HashMap<ActivityId, Activity>, ApplicationError> {
+    Ok(activities
+        .find_by_user(owner)
+        .await?
+        .into_iter()
+        .map(|activity| (activity.id().clone(), activity))
+        .collect())
+}
+
+fn not_in_this_catalogue(activity_id: &ActivityId) -> ApplicationError {
+    DomainError::Forbidden(format!(
+        "activity {activity_id} is not in this account's catalogue"
+    ))
+    .into()
+}
+
+fn retired(activity: &Activity) -> ApplicationError {
+    ApplicationError::Validation(format!(
+        "{} is archived, so it cannot be tagged onto an entry it was not already on: unarchive it first",
+        activity.name().value()
+    ))
+}
diff --git a/crates/application/src/entry/use_cases/create_entries.rs b/crates/application/src/entry/use_cases/create_entries.rs
new file mode 100644
index 0000000..6aec58f
--- /dev/null
+++ b/crates/application/src/entry/use_cases/create_entries.rs
@@ -0,0 +1,65 @@
+use std::sync::Arc;
+
+use domain::entry::MoodEntry;
+use domain::events::{DomainEvent, EventEnvelope};
+use domain::ports::{
+    ActivityQueryPort, EntryDimensionPort, EventPublisherPort, MoodEntryCommandPort,
+};
+use domain::user::UserId;
+
+use crate::entry::tagging::verify_activities_may_be_tagged;
+use crate::errors::ApplicationError;
+
+use super::super::commands::CreateEntryCommand;
+
+const NOTHING_YET: &[domain::activity::ActivityId] = &[];
+
+pub struct Deps {
+    pub entries: Arc<dyn MoodEntryCommandPort>,
+    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
+    pub activities: Arc<dyn ActivityQueryPort>,
+    pub events: Arc<dyn EventPublisherPort>,
+}
+
+#[tracing::instrument(skip(deps, wanted), fields(count = wanted.len()))]
+pub async fn execute(
+    user_id: UserId,
+    wanted: Vec<CreateEntryCommand>,
+    deps: &Deps,
+) -> Result<Vec<MoodEntry>, ApplicationError> {
+    for one in &wanted {
+        verify_activities_may_be_tagged(&user_id, &one.dimensions, NOTHING_YET, &deps.activities)
+            .await?;
+    }
+
+    let written: Vec<(MoodEntry, Vec<domain::dimension::DimensionValue>)> = wanted
+        .into_iter()
+        .map(|one| {
+            (
+                MoodEntry::new(one.user_id, one.mood, one.logged_at),
+                one.dimensions,
+            )
+        })
+        .collect();
+
+    let entries: Vec<MoodEntry> = written.iter().map(|(entry, _)| entry.clone()).collect();
+    deps.entries.save_batch(&entries).await?;
+
+    for (entry, dimensions) in &written {
+        for port in &deps.dimensions {
+            port.save(entry.id(), dimensions).await?;
+        }
+    }
+
+    for entry in &entries {
+        let event = DomainEvent::EntryCreated {
+            entry_id: entry.id().clone(),
+            user_id: entry.user_id().clone(),
+        };
+        deps.events.publish(EventEnvelope::wrap(event)).await?;
+    }
+
+    tracing::info!(created = entries.len(), "created entries in one request");
+
+    Ok(entries)
+}
diff --git a/crates/application/src/entry/use_cases/create_entry.rs b/crates/application/src/entry/use_cases/create_entry.rs
index 4117eae..a3ac424 100644
--- a/crates/application/src/entry/use_cases/create_entry.rs
+++ b/crates/application/src/entry/use_cases/create_entry.rs
@@ -2,20 +2,29 @@ use std::sync::Arc;
 
 use domain::entry::MoodEntry;
 use domain::events::{DomainEvent, EventEnvelope};
-use domain::ports::{EntryDimensionPort, EventPublisherPort, MoodEntryCommandPort};
+use domain::ports::{
+    ActivityQueryPort, EntryDimensionPort, EventPublisherPort, MoodEntryCommandPort,
+};
 
+use crate::entry::tagging::verify_activities_may_be_tagged;
 use crate::errors::ApplicationError;
 
 use super::super::commands::CreateEntryCommand;
 
+const NOTHING_YET: &[domain::activity::ActivityId] = &[];
+
 pub struct Deps {
     pub entries: Arc<dyn MoodEntryCommandPort>,
     pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
+    pub activities: Arc<dyn ActivityQueryPort>,
     pub events: Arc<dyn EventPublisherPort>,
 }
 
 #[tracing::instrument(skip(deps))]
 pub async fn execute(cmd: CreateEntryCommand, deps: &Deps) -> Result<MoodEntry, ApplicationError> {
+    verify_activities_may_be_tagged(&cmd.user_id, &cmd.dimensions, NOTHING_YET, &deps.activities)
+        .await?;
+
     let entry = MoodEntry::new(cmd.user_id, cmd.mood, cmd.logged_at);
 
     deps.entries.save(&entry).await?;
diff --git a/crates/application/src/entry/use_cases/filter_by_activity.rs b/crates/application/src/entry/use_cases/filter_by_activity.rs
deleted file mode 100644
index e56800f..0000000
--- a/crates/application/src/entry/use_cases/filter_by_activity.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use std::sync::Arc;
-
-use domain::entry::MoodEntry;
-use domain::ports::MoodEntryQueryPort;
-
-use crate::errors::ApplicationError;
-
-use super::super::queries::FilterByActivityQuery;
-
-pub struct Deps {
-    pub query: Arc<dyn MoodEntryQueryPort>,
-}
-
-#[tracing::instrument(skip(deps))]
-pub async fn execute(
-    query: FilterByActivityQuery,
-    deps: &Deps,
-) -> Result<Vec<MoodEntry>, ApplicationError> {
-    let entries = deps
-        .query
-        .find_by_activity(&query.user_id, &query.activity_id)
-        .await?;
-    Ok(entries)
-}
diff --git a/crates/application/src/entry/use_cases/filter_by_mood.rs b/crates/application/src/entry/use_cases/filter_by_mood.rs
deleted file mode 100644
index 81f0dc9..0000000
--- a/crates/application/src/entry/use_cases/filter_by_mood.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use std::sync::Arc;
-
-use domain::entry::MoodEntry;
-use domain::ports::MoodEntryQueryPort;
-
-use crate::errors::ApplicationError;
-
-use super::super::queries::FilterByMoodQuery;
-
-pub struct Deps {
-    pub query: Arc<dyn MoodEntryQueryPort>,
-}
-
-#[tracing::instrument(skip(deps))]
-pub async fn execute(
-    query: FilterByMoodQuery,
-    deps: &Deps,
-) -> Result<Vec<MoodEntry>, ApplicationError> {
-    let entries = deps.query.find_by_mood(&query.user_id, query.mood).await?;
-    Ok(entries)
-}
diff --git a/crates/application/src/entry/use_cases/get_mood_stats.rs b/crates/application/src/entry/use_cases/get_mood_stats.rs
index a510e5f..3e81110 100644
--- a/crates/application/src/entry/use_cases/get_mood_stats.rs
+++ b/crates/application/src/entry/use_cases/get_mood_stats.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use domain::entry::Mood;
+use domain::entry::{Date, Mood};
 use domain::ports::{MoodEntryQueryPort, UserQueryPort};
 use domain::services::MoodAnalyzerService;
 
@@ -14,6 +14,8 @@ pub struct MoodStats {
     pub frequency: Vec<(Mood, usize)>,
     pub current_streak: usize,
     pub total_entries: usize,
+    pub first_logged_on: Option<Date>,
+    pub last_logged_on: Option<Date>,
 }
 
 pub struct Deps {
@@ -29,7 +31,7 @@ pub async fn execute(query: MoodStatsQuery, deps: &Deps) -> Result<MoodStats, Ap
                 .find_by_date_range(&query.user_id, &range)
                 .await?
         }
-        None => deps.query.find_by_user(&query.user_id, None, None).await?,
+        None => deps.query.find_all_by_user(&query.user_id).await?,
     };
 
     let timezone = timezone_for(&query.user_id, &deps.users).await?;
@@ -43,5 +45,7 @@ pub async fn execute(query: MoodStatsQuery, deps: &Deps) -> Result<MoodStats, Ap
         frequency: MoodAnalyzerService::mood_frequency(&entries),
         current_streak: MoodAnalyzerService::current_streak(&dates, today_in(&timezone)),
         total_entries: entries.len(),
+        first_logged_on: dates.iter().min().copied(),
+        last_logged_on: dates.iter().max().copied(),
     })
 }
diff --git a/crates/application/src/entry/use_cases/list_entries.rs b/crates/application/src/entry/use_cases/list_entries.rs
index 4fc4576..beb2816 100644
--- a/crates/application/src/entry/use_cases/list_entries.rs
+++ b/crates/application/src/entry/use_cases/list_entries.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use domain::entry::MoodEntry;
+use domain::entry::{MoodEntry, Page};
 use domain::ports::MoodEntryQueryPort;
 
 use crate::errors::ApplicationError;
@@ -15,19 +15,9 @@ pub struct Deps {
 pub async fn execute(
     query: ListEntriesQuery,
     deps: &Deps,
-) -> Result<Vec<MoodEntry>, ApplicationError> {
-    let entries = match query.range {
-        Some(range) => {
-            deps.query
-                .find_by_date_range(&query.user_id, &range)
-                .await?
-        }
-        None => {
-            deps.query
-                .find_by_user(&query.user_id, query.limit, query.offset)
-                .await?
-        }
-    };
+) -> Result<Page<MoodEntry>, ApplicationError> {
+    let total = deps.query.count(&query.selection).await?;
+    let entries = deps.query.select(&query.selection, query.page).await?;
 
-    Ok(entries)
+    Ok(Page::new(entries, total, query.page))
 }
diff --git a/crates/application/src/entry/use_cases/mod.rs b/crates/application/src/entry/use_cases/mod.rs
index cd590a7..376ef75 100644
--- a/crates/application/src/entry/use_cases/mod.rs
+++ b/crates/application/src/entry/use_cases/mod.rs
@@ -1,8 +1,7 @@
+pub mod create_entries;
 pub mod create_entry;
 pub mod delete_entries_by_date_range;
 pub mod delete_entry;
-pub mod filter_by_activity;
-pub mod filter_by_mood;
 pub mod get_calendar;
 pub mod get_entry;
 pub mod get_mood_stats;
diff --git a/crates/application/src/entry/use_cases/update_entry.rs b/crates/application/src/entry/use_cases/update_entry.rs
index 95dc529..c02f55f 100644
--- a/crates/application/src/entry/use_cases/update_entry.rs
+++ b/crates/application/src/entry/use_cases/update_entry.rs
@@ -1,18 +1,20 @@
 use std::sync::Arc;
 
-use domain::dimension::lookup;
+use domain::dimension::DimensionValue;
 use domain::entry::MoodEntry;
 use domain::errors::DomainError;
 use domain::events::{DomainEvent, EventEnvelope};
 use domain::ports::{
-    EntryDimensionPort, EventPublisherPort, MediaStoragePort, MoodEntryCommandPort,
-    MoodEntryQueryPort,
+    ActivityQueryPort, EntryDimensionPort, EventPublisherPort, MediaStoragePort,
+    MoodEntryCommandPort, MoodEntryQueryPort,
 };
 use domain::user::UserId;
 
 use crate::authorization::verify_ownership;
 use crate::entry::composition::EntryComposer;
+use crate::entry::tagging::verify_activities_may_be_tagged;
 use crate::errors::ApplicationError;
+use crate::media::dropped::{DroppedMedia, delete_dropped};
 
 use super::super::commands::UpdateEntryCommand;
 
@@ -20,6 +22,7 @@ pub struct Deps {
     pub command: Arc<dyn MoodEntryCommandPort>,
     pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
     pub query: Arc<dyn MoodEntryQueryPort>,
+    pub activities: Arc<dyn ActivityQueryPort>,
     pub media_storage: Arc<dyn MediaStoragePort>,
     pub events: Arc<dyn EventPublisherPort>,
 }
@@ -38,38 +41,28 @@ pub async fn execute(
 
     verify_ownership(entry.user_id(), &caller_id)?;
 
-    let previous = EntryComposer::new(deps.dimensions.clone())
-        .compose(vec![entry.clone()])
-        .await?;
-    let old_photos = previous[0].photos().to_vec();
-    let old_memos = previous[0].voice_memos().to_vec();
+    let dropped = match &cmd.dimensions {
+        Some(wanted) => Some(replace_dimensions(&entry, wanted, &caller_id, deps).await?),
+        None => None,
+    };
 
-    entry.update_mood(cmd.mood);
+    if let Some(mood) = cmd.mood {
+        entry.update_mood(mood);
+    }
     if let Some(logged_at) = cmd.logged_at {
         entry.update_logged_at(logged_at);
     }
 
-    let new_photos = lookup::photos_in(&cmd.dimensions);
-    let new_memos = lookup::voice_memos_in(&cmd.dimensions);
-
-    for photo_id in &old_photos {
-        if !new_photos.contains(photo_id)
-            && let Err(e) = deps.media_storage.delete_photo(photo_id).await
-        {
-            tracing::warn!(%e, "failed to delete removed photo blob");
-        }
-    }
-    for memo_id in &old_memos {
-        if !new_memos.contains(memo_id)
-            && let Err(e) = deps.media_storage.delete_voice_memo(memo_id).await
-        {
-            tracing::warn!(%e, "failed to delete removed voice memo blob");
-        }
-    }
-
     deps.command.save(&entry).await?;
-    for port in &deps.dimensions {
-        port.save(entry.id(), &cmd.dimensions).await?;
+
+    if let Some(wanted) = &cmd.dimensions {
+        for port in &deps.dimensions {
+            port.save(entry.id(), wanted).await?;
+        }
+    }
+
+    if let Some(dropped) = dropped {
+        delete_dropped(&dropped, &deps.media_storage).await;
     }
 
     let event = DomainEvent::EntryUpdated {
@@ -80,3 +73,24 @@ pub async fn execute(
 
     Ok(entry)
 }
+
+async fn replace_dimensions(
+    entry: &MoodEntry,
+    wanted: &[DimensionValue],
+    caller_id: &UserId,
+    deps: &Deps,
+) -> Result<DroppedMedia, ApplicationError> {
+    let previous = EntryComposer::new(deps.dimensions.clone())
+        .compose(vec![entry.clone()])
+        .await?;
+
+    verify_activities_may_be_tagged(
+        caller_id,
+        wanted,
+        previous[0].activities(),
+        &deps.activities,
+    )
+    .await?;
+
+    Ok(DroppedMedia::between(&previous[0], wanted))
+}
diff --git a/crates/application/src/export/use_cases/write_backup.rs b/crates/application/src/export/use_cases/write_backup.rs
index 9f2c680..d37fb53 100644
--- a/crates/application/src/export/use_cases/write_backup.rs
+++ b/crates/application/src/export/use_cases/write_backup.rs
@@ -29,7 +29,7 @@ pub struct Deps {
 #[tracing::instrument(skip(deps))]
 pub async fn execute(user_id: UserId, deps: &Deps) -> Result<Vec<u8>, ApplicationError> {
     let entries = EntryComposer::new(deps.dimensions.clone())
-        .compose(deps.entries.find_by_user(&user_id, None, None).await?)
+        .compose(deps.entries.find_all_by_user(&user_id).await?)
         .await?;
 
     let media = gather_media(&entries, deps).await?;
@@ -81,26 +81,46 @@ async fn gather_media(
 ) -> Result<BackupMedia, ApplicationError> {
     let mut photos = Vec::new();
     let mut voice_memos = Vec::new();
+    let mut missing: Vec<String> = Vec::new();
 
     for entry in entries {
         for photo_id in entry.photos() {
-            if let Some(file) = deps.media_storage.get_photo(photo_id).await? {
-                photos.push(MediaBlob {
+            match deps.media_storage.get_photo(photo_id).await {
+                Ok(Some(file)) => photos.push(MediaBlob {
                     id: photo_id.value().to_string(),
                     data: file.data,
-                });
+                    content_type: file.content_type,
+                }),
+                Ok(None) => missing.push(format!("photo {photo_id}")),
+                Err(error) => {
+                    tracing::warn!(%photo_id, %error, "a photo could not be read for the backup");
+                    missing.push(format!("photo {photo_id}"));
+                }
             }
         }
         for memo_id in entry.voice_memos() {
-            if let Some(file) = deps.media_storage.get_voice_memo(memo_id).await? {
-                voice_memos.push(MediaBlob {
+            match deps.media_storage.get_voice_memo(memo_id).await {
+                Ok(Some(file)) => voice_memos.push(MediaBlob {
                     id: memo_id.value().to_string(),
                     data: file.data,
-                });
+                    content_type: file.content_type,
+                }),
+                Ok(None) => missing.push(format!("voice memo {memo_id}")),
+                Err(error) => {
+                    tracing::warn!(%memo_id, %error, "a voice memo could not be read for the backup");
+                    missing.push(format!("voice memo {memo_id}"));
+                }
             }
         }
     }
 
+    if !missing.is_empty() {
+        tracing::warn!(
+            missing = missing.len(),
+            "some media could not be read, so the backup carries the rest"
+        );
+    }
+
     Ok(BackupMedia {
         photos,
         voice_memos,
diff --git a/crates/application/src/export/use_cases/write_extract.rs b/crates/application/src/export/use_cases/write_extract.rs
index 37d34c9..86d8403 100644
--- a/crates/application/src/export/use_cases/write_extract.rs
+++ b/crates/application/src/export/use_cases/write_extract.rs
@@ -18,7 +18,7 @@ pub struct Deps {
 #[tracing::instrument(skip(deps))]
 pub async fn execute(user_id: UserId, deps: &Deps) -> Result<Vec<u8>, ApplicationError> {
     let entries = EntryComposer::new(deps.dimensions.clone())
-        .compose(deps.entries.find_by_user(&user_id, None, None).await?)
+        .compose(deps.entries.find_all_by_user(&user_id).await?)
         .await?;
 
     let extract = SharedExtract {
diff --git a/crates/application/src/import/already_here.rs b/crates/application/src/import/already_here.rs
new file mode 100644
index 0000000..8aa3927
--- /dev/null
+++ b/crates/application/src/import/already_here.rs
@@ -0,0 +1,41 @@
+use std::collections::HashSet;
+
+use chrono::{DateTime, FixedOffset};
+
+use domain::entry::{Mood, MoodEntry};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+struct Fingerprint {
+    instant: i64,
+    mood: u8,
+}
+
+impl Fingerprint {
+    fn of(logged_at: &DateTime<FixedOffset>, mood: Mood) -> Self {
+        Self {
+            instant: logged_at.timestamp(),
+            mood: mood.value(),
+        }
+    }
+}
+
+pub struct AlreadyHere(HashSet<Fingerprint>);
+
+impl AlreadyHere {
+    pub fn holding(entries: &[MoodEntry]) -> Self {
+        Self(
+            entries
+                .iter()
+                .map(|entry| Fingerprint::of(entry.logged_at(), entry.mood()))
+                .collect(),
+        )
+    }
+
+    pub fn holds(&self, logged_at: &DateTime<FixedOffset>, mood: Mood) -> bool {
+        self.0.contains(&Fingerprint::of(logged_at, mood))
+    }
+
+    pub fn remember(&mut self, logged_at: &DateTime<FixedOffset>, mood: Mood) {
+        self.0.insert(Fingerprint::of(logged_at, mood));
+    }
+}
diff --git a/crates/application/src/import/mod.rs b/crates/application/src/import/mod.rs
index 804f0ee..a92480c 100644
--- a/crates/application/src/import/mod.rs
+++ b/crates/application/src/import/mod.rs
@@ -1,2 +1,3 @@
+pub mod already_here;
 pub mod commands;
 pub mod use_cases;
diff --git a/crates/application/src/import/use_cases/import_entries.rs b/crates/application/src/import/use_cases/import_entries.rs
index 7ca3525..055c65d 100644
--- a/crates/application/src/import/use_cases/import_entries.rs
+++ b/crates/application/src/import/use_cases/import_entries.rs
@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::sync::Arc;
 
 use chrono::FixedOffset;
@@ -14,6 +14,7 @@ use domain::ports::{
 use domain::user::Timezone;
 
 use crate::errors::ApplicationError;
+use crate::import::already_here::AlreadyHere;
 
 use super::super::commands::ImportCommand;
 
@@ -42,14 +43,8 @@ pub async fn execute(cmd: ImportCommand, deps: &Deps) -> Result<ImportResult, Ap
 
     let timezone = crate::day::timezone_for(&cmd.user_id, &deps.users).await?;
 
-    let existing_entries = deps
-        .entry_query
-        .find_by_user(&cmd.user_id, None, None)
-        .await?;
-    let existing_keys: HashSet<(String, u8)> = existing_entries
-        .iter()
-        .map(|e| (e.logged_at().to_rfc3339(), e.mood().value()))
-        .collect();
+    let existing_entries = deps.entry_query.find_all_by_user(&cmd.user_id).await?;
+    let mut already_here = AlreadyHere::holding(&existing_entries);
 
     let existing_activities = deps.activity_query.find_by_user(&cmd.user_id).await?;
     let mut activity_cache: HashMap<String, ActivityId> = existing_activities
@@ -74,7 +69,7 @@ pub async fn execute(cmd: ImportCommand, deps: &Deps) -> Result<ImportResult, Ap
             &cmd.user_id,
             &mut activity_cache,
             &category_map,
-            &existing_keys,
+            &mut already_here,
             &timezone,
             deps,
         )
@@ -118,17 +113,17 @@ async fn build_entry(
     user_id: &domain::user::UserId,
     activity_cache: &mut HashMap<String, ActivityId>,
     category_map: &HashMap<String, String>,
-    existing_keys: &HashSet<(String, u8)>,
+    already_here: &mut AlreadyHere,
     timezone: &Timezone,
     deps: &Deps,
 ) -> Result<Option<ComposedEntry>, ApplicationError> {
     let mood = Mood::try_from(row.mood)?;
     let logged_at = the_users_own_wall_clock(&row.date, &row.time, timezone)?;
 
-    let key = (logged_at.to_rfc3339(), mood.value());
-    if existing_keys.contains(&key) {
+    if already_here.holds(&logged_at, mood) {
         return Ok(None);
     }
+    already_here.remember(&logged_at, mood);
 
     let mut activity_ids = Vec::new();
     for activity_name in &row.activities {
diff --git a/crates/application/src/job/use_cases/list_exhausted_jobs.rs b/crates/application/src/job/use_cases/list_exhausted_jobs.rs
new file mode 100644
index 0000000..5053ac3
--- /dev/null
+++ b/crates/application/src/job/use_cases/list_exhausted_jobs.rs
@@ -0,0 +1,15 @@
+use std::sync::Arc;
+
+use domain::job::Job;
+use domain::ports::JobQueueQueryPort;
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub jobs: Arc<dyn JobQueueQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(most: usize, deps: &Deps) -> Result<Vec<Job>, ApplicationError> {
+    Ok(deps.jobs.find_exhausted(most).await?)
+}
diff --git a/crates/application/src/job/use_cases/mod.rs b/crates/application/src/job/use_cases/mod.rs
index 5767cf5..830dbdb 100644
--- a/crates/application/src/job/use_cases/mod.rs
+++ b/crates/application/src/job/use_cases/mod.rs
@@ -1,3 +1,4 @@
+pub mod list_exhausted_jobs;
 pub mod run_due_jobs;
 pub mod sweep_recording_backlog;
 pub mod sweep_weather_backlog;
diff --git a/crates/application/src/job/use_cases/run_due_jobs.rs b/crates/application/src/job/use_cases/run_due_jobs.rs
index 849fd56..389a740 100644
--- a/crates/application/src/job/use_cases/run_due_jobs.rs
+++ b/crates/application/src/job/use_cases/run_due_jobs.rs
@@ -95,13 +95,13 @@ async fn observe_weather(job: &Job, deps: &Deps) -> Result<(), String> {
         return Err("weather lookups are switched off".into());
     };
 
-    let waiting = deps
+    let found = deps
         .places
-        .find_places_without_weather(usize::MAX)
+        .find_place_without_weather(entry_id)
         .await
         .map_err(|error| error.to_string())?;
 
-    let Some(place) = waiting.iter().find(|place| &place.entry_id == entry_id) else {
+    let Some(place) = found else {
         return Ok(());
     };
 
@@ -116,7 +116,7 @@ async fn observe_weather(job: &Job, deps: &Deps) -> Result<(), String> {
         return Ok(());
     };
 
-    remember_weather(place, weather, deps).await
+    remember_weather(&place, weather, deps).await
 }
 
 async fn remember_weather(
@@ -133,13 +133,13 @@ async fn remember_weather(
 async fn backfill_recording_identity(job: &Job, deps: &Deps) -> Result<(), String> {
     let JobSubject::Entry(entry_id) = job.subject();
 
-    let waiting = deps
+    let found = deps
         .backfill
-        .find_songs_without_a_recording(usize::MAX)
+        .find_song_without_a_recording(entry_id)
         .await
         .map_err(|error| error.to_string())?;
 
-    let Some(song) = waiting.iter().find(|song| &song.entry_id == entry_id) else {
+    let Some(song) = found else {
         return Ok(());
     };
 
@@ -155,7 +155,7 @@ async fn backfill_recording_identity(job: &Job, deps: &Deps) -> Result<(), Strin
         return Ok(());
     };
 
-    remember(song, &recording_id, deps).await
+    remember(&song, &recording_id, deps).await
 }
 
 async fn remember(
diff --git a/crates/application/src/media/cleanup.rs b/crates/application/src/media/cleanup.rs
index 2e33016..5c17bc1 100644
--- a/crates/application/src/media/cleanup.rs
+++ b/crates/application/src/media/cleanup.rs
@@ -1,19 +1,51 @@
 use std::sync::Arc;
 
+use domain::attachment::MediaRef;
 use domain::dimension::ComposedEntry;
-use domain::ports::MediaStoragePort;
+use domain::ports::{MediaOwnershipPort, MediaStoragePort};
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
 
 pub async fn delete_media_for(entries: &[ComposedEntry], storage: &Arc<dyn MediaStoragePort>) {
     for entry in entries {
         for photo_id in entry.photos() {
-            if let Err(e) = storage.delete_photo(photo_id).await {
-                tracing::warn!(%e, "failed to delete photo blob");
+            if let Err(error) = storage.delete_photo(photo_id).await {
+                tracing::warn!(%error, "failed to delete photo blob");
             }
         }
         for memo_id in entry.voice_memos() {
-            if let Err(e) = storage.delete_voice_memo(memo_id).await {
-                tracing::warn!(%e, "failed to delete voice memo blob");
+            if let Err(error) = storage.delete_voice_memo(memo_id).await {
+                tracing::warn!(%error, "failed to delete voice memo blob");
             }
         }
     }
 }
+
+pub async fn delete_everything_owned_by(
+    owner: &UserId,
+    storage: &Arc<dyn MediaStoragePort>,
+    ownership: &Arc<dyn MediaOwnershipPort>,
+) -> Result<usize, ApplicationError> {
+    let held = ownership.owned_by(owner).await?;
+
+    for media in &held {
+        delete_one(*media, storage).await;
+    }
+
+    Ok(held.len())
+}
+
+async fn delete_one(media: MediaRef, storage: &Arc<dyn MediaStoragePort>) {
+    if let Some(photo_id) = media.to_photo()
+        && let Err(error) = storage.delete_photo(&photo_id).await
+    {
+        tracing::warn!(%error, %media, "failed to delete photo blob");
+    }
+
+    if let Some(memo_id) = media.to_voice_memo()
+        && let Err(error) = storage.delete_voice_memo(&memo_id).await
+    {
+        tracing::warn!(%error, %media, "failed to delete voice memo blob");
+    }
+}
diff --git a/crates/application/src/media/custody.rs b/crates/application/src/media/custody.rs
new file mode 100644
index 0000000..3545096
--- /dev/null
+++ b/crates/application/src/media/custody.rs
@@ -0,0 +1,22 @@
+use std::sync::Arc;
+
+use domain::attachment::MediaRef;
+use domain::errors::DomainError;
+use domain::ports::MediaOwnershipPort;
+use domain::user::UserId;
+
+use crate::authorization::verify_ownership;
+use crate::errors::ApplicationError;
+
+pub async fn verify_custody(
+    media: MediaRef,
+    caller: &UserId,
+    ownership: &Arc<dyn MediaOwnershipPort>,
+) -> Result<(), ApplicationError> {
+    let owner = ownership
+        .owner_of(media)
+        .await?
+        .ok_or_else(|| DomainError::NotFound(format!("{media} not found")))?;
+
+    verify_ownership(&owner, caller)
+}
diff --git a/crates/application/src/media/dropped.rs b/crates/application/src/media/dropped.rs
new file mode 100644
index 0000000..b611b46
--- /dev/null
+++ b/crates/application/src/media/dropped.rs
@@ -0,0 +1,58 @@
+use std::sync::Arc;
+
+use domain::attachment::{PhotoId, VoiceMemoId};
+use domain::dimension::{ComposedEntry, DimensionValue, lookup};
+use domain::ports::MediaStoragePort;
+
+pub struct DroppedMedia {
+    photos: Vec<PhotoId>,
+    voice_memos: Vec<VoiceMemoId>,
+}
+
+impl DroppedMedia {
+    pub fn between(previous: &ComposedEntry, kept: &[DimensionValue]) -> Self {
+        let still_here_photos = lookup::photos_in(kept);
+        let still_here_memos = lookup::voice_memos_in(kept);
+
+        Self {
+            photos: previous
+                .photos()
+                .iter()
+                .filter(|photo_id| !still_here_photos.contains(photo_id))
+                .cloned()
+                .collect(),
+            voice_memos: previous
+                .voice_memos()
+                .iter()
+                .filter(|memo_id| !still_here_memos.contains(memo_id))
+                .cloned()
+                .collect(),
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.photos.is_empty() && self.voice_memos.is_empty()
+    }
+
+    pub fn photos(&self) -> &[PhotoId] {
+        &self.photos
+    }
+
+    pub fn voice_memos(&self) -> &[VoiceMemoId] {
+        &self.voice_memos
+    }
+}
+
+pub async fn delete_dropped(dropped: &DroppedMedia, storage: &Arc<dyn MediaStoragePort>) {
+    for photo_id in dropped.photos() {
+        if let Err(error) = storage.delete_photo(photo_id).await {
+            tracing::warn!(%error, "failed to delete a photo dropped from an edit");
+        }
+    }
+
+    for memo_id in dropped.voice_memos() {
+        if let Err(error) = storage.delete_voice_memo(memo_id).await {
+            tracing::warn!(%error, "failed to delete a voice memo dropped from an edit");
+        }
+    }
+}
diff --git a/crates/application/src/media/mod.rs b/crates/application/src/media/mod.rs
index f6ac411..254abda 100644
--- a/crates/application/src/media/mod.rs
+++ b/crates/application/src/media/mod.rs
@@ -1,2 +1,4 @@
 pub mod cleanup;
+pub mod custody;
+pub mod dropped;
 pub mod use_cases;
diff --git a/crates/application/src/media/use_cases/delete_photo.rs b/crates/application/src/media/use_cases/delete_photo.rs
index b0270f6..e0ca57c 100644
--- a/crates/application/src/media/use_cases/delete_photo.rs
+++ b/crates/application/src/media/use_cases/delete_photo.rs
@@ -1,16 +1,28 @@
 use std::sync::Arc;
 
 use domain::attachment::PhotoId;
-use domain::ports::MediaStoragePort;
+use domain::ports::{MediaOwnershipPort, MediaStoragePort};
+use domain::user::UserId;
 
 use crate::errors::ApplicationError;
+use crate::media::custody::verify_custody;
 
 pub struct Deps {
     pub storage: Arc<dyn MediaStoragePort>,
+    pub ownership: Arc<dyn MediaOwnershipPort>,
 }
 
 #[tracing::instrument(skip(deps))]
-pub async fn execute(photo_id: PhotoId, deps: &Deps) -> Result<(), ApplicationError> {
+pub async fn execute(
+    photo_id: PhotoId,
+    caller_id: UserId,
+    deps: &Deps,
+) -> Result<(), ApplicationError> {
+    let media = (&photo_id).into();
+    verify_custody(media, &caller_id, &deps.ownership).await?;
+
     deps.storage.delete_photo(&photo_id).await?;
+    deps.ownership.forget(media).await?;
+
     Ok(())
 }
diff --git a/crates/application/src/media/use_cases/delete_voice_memo.rs b/crates/application/src/media/use_cases/delete_voice_memo.rs
index 711f491..9b4dfb8 100644
--- a/crates/application/src/media/use_cases/delete_voice_memo.rs
+++ b/crates/application/src/media/use_cases/delete_voice_memo.rs
@@ -1,16 +1,28 @@
 use std::sync::Arc;
 
 use domain::attachment::VoiceMemoId;
-use domain::ports::MediaStoragePort;
+use domain::ports::{MediaOwnershipPort, MediaStoragePort};
+use domain::user::UserId;
 
 use crate::errors::ApplicationError;
+use crate::media::custody::verify_custody;
 
 pub struct Deps {
     pub storage: Arc<dyn MediaStoragePort>,
+    pub ownership: Arc<dyn MediaOwnershipPort>,
 }
 
 #[tracing::instrument(skip(deps))]
-pub async fn execute(voice_memo_id: VoiceMemoId, deps: &Deps) -> Result<(), ApplicationError> {
+pub async fn execute(
+    voice_memo_id: VoiceMemoId,
+    caller_id: UserId,
+    deps: &Deps,
+) -> Result<(), ApplicationError> {
+    let media = (&voice_memo_id).into();
+    verify_custody(media, &caller_id, &deps.ownership).await?;
+
     deps.storage.delete_voice_memo(&voice_memo_id).await?;
+    deps.ownership.forget(media).await?;
+
     Ok(())
 }
diff --git a/crates/application/src/media/use_cases/list_media.rs b/crates/application/src/media/use_cases/list_media.rs
new file mode 100644
index 0000000..442c4f3
--- /dev/null
+++ b/crates/application/src/media/use_cases/list_media.rs
@@ -0,0 +1,16 @@
+use std::sync::Arc;
+
+use domain::attachment::MediaRef;
+use domain::ports::MediaOwnershipPort;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub ownership: Arc<dyn MediaOwnershipPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(owner: UserId, deps: &Deps) -> Result<Vec<MediaRef>, ApplicationError> {
+    Ok(deps.ownership.owned_by(&owner).await?)
+}
diff --git a/crates/application/src/media/use_cases/mod.rs b/crates/application/src/media/use_cases/mod.rs
index d6000c6..59706ef 100644
--- a/crates/application/src/media/use_cases/mod.rs
+++ b/crates/application/src/media/use_cases/mod.rs
@@ -1,4 +1,5 @@
 pub mod delete_photo;
 pub mod delete_voice_memo;
+pub mod list_media;
 pub mod upload_photo;
 pub mod upload_voice_memo;
diff --git a/crates/application/src/media/use_cases/upload_photo.rs b/crates/application/src/media/use_cases/upload_photo.rs
index a1fd5f1..4a2ac23 100644
--- a/crates/application/src/media/use_cases/upload_photo.rs
+++ b/crates/application/src/media/use_cases/upload_photo.rs
@@ -1,16 +1,25 @@
 use std::sync::Arc;
 
 use domain::attachment::{MediaUpload, PhotoId};
-use domain::ports::MediaStoragePort;
+use domain::ports::{MediaOwnershipPort, MediaStoragePort};
+use domain::user::UserId;
 
 use crate::errors::ApplicationError;
 
 pub struct Deps {
     pub storage: Arc<dyn MediaStoragePort>,
+    pub ownership: Arc<dyn MediaOwnershipPort>,
 }
 
-#[tracing::instrument(skip(deps))]
-pub async fn execute(upload: MediaUpload, deps: &Deps) -> Result<PhotoId, ApplicationError> {
+#[tracing::instrument(skip(deps, upload))]
+pub async fn execute(
+    owner: UserId,
+    upload: MediaUpload,
+    deps: &Deps,
+) -> Result<PhotoId, ApplicationError> {
     let photo_id = deps.storage.store_photo(upload).await?;
+
+    deps.ownership.remember(&owner, (&photo_id).into()).await?;
+
     Ok(photo_id)
 }
diff --git a/crates/application/src/media/use_cases/upload_voice_memo.rs b/crates/application/src/media/use_cases/upload_voice_memo.rs
index b96e48b..7f89482 100644
--- a/crates/application/src/media/use_cases/upload_voice_memo.rs
+++ b/crates/application/src/media/use_cases/upload_voice_memo.rs
@@ -1,16 +1,27 @@
 use std::sync::Arc;
 
 use domain::attachment::{MediaUpload, VoiceMemoId};
-use domain::ports::MediaStoragePort;
+use domain::ports::{MediaOwnershipPort, MediaStoragePort};
+use domain::user::UserId;
 
 use crate::errors::ApplicationError;
 
 pub struct Deps {
     pub storage: Arc<dyn MediaStoragePort>,
+    pub ownership: Arc<dyn MediaOwnershipPort>,
 }
 
-#[tracing::instrument(skip(deps))]
-pub async fn execute(upload: MediaUpload, deps: &Deps) -> Result<VoiceMemoId, ApplicationError> {
+#[tracing::instrument(skip(deps, upload))]
+pub async fn execute(
+    owner: UserId,
+    upload: MediaUpload,
+    deps: &Deps,
+) -> Result<VoiceMemoId, ApplicationError> {
     let voice_memo_id = deps.storage.store_voice_memo(upload).await?;
+
+    deps.ownership
+        .remember(&owner, (&voice_memo_id).into())
+        .await?;
+
     Ok(voice_memo_id)
 }
diff --git a/crates/application/src/metric/use_cases/list_rejections.rs b/crates/application/src/metric/use_cases/list_rejections.rs
new file mode 100644
index 0000000..3cd689e
--- /dev/null
+++ b/crates/application/src/metric/use_cases/list_rejections.rs
@@ -0,0 +1,19 @@
+use std::sync::Arc;
+
+use domain::ports::RejectionQueryPort;
+use domain::rejection::RejectedMetric;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub rejections: Arc<dyn RejectionQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(
+    user_id: UserId,
+    deps: &Deps,
+) -> Result<Vec<RejectedMetric>, ApplicationError> {
+    Ok(deps.rejections.find_recent_by_user(&user_id).await?)
+}
diff --git a/crates/application/src/metric/use_cases/mod.rs b/crates/application/src/metric/use_cases/mod.rs
index 997b22d..5437185 100644
--- a/crates/application/src/metric/use_cases/mod.rs
+++ b/crates/application/src/metric/use_cases/mod.rs
@@ -1,2 +1,3 @@
 pub mod list_daily_metrics;
+pub mod list_rejections;
 pub mod set_daily_metrics;
diff --git a/crates/application/src/push/commands.rs b/crates/application/src/push/commands.rs
index b0e78fb..f3b51e3 100644
--- a/crates/application/src/push/commands.rs
+++ b/crates/application/src/push/commands.rs
@@ -10,5 +10,6 @@ pub struct SubscribePushCommand {
 
 #[derive(Debug)]
 pub struct UnsubscribePushCommand {
+    pub user_id: UserId,
     pub endpoint: String,
 }
diff --git a/crates/application/src/push/use_cases/list_subscriptions.rs b/crates/application/src/push/use_cases/list_subscriptions.rs
new file mode 100644
index 0000000..0572c40
--- /dev/null
+++ b/crates/application/src/push/use_cases/list_subscriptions.rs
@@ -0,0 +1,19 @@
+use std::sync::Arc;
+
+use domain::ports::PushSubscriptionQueryPort;
+use domain::push::PushSubscription;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub push_query: Arc<dyn PushSubscriptionQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(
+    user_id: UserId,
+    deps: &Deps,
+) -> Result<Vec<PushSubscription>, ApplicationError> {
+    Ok(deps.push_query.find_by_user(&user_id).await?)
+}
diff --git a/crates/application/src/push/use_cases/mod.rs b/crates/application/src/push/use_cases/mod.rs
index 6ba5190..b30d7a5 100644
--- a/crates/application/src/push/use_cases/mod.rs
+++ b/crates/application/src/push/use_cases/mod.rs
@@ -1,2 +1,3 @@
+pub mod list_subscriptions;
 pub mod subscribe;
 pub mod unsubscribe;
diff --git a/crates/application/src/push/use_cases/subscribe.rs b/crates/application/src/push/use_cases/subscribe.rs
index 9055a40..8df4f49 100644
--- a/crates/application/src/push/use_cases/subscribe.rs
+++ b/crates/application/src/push/use_cases/subscribe.rs
@@ -14,16 +14,28 @@ pub struct Deps {
 
 #[tracing::instrument(skip(deps))]
 pub async fn execute(cmd: SubscribePushCommand, deps: &Deps) -> Result<(), ApplicationError> {
-    if let Some(_existing) = deps.push_query.find_by_endpoint(&cmd.endpoint).await? {
-        tracing::debug!(
-            endpoint = cmd.endpoint,
-            "push subscription already exists, updating"
-        );
-    }
+    let known = deps.push_query.find_by_endpoint(&cmd.endpoint).await?;
+
+    let subscription = match known {
+        Some(mut existing) => {
+            if existing.user_id() != &cmd.user_id {
+                tracing::info!(
+                    endpoint = cmd.endpoint,
+                    from = %existing.user_id(),
+                    to = %cmd.user_id,
+                    "a device already subscribed is moving to another account"
+                );
+            }
+
+            existing.renew(cmd.user_id, cmd.p256dh, cmd.auth);
+            existing
+        }
+        None => PushSubscription::new(cmd.user_id, cmd.endpoint, cmd.p256dh, cmd.auth),
+    };
 
-    let subscription = PushSubscription::new(cmd.user_id, cmd.endpoint, cmd.p256dh, cmd.auth);
     deps.push_command.save(&subscription).await?;
 
     tracing::info!(user_id = %subscription.user_id(), "push subscription saved");
+
     Ok(())
 }
diff --git a/crates/application/src/push/use_cases/unsubscribe.rs b/crates/application/src/push/use_cases/unsubscribe.rs
index 0a1a99b..3472ec4 100644
--- a/crates/application/src/push/use_cases/unsubscribe.rs
+++ b/crates/application/src/push/use_cases/unsubscribe.rs
@@ -12,7 +12,11 @@ pub struct Deps {
 
 #[tracing::instrument(skip(deps))]
 pub async fn execute(cmd: UnsubscribePushCommand, deps: &Deps) -> Result<(), ApplicationError> {
-    deps.push_command.delete_by_endpoint(&cmd.endpoint).await?;
-    tracing::info!(endpoint = cmd.endpoint, "push subscription removed");
+    deps.push_command
+        .delete_by_endpoint(&cmd.user_id, &cmd.endpoint)
+        .await?;
+
+    tracing::info!(user_id = %cmd.user_id, endpoint = cmd.endpoint, "push subscription removed");
+
     Ok(())
 }
diff --git a/crates/application/src/reminder/use_cases/process_due_reminders.rs b/crates/application/src/reminder/use_cases/process_due_reminders.rs
index ec3927e..fdd1b16 100644
--- a/crates/application/src/reminder/use_cases/process_due_reminders.rs
+++ b/crates/application/src/reminder/use_cases/process_due_reminders.rs
@@ -1,16 +1,19 @@
 use std::sync::Arc;
 
-use chrono::{Datelike, NaiveTime, Utc};
+use chrono::{Duration, Utc};
 
-use domain::ports::{ReminderQueryPort, ReminderSenderPort, UserQueryPort};
-use domain::reminder::Reminder;
+use domain::ports::{ReminderCommandPort, ReminderQueryPort, ReminderSenderPort, UserQueryPort};
+use domain::reminder::{DueOccurrence, Reminder};
+use domain::user::Timezone;
 
 use crate::errors::ApplicationError;
 
 pub struct Deps {
     pub reminder_query: Arc<dyn ReminderQueryPort>,
+    pub reminder_command: Arc<dyn ReminderCommandPort>,
     pub user_query: Arc<dyn UserQueryPort>,
     pub sender: Arc<dyn ReminderSenderPort>,
+    pub grace: Duration,
 }
 
 #[tracing::instrument(skip(deps))]
@@ -21,58 +24,74 @@ pub async fn execute(deps: &Deps) -> Result<u64, ApplicationError> {
         "checking enabled reminders"
     );
 
+    let now = Utc::now();
     let mut sent_count = 0u64;
 
-    // One user with no reachable device must not stop the sweep for everyone
-    // scheduled behind them.
-    for reminder in &reminders {
-        if should_send(reminder, &deps.user_query).await? {
-            tracing::info!(user_id = %reminder.user_id(), "sending reminder");
-            match deps.sender.send_reminder(reminder.user_id()).await {
-                Ok(()) => sent_count += 1,
-                Err(error) => {
-                    tracing::warn!(user_id = %reminder.user_id(), %error, "could not send reminder")
-                }
-            }
+    for reminder in reminders {
+        let Some(timezone) = timezone_of(&reminder, deps).await else {
+            continue;
+        };
+
+        let Some(occurrence) = reminder.occurrence_reached(now, &timezone, deps.grace) else {
+            continue;
+        };
+
+        if send(reminder, occurrence, deps).await {
+            sent_count += 1;
         }
     }
 
     tracing::info!(sent_count, "reminder processing completed");
+
     Ok(sent_count)
 }
 
-async fn should_send(
-    reminder: &Reminder,
-    user_query: &Arc<dyn UserQueryPort>,
-) -> Result<bool, ApplicationError> {
-    let user = user_query.find_by_id(reminder.user_id()).await?;
-    let user = match user {
-        Some(u) => u,
-        None => {
+async fn send(mut reminder: Reminder, occurrence: DueOccurrence, deps: &Deps) -> bool {
+    tracing::info!(user_id = %reminder.user_id(), "sending reminder");
+
+    if let Err(error) = deps.sender.send_reminder(reminder.user_id()).await {
+        tracing::warn!(user_id = %reminder.user_id(), %error, "could not send reminder");
+
+        return false;
+    }
+
+    reminder.mark_sent(occurrence);
+
+    if let Err(error) = deps.reminder_command.save(&reminder).await {
+        tracing::error!(
+            reminder_id = %reminder.id(),
+            %error,
+            "sent a reminder but could not record it, so it may be sent again"
+        );
+    }
+
+    true
+}
+
+async fn timezone_of(reminder: &Reminder, deps: &Deps) -> Option<Timezone> {
+    let found = deps.user_query.find_by_id(reminder.user_id()).await;
+
+    let user = match found {
+        Ok(Some(user)) => user,
+        Ok(None) => {
             tracing::warn!(user_id = %reminder.user_id(), "reminder references nonexistent user");
-            return Ok(false);
+
+            return None;
+        }
+        Err(error) => {
+            tracing::warn!(
+                user_id = %reminder.user_id(),
+                %error,
+                "could not read the account behind a reminder, so the rest of the sweep goes on"
+            );
+
+            return None;
         }
     };
 
-    let Some(timezone) = user.timezone() else {
+    if user.timezone().is_none() {
         tracing::debug!(user_id = %reminder.user_id(), "user has no timezone set, skipping reminder");
-        return Ok(false);
-    };
+    }
 
-    let now = Utc::now().with_timezone(&timezone.resolve());
-
-    let weekday = now.weekday();
-    let scheduled_time = match reminder.schedule().time_for(weekday) {
-        Some(time) => time,
-        None => return Ok(false),
-    };
-
-    let current_time = now.time();
-    Ok(is_within_window(current_time, scheduled_time))
-}
-
-fn is_within_window(current: NaiveTime, scheduled: NaiveTime) -> bool {
-    let diff = current.signed_duration_since(scheduled);
-    let minutes = diff.num_minutes();
-    (0..5).contains(&minutes)
+    user.timezone().copied()
 }
diff --git a/crates/application/src/restore/use_cases/restore_backup.rs b/crates/application/src/restore/use_cases/restore_backup.rs
index fb14c73..8dbc1aa 100644
--- a/crates/application/src/restore/use_cases/restore_backup.rs
+++ b/crates/application/src/restore/use_cases/restore_backup.rs
@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+
 use std::sync::Arc;
 
 use chrono::{NaiveTime, Weekday};
@@ -10,8 +11,9 @@ use domain::entry::{Date, Mood, MoodEntry};
 use domain::metric::{DailyMetric, MetricKind, MetricValue, Source};
 use domain::ports::{
     ActivityCommandPort, ActivityQueryPort, BackupReaderPort, CycleStartCommandPort,
-    DailyMetricCommandPort, EntryDimensionPort, MediaStoragePort, MoodEntryCommandPort,
-    ReminderCommandPort, RestorableActivity, RestorableContents, RestorableEntry, RestorableMetric,
+    DailyMetricCommandPort, EntryDimensionPort, MediaOwnershipPort, MediaStoragePort,
+    MoodEntryCommandPort, MoodEntryQueryPort, ReminderCommandPort, ReminderQueryPort,
+    RestorableActivity, RestorableContents, RestorableEntry, RestorableMedia, RestorableMetric,
     RestorableReminder, UserPreferencesCommandPort, UserPreferencesQueryPort,
 };
 use domain::provider::ProviderName;
@@ -19,6 +21,7 @@ use domain::reminder::{DaySchedule, Reminder};
 use domain::user::UserId;
 
 use crate::errors::ApplicationError;
+use crate::import::already_here::AlreadyHere;
 use crate::restore::commands::RestoreBackupCommand;
 use crate::user::preferences::preferences_of;
 
@@ -32,6 +35,9 @@ const WEEK: [Weekday; 7] = [
     Weekday::Sun,
 ];
 
+const PHOTO_FALLBACK_TYPE: &str = "image/jpeg";
+const VOICE_MEMO_FALLBACK_TYPE: &str = "audio/webm";
+
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct RestoreOutcome {
     pub entries: usize,
@@ -40,21 +46,25 @@ pub struct RestoreOutcome {
     pub activities: usize,
     pub reminders: usize,
     pub media: usize,
+    pub skipped: usize,
     pub unreadable: Vec<String>,
 }
 
 pub struct Deps {
     pub reader: Arc<dyn BackupReaderPort>,
     pub entry_command: Arc<dyn MoodEntryCommandPort>,
+    pub entry_query: Arc<dyn MoodEntryQueryPort>,
     pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
     pub activity_command: Arc<dyn ActivityCommandPort>,
     pub activity_query: Arc<dyn ActivityQueryPort>,
     pub reminder_command: Arc<dyn ReminderCommandPort>,
+    pub reminder_query: Arc<dyn ReminderQueryPort>,
     pub metrics: Arc<dyn DailyMetricCommandPort>,
     pub cycles: Arc<dyn CycleStartCommandPort>,
     pub preferences_command: Arc<dyn UserPreferencesCommandPort>,
     pub preferences_query: Arc<dyn UserPreferencesQueryPort>,
     pub media_storage: Arc<dyn MediaStoragePort>,
+    pub media_ownership: Arc<dyn MediaOwnershipPort>,
 }
 
 #[tracing::instrument(skip(deps))]
@@ -67,7 +77,7 @@ pub async fn execute(
     let mut outcome = RestoreOutcome::default();
 
     let activities = restore_activities(&user_id, &contents.activities, deps, &mut outcome).await?;
-    let media = restore_media(&contents, deps, &mut outcome).await;
+    let media = restore_media(&user_id, &contents, deps, &mut outcome).await;
     let renamed = Renamed { activities, media };
     restore_entries(&user_id, &contents.entries, &renamed, deps, &mut outcome).await?;
     restore_metrics(&user_id, &contents.metrics, deps, &mut outcome).await?;
@@ -82,6 +92,7 @@ pub async fn execute(
         activities = outcome.activities,
         reminders = outcome.reminders,
         media = outcome.media,
+        skipped = outcome.skipped,
         unreadable = outcome.unreadable.len(),
         "restored a backup"
     );
@@ -124,8 +135,12 @@ async fn restore_activities(
             .and_then(|category| CategoryName::new(category).ok());
 
         let mut activity = Activity::new(user_id.clone(), name, category);
-        if held.archived {
-            let _ = activity.archive();
+        if held.archived
+            && let Err(error) = activity.archive()
+        {
+            outcome
+                .unreadable
+                .push(format!("activity {}: {error}", held.name));
         }
 
         deps.activity_command.save(&activity).await?;
@@ -143,6 +158,9 @@ async fn restore_entries(
     deps: &Deps,
     outcome: &mut RestoreOutcome,
 ) -> Result<(), ApplicationError> {
+    let existing = deps.entry_query.find_all_by_user(user_id).await?;
+    let mut already_here = AlreadyHere::holding(&existing);
+
     for held in backed_up {
         let Ok(logged_at) = chrono::DateTime::parse_from_rfc3339(&held.logged_at) else {
             outcome
@@ -158,6 +176,12 @@ async fn restore_entries(
             continue;
         };
 
+        if already_here.holds(&logged_at, mood) {
+            outcome.skipped += 1;
+            continue;
+        }
+        already_here.remember(&logged_at, mood);
+
         let entry = MoodEntry::new(user_id.clone(), mood, logged_at);
         deps.entry_command.save(&entry).await?;
 
@@ -239,7 +263,14 @@ async fn restore_metrics(
             None => Source::Manual,
             Some(name) => match ProviderName::new(name) {
                 Ok(provider) => Source::Provider(provider),
-                Err(_) => Source::Manual,
+                Err(_) => {
+                    outcome.unreadable.push(format!(
+                        "metric {} on {}: {name} is not a usable provider name, so it reads as manual",
+                        held.kind, held.date
+                    ));
+
+                    Source::Manual
+                }
             },
         };
 
@@ -276,14 +307,20 @@ async fn restore_reminders(
     deps: &Deps,
     outcome: &mut RestoreOutcome,
 ) -> Result<(), ApplicationError> {
-    for held in backed_up {
-        let mut schedule = DaySchedule::new();
+    let existing: Vec<DaySchedule> = deps
+        .reminder_query
+        .find_by_user(user_id)
+        .await?
+        .iter()
+        .map(|reminder| reminder.schedule().clone())
+        .collect();
 
-        for (day, time) in WEEK.iter().zip(&held.times) {
-            let at = time
-                .as_ref()
-                .and_then(|time| NaiveTime::parse_from_str(time, "%H:%M").ok());
-            schedule.set_time(*day, at);
+    for held in backed_up {
+        let schedule = rebuilt_schedule(held);
+
+        if existing.contains(&schedule) {
+            outcome.skipped += 1;
+            continue;
         }
 
         let mut reminder = Reminder::new(user_id.clone(), schedule);
@@ -300,6 +337,19 @@ async fn restore_reminders(
     Ok(())
 }
 
+fn rebuilt_schedule(held: &RestorableReminder) -> DaySchedule {
+    let mut schedule = DaySchedule::new();
+
+    for (day, time) in WEEK.iter().zip(&held.times) {
+        let at = time
+            .as_ref()
+            .and_then(|time| NaiveTime::parse_from_str(time, "%H:%M").ok());
+        schedule.set_time(*day, at);
+    }
+
+    schedule
+}
+
 async fn restore_preferences(
     user_id: &UserId,
     tracks_cycle: bool,
@@ -314,41 +364,81 @@ async fn restore_preferences(
 }
 
 async fn restore_media(
+    owner: &UserId,
     contents: &RestorableContents,
     deps: &Deps,
     outcome: &mut RestoreOutcome,
 ) -> HashMap<String, String> {
     let mut renamed = HashMap::new();
 
-    for (was, bytes) in &contents.photos {
-        let Ok(upload) = photo_upload(bytes) else {
-            continue;
+    for held in &contents.photos {
+        let upload = match upload_of(held, PHOTO_FALLBACK_TYPE) {
+            Ok(upload) => upload,
+            Err(reason) => {
+                outcome
+                    .unreadable
+                    .push(format!("photo {}: {reason}", held.id));
+                continue;
+            }
         };
 
-        if let Ok(now) = deps.media_storage.store_photo(upload).await {
-            renamed.insert(was.clone(), now.value().to_string());
-            outcome.media += 1;
+        match deps.media_storage.store_photo(upload).await {
+            Ok(now) => {
+                remember(owner, (&now).into(), deps, outcome).await;
+                renamed.insert(held.id.clone(), now.value().to_string());
+                outcome.media += 1;
+            }
+            Err(error) => outcome
+                .unreadable
+                .push(format!("photo {}: could not be stored: {error}", held.id)),
         }
     }
 
-    for (was, bytes) in &contents.voice_memos {
-        let Ok(upload) = memo_upload(bytes) else {
-            continue;
+    for held in &contents.voice_memos {
+        let upload = match upload_of(held, VOICE_MEMO_FALLBACK_TYPE) {
+            Ok(upload) => upload,
+            Err(reason) => {
+                outcome
+                    .unreadable
+                    .push(format!("voice memo {}: {reason}", held.id));
+                continue;
+            }
         };
 
-        if let Ok(now) = deps.media_storage.store_voice_memo(upload).await {
-            renamed.insert(was.clone(), now.value().to_string());
-            outcome.media += 1;
+        match deps.media_storage.store_voice_memo(upload).await {
+            Ok(now) => {
+                remember(owner, (&now).into(), deps, outcome).await;
+                renamed.insert(held.id.clone(), now.value().to_string());
+                outcome.media += 1;
+            }
+            Err(error) => outcome.unreadable.push(format!(
+                "voice memo {}: could not be stored: {error}",
+                held.id
+            )),
         }
     }
 
     renamed
 }
 
-fn photo_upload(bytes: &[u8]) -> Result<MediaUpload, domain::errors::DomainError> {
-    MediaUpload::new(bytes.to_vec(), ContentType::new("image/jpeg")?)
+async fn remember(
+    owner: &UserId,
+    media: domain::attachment::MediaRef,
+    deps: &Deps,
+    outcome: &mut RestoreOutcome,
+) {
+    if let Err(error) = deps.media_ownership.remember(owner, media).await {
+        outcome
+            .unreadable
+            .push(format!("{media}: restored but not claimed: {error}"));
+    }
 }
 
-fn memo_upload(bytes: &[u8]) -> Result<MediaUpload, domain::errors::DomainError> {
-    MediaUpload::new(bytes.to_vec(), ContentType::new("audio/webm")?)
+fn upload_of(held: &RestorableMedia, fallback: &str) -> Result<MediaUpload, String> {
+    let content_type = match held.content_type.clone() {
+        Some(content_type) => content_type,
+        None => ContentType::new(fallback).map_err(|error| error.to_string())?,
+    };
+
+    MediaUpload::new(held.data.clone(), content_type).map_err(|error| error.to_string())
 }
diff --git a/crates/application/src/user/use_cases/change_password.rs b/crates/application/src/user/use_cases/change_password.rs
index f5d5cf3..09ea14d 100644
--- a/crates/application/src/user/use_cases/change_password.rs
+++ b/crates/application/src/user/use_cases/change_password.rs
@@ -1,7 +1,9 @@
 use std::sync::Arc;
 
 use domain::errors::DomainError;
-use domain::ports::{PasswordHasherPort, UserCommandPort, UserQueryPort};
+use domain::ports::{
+    PasswordHasherPort, RefreshSessionCommandPort, UserCommandPort, UserQueryPort,
+};
 
 use crate::errors::ApplicationError;
 
@@ -11,6 +13,7 @@ pub struct Deps {
     pub user_command: Arc<dyn UserCommandPort>,
     pub user_query: Arc<dyn UserQueryPort>,
     pub password_hasher: Arc<dyn PasswordHasherPort>,
+    pub refresh_sessions: Arc<dyn RefreshSessionCommandPort>,
 }
 
 #[tracing::instrument(skip_all, fields(user_id = %cmd.user_id))]
@@ -33,6 +36,9 @@ pub async fn execute(cmd: ChangePasswordCommand, deps: &Deps) -> Result<(), Appl
     user.update_password(new_hash);
 
     deps.user_command.save(&user).await?;
+    deps.refresh_sessions.revoke_all_for_user(user.id()).await?;
+
+    tracing::info!(user_id = %user.id(), "password changed and every session revoked");
 
     Ok(())
 }
diff --git a/crates/application/src/user/use_cases/clear_data.rs b/crates/application/src/user/use_cases/clear_data.rs
index a34b33b..0bc1d06 100644
--- a/crates/application/src/user/use_cases/clear_data.rs
+++ b/crates/application/src/user/use_cases/clear_data.rs
@@ -1,30 +1,25 @@
 use std::sync::Arc;
 
-use domain::ports::{CascadeDeletePort, EntryDimensionPort, MediaStoragePort, MoodEntryQueryPort};
+use domain::ports::{CascadeDeletePort, MediaOwnershipPort, MediaStoragePort};
 use domain::user::UserId;
 
-use crate::entry::composition::EntryComposer;
 use crate::errors::ApplicationError;
-use crate::media::cleanup::delete_media_for;
+use crate::media::cleanup::delete_everything_owned_by;
 
 pub struct Deps {
-    pub entry_query: Arc<dyn MoodEntryQueryPort>,
-    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
     pub cascade: Arc<dyn CascadeDeletePort>,
     pub media_storage: Arc<dyn MediaStoragePort>,
+    pub media_ownership: Arc<dyn MediaOwnershipPort>,
 }
 
 #[tracing::instrument(skip(deps))]
 pub async fn execute(user_id: UserId, deps: &Deps) -> Result<(), ApplicationError> {
-    let entries = deps.entry_query.find_by_user(&user_id, None, None).await?;
-
-    let composed = EntryComposer::new(deps.dimensions.clone())
-        .compose(entries)
-        .await?;
-    delete_media_for(&composed, &deps.media_storage).await;
+    let blobs =
+        delete_everything_owned_by(&user_id, &deps.media_storage, &deps.media_ownership).await?;
 
     deps.cascade.delete_all_user_data(&user_id).await?;
 
-    tracing::info!(%user_id, "all user data cleared");
+    tracing::info!(%user_id, blobs, "all user data cleared");
+
     Ok(())
 }
diff --git a/crates/application/src/user/use_cases/delete_user.rs b/crates/application/src/user/use_cases/delete_user.rs
index ea721c3..5a69da3 100644
--- a/crates/application/src/user/use_cases/delete_user.rs
+++ b/crates/application/src/user/use_cases/delete_user.rs
@@ -2,21 +2,18 @@ use std::sync::Arc;
 
 use domain::errors::DomainError;
 use domain::ports::{
-    CascadeDeletePort, EntryDimensionPort, EventPublisherPort, MediaStoragePort,
-    MoodEntryQueryPort, UserQueryPort,
+    CascadeDeletePort, EventPublisherPort, MediaOwnershipPort, MediaStoragePort, UserQueryPort,
 };
 use domain::user::UserId;
 
-use crate::entry::composition::EntryComposer;
 use crate::errors::ApplicationError;
-use crate::media::cleanup::delete_media_for;
+use crate::media::cleanup::delete_everything_owned_by;
 
 pub struct Deps {
     pub user_query: Arc<dyn UserQueryPort>,
-    pub entry_query: Arc<dyn MoodEntryQueryPort>,
-    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
     pub cascade: Arc<dyn CascadeDeletePort>,
     pub media_storage: Arc<dyn MediaStoragePort>,
+    pub media_ownership: Arc<dyn MediaOwnershipPort>,
     pub events: Arc<dyn EventPublisherPort>,
 }
 
@@ -27,14 +24,12 @@ pub async fn execute(user_id: UserId, deps: &Deps) -> Result<(), ApplicationErro
         .await?
         .ok_or_else(|| DomainError::NotFound("user not found".into()))?;
 
-    let entries = deps.entry_query.find_by_user(&user_id, None, None).await?;
-    let composed = EntryComposer::new(deps.dimensions.clone())
-        .compose(entries)
-        .await?;
-    delete_media_for(&composed, &deps.media_storage).await;
+    let blobs =
+        delete_everything_owned_by(&user_id, &deps.media_storage, &deps.media_ownership).await?;
 
     deps.cascade.delete_user_account(&user_id).await?;
 
-    tracing::info!(%user_id, "user account deleted");
+    tracing::info!(%user_id, blobs, "user account deleted");
+
     Ok(())
 }
diff --git a/crates/application/tests/activity/crud_test.rs b/crates/application/tests/activity/crud_test.rs
index 6946ca2..705b6d2 100644
--- a/crates/application/tests/activity/crud_test.rs
+++ b/crates/application/tests/activity/crud_test.rs
@@ -152,6 +152,7 @@ async fn deletes_activity() {
     store.save(&activity).await.unwrap();
 
     let deps = delete_activity::Deps {
+        entries: store.clone(),
         command: store.clone(),
         query: store.clone(),
     };
@@ -193,6 +194,7 @@ async fn delete_rejects_different_user() {
     store.save(&activity).await.unwrap();
 
     let deps = delete_activity::Deps {
+        entries: store.clone(),
         command: store.clone(),
         query: store.clone(),
     };
@@ -218,3 +220,73 @@ async fn archive_rejects_different_user() {
     let result = archive_activity::archive(activity.id().clone(), UserId::generate(), &deps).await;
     assert!(result.is_err());
 }
+
+#[tokio::test]
+async fn an_activity_entries_still_wear_cannot_be_deleted() {
+    let store = store_and_events();
+    let user = test_user("alice");
+    let activity = test_activity(user.id().clone(), "gaming");
+    store.save(&activity).await.unwrap();
+
+    let entry = domain::testing::test_entry(user.id().clone(), domain::entry::Mood::Good);
+    domain::ports::MoodEntryCommandPort::save(store.as_ref(), &entry)
+        .await
+        .unwrap();
+    store.assign_activities(entry.id(), vec![activity.id().clone()]);
+
+    let deps = delete_activity::Deps {
+        entries: store.clone(),
+        command: store.clone(),
+        query: store.clone(),
+    };
+
+    let refused = delete_activity::execute(activity.id().clone(), user.id().clone(), &deps).await;
+
+    assert!(
+        matches!(
+            refused,
+            Err(application::errors::ApplicationError::Validation(_))
+        ),
+        "deleting a tagged activity would rewrite history, got {refused:?}"
+    );
+    assert_eq!(
+        store.activity_count(),
+        1,
+        "the activity must survive so it can be archived instead"
+    );
+}
+
+#[tokio::test]
+async fn an_archived_activity_is_still_listable_so_it_can_be_unarchived() {
+    let store = store_and_events();
+    let user = test_user("alice");
+
+    let kept = test_activity(user.id().clone(), "reading");
+    store.save(&kept).await.unwrap();
+
+    let mut retired = test_activity(user.id().clone(), "fencing");
+    retired.archive().unwrap();
+    store.save(&retired).await.unwrap();
+
+    let deps = list_activities::Deps {
+        query: store.clone(),
+    };
+
+    let offered = list_activities::active_only(user.id().clone(), &deps)
+        .await
+        .unwrap();
+    assert_eq!(offered.len(), 1, "only the active one may be tagged");
+
+    let everything = list_activities::all(user.id().clone(), &deps)
+        .await
+        .unwrap();
+    assert_eq!(
+        everything.len(),
+        2,
+        "archiving must not put an activity beyond reach"
+    );
+    assert!(
+        everything.iter().any(|activity| activity.is_archived()),
+        "the archived one is the point"
+    );
+}
diff --git a/crates/application/tests/api_token/api_token_test.rs b/crates/application/tests/api_token/api_token_test.rs
index c40374c..2b322c4 100644
--- a/crates/application/tests/api_token/api_token_test.rs
+++ b/crates/application/tests/api_token/api_token_test.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use domain::api_token::ApiToken;
+use domain::api_token::{ApiToken, TokenScope, TokenScopes};
 use domain::ports::UserCommandPort;
 use domain::provider::ProviderName;
 use domain::testing::{FakeApiTokenSecret, InMemoryStore, test_user};
@@ -31,6 +31,14 @@ async fn a_user_with_no_tokens() -> Fixture {
 
 impl Fixture {
     async fn mint(&self, name: &str) -> Result<String, application::errors::ApplicationError> {
+        self.mint_granting(name, [TokenScope::WriteMetrics]).await
+    }
+
+    async fn mint_granting(
+        &self,
+        name: &str,
+        scopes: impl IntoIterator<Item = TokenScope>,
+    ) -> Result<String, application::errors::ApplicationError> {
         let deps = mint_api_token::Deps {
             command: self.store.clone(),
             secrets: self.secrets.clone(),
@@ -40,6 +48,7 @@ impl Fixture {
             MintApiTokenCommand {
                 user_id: self.user.id().clone(),
                 name: ProviderName::new(name)?,
+                scopes: TokenScopes::new(scopes)?,
             },
             &deps,
         )
@@ -49,13 +58,20 @@ impl Fixture {
     }
 
     async fn authenticate(&self, secret: &str) -> Option<ApiToken> {
+        self.authenticate_for(secret, TokenScope::WriteMetrics)
+            .await
+    }
+
+    async fn authenticate_for(&self, secret: &str, needed: TokenScope) -> Option<ApiToken> {
         let deps = authenticate_api_token::Deps {
             query: self.store.clone(),
             command: self.store.clone(),
             secrets: self.secrets.clone(),
         };
 
-        authenticate_api_token::execute(secret, &deps).await.ok()
+        authenticate_api_token::execute(secret, needed, &deps)
+            .await
+            .ok()
     }
 
     async fn list(&self) -> Vec<ApiToken> {
@@ -181,3 +197,83 @@ async fn every_minting_produces_a_different_secret() {
 
     assert_ne!(first, second);
 }
+
+#[tokio::test]
+async fn a_token_authenticates_only_for_a_scope_it_grants() {
+    let fixture = a_user_with_no_tokens().await;
+    let secret = fixture
+        .mint_granting("widget", [TokenScope::ReadJournal])
+        .await
+        .unwrap();
+
+    assert!(
+        fixture
+            .authenticate_for(&secret, TokenScope::ReadJournal)
+            .await
+            .is_some(),
+        "the scope it was minted for must work"
+    );
+
+    for refused in [
+        TokenScope::WriteJournal,
+        TokenScope::WriteMetrics,
+        TokenScope::ReadProfile,
+    ] {
+        assert!(
+            fixture.authenticate_for(&secret, refused).await.is_none(),
+            "a read-only token must not pass for {refused}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn a_token_can_grant_several_scopes_at_once() {
+    let fixture = a_user_with_no_tokens().await;
+    let secret = fixture
+        .mint_granting(
+            "widget",
+            [TokenScope::ReadJournal, TokenScope::WriteJournal],
+        )
+        .await
+        .unwrap();
+
+    assert!(
+        fixture
+            .authenticate_for(&secret, TokenScope::ReadJournal)
+            .await
+            .is_some()
+    );
+    assert!(
+        fixture
+            .authenticate_for(&secret, TokenScope::WriteJournal)
+            .await
+            .is_some()
+    );
+    assert!(
+        fixture
+            .authenticate_for(&secret, TokenScope::ReadProfile)
+            .await
+            .is_none()
+    );
+}
+
+#[tokio::test]
+async fn the_scopes_a_token_grants_are_listed_back() {
+    let fixture = a_user_with_no_tokens().await;
+    fixture
+        .mint_granting(
+            "widget",
+            [TokenScope::ReadJournal, TokenScope::WriteJournal],
+        )
+        .await
+        .unwrap();
+
+    let listed = fixture.list().await;
+
+    assert_eq!(listed.len(), 1);
+    assert_eq!(
+        listed[0].scopes().names(),
+        vec!["readJournal", "writeJournal"],
+        "a client needs to see what a token it holds can do"
+    );
+}
diff --git a/crates/application/tests/backup/round_trip_test.rs b/crates/application/tests/backup/round_trip_test.rs
index fe6298a..7b02607 100644
--- a/crates/application/tests/backup/round_trip_test.rs
+++ b/crates/application/tests/backup/round_trip_test.rs
@@ -68,14 +68,11 @@ async fn a_populated_account() -> World {
         .await
         .unwrap();
 
-    let attached = vec![
-        DimensionValue::Content(Content::new("Long walk by the river").unwrap()),
-        DimensionValue::activities(vec![walking.id().clone()]),
-        DimensionValue::Location(Coordinates::new(52.2297, 21.0122).unwrap()),
-        DimensionValue::Song(
-            Song::new("Teardrop", "Massive Attack", Some("Mezzanine".into()), None).unwrap(),
-        ),
-    ];
+    let attached = [
+        attached_to_the_walk(),
+        vec![DimensionValue::activities(vec![walking.id().clone()])],
+    ]
+    .concat();
     for port in &dimensions {
         port.save(entry.id(), &attached).await.unwrap();
     }
@@ -123,6 +120,16 @@ async fn a_populated_account() -> World {
     }
 }
 
+fn attached_to_the_walk() -> Vec<DimensionValue> {
+    vec![
+        DimensionValue::Content(Content::new("Long walk by the river").unwrap()),
+        DimensionValue::Location(Coordinates::new(52.2297, 21.0122).unwrap()),
+        DimensionValue::Song(
+            Song::new("Teardrop", "Massive Attack", Some("Mezzanine".into()), None).unwrap(),
+        ),
+    ]
+}
+
 fn on(day: &str) -> Date {
     Date::from_persistence(day.parse().unwrap())
 }
@@ -147,6 +154,9 @@ async fn backup_of(world: &World) -> Vec<u8> {
 
 async fn restore_into(world: &World, archive: Vec<u8>) -> RestoreOutcome {
     let deps = restore_backup::Deps {
+        entry_query: world.store.clone(),
+        reminder_query: world.store.clone(),
+        media_ownership: world.store.clone(),
         reader: Arc::new(importer::KmoodBackupAdapter),
         entry_command: world.store.clone(),
         dimensions: world.dimensions.clone(),
@@ -212,10 +222,9 @@ async fn every_dimension_survives_the_round_trip() {
     let restored = an_empty_account().await;
     restore_into(&restored, archive).await;
 
-    let entries =
-        MoodEntryQueryPort::find_by_user(restored.store.as_ref(), restored.user.id(), None, None)
-            .await
-            .unwrap();
+    let entries = MoodEntryQueryPort::find_all_by_user(restored.store.as_ref(), restored.user.id())
+        .await
+        .unwrap();
     let composed = application::entry::composition::EntryComposer::new(restored.dimensions.clone())
         .compose(entries)
         .await
@@ -248,10 +257,9 @@ async fn a_restored_activity_tag_points_at_the_restored_activity() {
     let catalog = ActivityQueryPort::find_by_user(restored.store.as_ref(), restored.user.id())
         .await
         .unwrap();
-    let entries =
-        MoodEntryQueryPort::find_by_user(restored.store.as_ref(), restored.user.id(), None, None)
-            .await
-            .unwrap();
+    let entries = MoodEntryQueryPort::find_all_by_user(restored.store.as_ref(), restored.user.id())
+        .await
+        .unwrap();
     let composed = application::entry::composition::EntryComposer::new(restored.dimensions.clone())
         .compose(entries)
         .await
@@ -305,6 +313,9 @@ async fn an_archive_that_is_not_a_backup_is_refused() {
     let restored = an_empty_account().await;
 
     let deps = restore_backup::Deps {
+        entry_query: restored.store.clone(),
+        reminder_query: restored.store.clone(),
+        media_ownership: restored.store.clone(),
         reader: Arc::new(importer::KmoodBackupAdapter),
         entry_command: restored.store.clone(),
         dimensions: restored.dimensions.clone(),
@@ -330,3 +341,155 @@ async fn an_archive_that_is_not_a_backup_is_refused() {
 
     assert!(refused.to_string().contains("zip"), "got {refused}");
 }
+
+async fn a_world_holding_a_png() -> (
+    World,
+    Arc<domain::testing::FakeMediaStorage>,
+    domain::attachment::PhotoId,
+) {
+    let world = a_populated_account().await;
+    let media = Arc::new(domain::testing::FakeMediaStorage::holding_nothing());
+
+    let photo_id = domain::attachment::PhotoId::generate();
+    media.put_photo_as(
+        &photo_id,
+        &[0x89, b'P', b'N', b'G'],
+        domain::attachment::ContentType::new("image/png").unwrap(),
+    );
+
+    let entries = MoodEntryQueryPort::find_all_by_user(world.store.as_ref(), world.user.id())
+        .await
+        .unwrap();
+
+    let everything = [
+        attached_to_the_walk(),
+        vec![DimensionValue::Photos(vec![photo_id.clone()])],
+    ]
+    .concat();
+
+    for port in &world.dimensions {
+        port.save(entries[0].id(), &everything).await.unwrap();
+    }
+
+    (world, media, photo_id)
+}
+
+#[tokio::test]
+async fn a_photos_own_type_survives_the_round_trip() {
+    let (world, media, photo_id) = a_world_holding_a_png().await;
+
+    let deps = write_backup::Deps {
+        entries: world.store.clone(),
+        dimensions: world.dimensions.clone(),
+        activities: world.store.clone(),
+        reminders: world.store.clone(),
+        metrics: world.store.clone(),
+        cycles: world.store.clone(),
+        preferences: world.store.clone(),
+        media_storage: media.clone(),
+        writer: Arc::new(exporter::ZipBackupWriter),
+    };
+    let archive = write_backup::execute(world.user.id().clone(), &deps)
+        .await
+        .unwrap();
+
+    let restored = an_empty_account().await;
+    let into = Arc::new(domain::testing::FakeMediaStorage::holding_nothing());
+
+    let deps = restore_backup::Deps {
+        entry_query: restored.store.clone(),
+        reminder_query: restored.store.clone(),
+        media_ownership: restored.store.clone(),
+        reader: Arc::new(importer::KmoodBackupAdapter),
+        entry_command: restored.store.clone(),
+        dimensions: restored.dimensions.clone(),
+        activity_command: restored.store.clone(),
+        activity_query: restored.store.clone(),
+        reminder_command: restored.store.clone(),
+        metrics: restored.store.clone(),
+        cycles: restored.store.clone(),
+        preferences_command: restored.store.clone(),
+        preferences_query: restored.store.clone(),
+        media_storage: into.clone(),
+    };
+
+    let outcome = restore_backup::execute(
+        RestoreBackupCommand {
+            user_id: restored.user.id().clone(),
+            data: archive,
+        },
+        &deps,
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(outcome.media, 1, "the photo should have been restored");
+    assert!(
+        outcome.unreadable.is_empty(),
+        "nothing should have been dropped: {:?}",
+        outcome.unreadable
+    );
+
+    let restored_photo = only_photo_of(&restored).await;
+
+    assert_ne!(
+        restored_photo, photo_id,
+        "a restored blob is a new blob with its own id"
+    );
+    assert_eq!(
+        into.type_of_photo(&restored_photo).unwrap().value(),
+        "image/png",
+        "a PNG must not come back labelled a JPEG"
+    );
+}
+
+async fn only_photo_of(world: &World) -> domain::attachment::PhotoId {
+    let entries = MoodEntryQueryPort::find_all_by_user(world.store.as_ref(), world.user.id())
+        .await
+        .unwrap();
+
+    let composed = application::entry::composition::EntryComposer::new(world.dimensions.clone())
+        .compose(entries)
+        .await
+        .unwrap();
+
+    composed
+        .iter()
+        .flat_map(|entry| entry.photos())
+        .next()
+        .expect("the restored entry should carry a photo")
+        .clone()
+}
+
+#[tokio::test]
+async fn restoring_the_same_backup_twice_does_not_double_the_account() {
+    let world = a_populated_account().await;
+    let archive = backup_of(&world).await;
+
+    let restored = an_empty_account().await;
+
+    let first = restore_into(&restored, archive.clone()).await;
+    assert_eq!(first.entries, 1);
+    assert_eq!(first.reminders, 1);
+
+    let again = restore_into(&restored, archive).await;
+
+    assert_eq!(again.entries, 0, "the entry was already here");
+    assert_eq!(again.reminders, 0, "the reminder was already here");
+    assert_eq!(again.activities, 0, "the activity was already here");
+    assert!(again.skipped >= 2, "the duplicates should be reported");
+
+    let entries = MoodEntryQueryPort::find_all_by_user(restored.store.as_ref(), restored.user.id())
+        .await
+        .unwrap();
+    assert_eq!(
+        entries.len(),
+        1,
+        "restoring twice must not duplicate history"
+    );
+
+    let reminders = ReminderQueryPort::find_by_user(restored.store.as_ref(), restored.user.id())
+        .await
+        .unwrap();
+    assert_eq!(reminders.len(), 1);
+}
diff --git a/crates/application/tests/correlation/get_correlations_test.rs b/crates/application/tests/correlation/get_correlations_test.rs
index 612c1c2..bc9eca0 100644
--- a/crates/application/tests/correlation/get_correlations_test.rs
+++ b/crates/application/tests/correlation/get_correlations_test.rs
@@ -78,6 +78,9 @@ async fn correlations(store: &Arc<InMemoryStore>, user: &User) -> Vec<Correlatio
         weather_store: Arc::new(domain::testing::InMemoryDimensionStore::new(
             domain::dimension::DimensionKind::Weather,
         )),
+        activity_store: Arc::new(domain::testing::InMemoryActivityDimension::sharing(
+            store.clone(),
+        )),
         preferences: store.clone(),
         users: store.clone(),
     };
@@ -281,6 +284,9 @@ async fn correlations_with_floor(
         weather_store: Arc::new(domain::testing::InMemoryDimensionStore::new(
             domain::dimension::DimensionKind::Weather,
         )),
+        activity_store: Arc::new(domain::testing::InMemoryActivityDimension::sharing(
+            store.clone(),
+        )),
         preferences: store.clone(),
         users: store.clone(),
     };
@@ -483,7 +489,7 @@ async fn an_activity_never_logged_in_the_span_is_not_a_row_at_all() {
 async fn deps_free_entries(store: &Arc<InMemoryStore>, user: &User) -> Vec<MoodEntry> {
     use domain::ports::MoodEntryQueryPort;
 
-    MoodEntryQueryPort::find_by_user(store.as_ref(), user.id(), None, None)
+    MoodEntryQueryPort::find_all_by_user(store.as_ref(), user.id())
         .await
         .unwrap()
 }
@@ -502,6 +508,9 @@ async fn correlations_with_rate(
         weather_store: Arc::new(domain::testing::InMemoryDimensionStore::new(
             domain::dimension::DimensionKind::Weather,
         )),
+        activity_store: Arc::new(domain::testing::InMemoryActivityDimension::sharing(
+            store.clone(),
+        )),
         preferences: store.clone(),
         users: store.clone(),
     };
@@ -737,3 +746,137 @@ async fn a_tracked_cycle_is_scored_like_anything_else_continuous() {
         ["pearson", "spearman", "kendall"]
     );
 }
+
+async fn an_entry_at(
+    store: &Arc<InMemoryStore>,
+    user: &User,
+    mood: Mood,
+    at: DateTime<FixedOffset>,
+) -> MoodEntry {
+    let entry = MoodEntry::new(user.id().clone(), mood, at);
+    MoodEntryCommandPort::save(store.as_ref(), &entry)
+        .await
+        .unwrap();
+
+    entry
+}
+
+fn weather_at(celsius: f64) -> domain::dimension::DimensionValue {
+    domain::dimension::DimensionValue::Weather(domain::weather::Weather::new(
+        domain::weather::Condition::Clear,
+        domain::weather::Celsius::new(celsius).unwrap(),
+        domain::provider::ProviderName::new("a-provider").unwrap(),
+    ))
+}
+
+async fn temperature_row_over(
+    readings: &[(usize, f64)],
+    order: &[usize],
+) -> Option<CorrelationRow> {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let weather_store = Arc::new(domain::testing::InMemoryDimensionStore::new(
+        domain::dimension::DimensionKind::Weather,
+    ));
+
+    for day in 0..40 {
+        let mood = a_rising_mood_for(day);
+        let mut entries = Vec::new();
+
+        for (offset, _) in readings {
+            entries.push(
+                an_entry_at(
+                    &store,
+                    &user,
+                    mood,
+                    noon_on(day) + Duration::hours(*offset as i64),
+                )
+                .await,
+            );
+        }
+
+        for position in order {
+            let (_, celsius) = readings[*position];
+            weather_store.put(entries[*position].id(), weather_at(celsius));
+        }
+    }
+
+    let deps = get_correlations::Deps {
+        entries: store.clone(),
+        metrics: store.clone(),
+        activities: store.clone(),
+        cycles: store.clone(),
+        weather_store: weather_store.clone(),
+        activity_store: Arc::new(domain::testing::InMemoryActivityDimension::sharing(
+            store.clone(),
+        )),
+        preferences: store.clone(),
+        users: store.clone(),
+    };
+
+    let query = CorrelationQuery {
+        user_id: user.id().clone(),
+        span: DateSpan::new(date_of(0), date_of(120)).unwrap(),
+        minimum_sample_size: MINIMUM,
+        false_discovery_rate: 0.10,
+    };
+
+    get_correlations::execute(query, &deps)
+        .await
+        .unwrap()
+        .into_iter()
+        .find(|row| row.input == CorrelationInput::Temperature)
+}
+
+#[tokio::test]
+async fn a_days_temperature_does_not_depend_on_the_order_its_entries_were_written() {
+    let readings = [(1usize, 4.0f64), (5, 27.0), (9, 15.0)];
+
+    let one_way = temperature_row_over(&readings, &[0, 1, 2]).await.unwrap();
+    let another = temperature_row_over(&readings, &[2, 0, 1]).await.unwrap();
+
+    let coefficients = |row: &CorrelationRow| {
+        row.scores
+            .iter()
+            .map(|score| score.coefficient.value())
+            .collect::<Vec<_>>()
+    };
+
+    assert_eq!(
+        coefficients(&one_way),
+        coefficients(&another),
+        "the day's reading is a property of the day, not of write order"
+    );
+    assert_eq!(one_way.sample_size, another.sample_size);
+}
+
+#[tokio::test]
+async fn a_day_is_represented_by_its_warmest_reading() {
+    let cold_first = [(1usize, 4.0f64), (5, 27.0)];
+    let warm_first = [(1usize, 27.0f64), (5, 4.0)];
+
+    let only_the_warmest = [(1usize, 27.0f64)];
+
+    let over_both_cold_first = temperature_row_over(&cold_first, &[0, 1]).await.unwrap();
+    let over_both_warm_first = temperature_row_over(&warm_first, &[0, 1]).await.unwrap();
+    let over_the_warmest = temperature_row_over(&only_the_warmest, &[0]).await.unwrap();
+
+    let coefficients = |row: &CorrelationRow| {
+        row.scores
+            .iter()
+            .map(|score| score.coefficient.value())
+            .collect::<Vec<_>>()
+    };
+
+    assert_eq!(
+        coefficients(&over_both_cold_first),
+        coefficients(&over_the_warmest),
+        "27C is the day's reading whether it was written first or last"
+    );
+    assert_eq!(
+        coefficients(&over_both_warm_first),
+        coefficients(&over_the_warmest)
+    );
+}
diff --git a/crates/application/tests/deletion/best_effort_test.rs b/crates/application/tests/deletion/best_effort_test.rs
index 6eda294..b192202 100644
--- a/crates/application/tests/deletion/best_effort_test.rs
+++ b/crates/application/tests/deletion/best_effort_test.rs
@@ -44,6 +44,7 @@ async fn a_blob_that_refuses_to_go_does_not_stop_the_entry_being_edited() {
         .unwrap();
 
     let deps = update_entry::Deps {
+        activities: store.clone(),
         command: store.clone(),
         dimensions: vec![photos.clone() as Arc<dyn EntryDimensionPort>],
         query: store.clone(),
@@ -54,11 +55,11 @@ async fn a_blob_that_refuses_to_go_does_not_stop_the_entry_being_edited() {
     let edited = update_entry::execute(
         UpdateEntryCommand {
             entry_id: entry.id().clone(),
-            mood: Mood::Rad,
+            mood: Some(Mood::Rad),
             logged_at: Some(
                 chrono::DateTime::parse_from_rfc3339("2026-08-20T12:00:00+02:00").unwrap(),
             ),
-            dimensions: Vec::new(),
+            dimensions: Some(Vec::new()),
         },
         owner,
         &deps,
@@ -134,6 +135,7 @@ async fn a_token_store_that_cannot_record_a_use_still_authenticates() {
         UserId::generate(),
         ProviderName::new("iphone-shortcuts").unwrap(),
         secrets.digest(&secret),
+        domain::api_token::TokenScopes::new([domain::api_token::TokenScope::WriteMetrics]).unwrap(),
     );
 
     let deps = authenticate_api_token::Deps {
@@ -142,7 +144,12 @@ async fn a_token_store_that_cannot_record_a_use_still_authenticates() {
         secrets,
     };
 
-    let authenticated = authenticate_api_token::execute(&secret, &deps).await;
+    let authenticated = authenticate_api_token::execute(
+        &secret,
+        domain::api_token::TokenScope::WriteMetrics,
+        &deps,
+    )
+    .await;
 
     assert!(
         authenticated.is_ok(),
@@ -160,6 +167,7 @@ async fn a_digest_that_matches_nothing_is_still_refused() {
         UserId::generate(),
         ProviderName::new("iphone-shortcuts").unwrap(),
         TokenDigest::from_persistence("some other digest".into()),
+        domain::api_token::TokenScopes::new([domain::api_token::TokenScope::WriteMetrics]).unwrap(),
     );
 
     let deps = authenticate_api_token::Deps {
@@ -169,7 +177,9 @@ async fn a_digest_that_matches_nothing_is_still_refused() {
     };
 
     assert!(
-        authenticate_api_token::execute(&real, &deps).await.is_err(),
+        authenticate_api_token::execute(&real, domain::api_token::TokenScope::WriteMetrics, &deps)
+            .await
+            .is_err(),
         "degrading on a write failure must not degrade into accepting anything"
     );
 }
diff --git a/crates/application/tests/deletion/ordering_test.rs b/crates/application/tests/deletion/ordering_test.rs
index 635f065..f6c8b0f 100644
--- a/crates/application/tests/deletion/ordering_test.rs
+++ b/crates/application/tests/deletion/ordering_test.rs
@@ -4,8 +4,8 @@ use domain::attachment::{PhotoId, VoiceMemoId};
 use domain::dimension::{DimensionKind, DimensionValue};
 use domain::entry::{DateRange, Mood, MoodEntry};
 use domain::ports::{
-    ActivityQueryPort, CascadeDeletePort, EntryDimensionPort, MoodEntryCommandPort,
-    ReminderQueryPort, UserCommandPort,
+    ActivityQueryPort, CascadeDeletePort, EntryDimensionPort, MediaOwnershipPort,
+    MoodEntryCommandPort, ReminderQueryPort, UserCommandPort,
 };
 use domain::testing::{FakeMediaStorage, InMemoryDimensionStore, InMemoryStore, test_user};
 use domain::user::{Timezone, User};
@@ -48,6 +48,13 @@ async fn an_entry_with_media(media: &Arc<FakeMediaStorage>) -> Doomed {
     media.put_photo(&photo_id, b"a photograph");
     media.put_voice_memo(&memo_id, b"a recording");
 
+    MediaOwnershipPort::remember(store.as_ref(), user.id(), (&photo_id).into())
+        .await
+        .unwrap();
+    MediaOwnershipPort::remember(store.as_ref(), user.id(), (&memo_id).into())
+        .await
+        .unwrap();
+
     photos
         .save(
             entry.id(),
@@ -150,10 +157,9 @@ async fn clearing_a_users_data_takes_the_blobs_with_it() {
     let doomed = an_entry_with_media(&media).await;
 
     let deps = clear_data::Deps {
-        entry_query: doomed.store.clone(),
-        dimensions: doomed.dimensions(),
         cascade: doomed.store.clone(),
         media_storage: media.clone(),
+        media_ownership: doomed.store.clone(),
     };
 
     clear_data::execute(doomed.user.id().clone(), &deps)
@@ -173,10 +179,9 @@ async fn deleting_an_account_takes_the_blobs_with_it() {
     let doomed = an_entry_with_media(&media).await;
 
     let deps = delete_user::Deps {
-        entry_query: doomed.store.clone(),
-        dimensions: doomed.dimensions(),
         cascade: doomed.store.clone(),
         media_storage: media.clone(),
+        media_ownership: doomed.store.clone(),
         user_query: doomed.store.clone(),
         events: doomed.store.clone(),
     };
diff --git a/crates/application/tests/entry.rs b/crates/application/tests/entry.rs
index 693e3bc..c8807e8 100644
--- a/crates/application/tests/entry.rs
+++ b/crates/application/tests/entry.rs
@@ -13,9 +13,6 @@ mod get_entry_test;
 #[path = "entry/list_entries_test.rs"]
 mod list_entries_test;
 
-#[path = "entry/filter_test.rs"]
-mod filter_test;
-
 #[path = "entry/mood_stats_test.rs"]
 mod mood_stats_test;
 
diff --git a/crates/application/tests/entry/create_entry_test.rs b/crates/application/tests/entry/create_entry_test.rs
index 8b457bd..22e403c 100644
--- a/crates/application/tests/entry/create_entry_test.rs
+++ b/crates/application/tests/entry/create_entry_test.rs
@@ -16,6 +16,7 @@ fn deps() -> (Arc<InMemoryStore>, create_entry::Deps) {
         Arc::new(InMemoryDimensionStore::new(DimensionKind::Activities));
 
     let deps = create_entry::Deps {
+        activities: store.clone(),
         entries: store.clone(),
         dimensions: vec![content, activities],
         events: store.clone(),
@@ -47,6 +48,9 @@ async fn creates_entry_with_optional_dimensions() {
     let (store, deps) = deps();
     let user = test_user("bob");
     let activity = domain::testing::test_activity(user.id().clone(), "gaming");
+    domain::ports::ActivityCommandPort::save(store.as_ref(), &activity)
+        .await
+        .unwrap();
 
     let cmd = CreateEntryCommand {
         user_id: user.id().clone(),
@@ -63,3 +67,190 @@ async fn creates_entry_with_optional_dimensions() {
     assert_eq!(entry.mood(), Mood::Rad);
     assert_eq!(store.entry_count(), 1);
 }
+
+#[tokio::test]
+async fn an_entry_cannot_wear_another_accounts_activity() {
+    let (store, deps) = deps();
+    let user = test_user("alice");
+    let stranger = test_user("mallory");
+
+    let theirs = domain::testing::test_activity(stranger.id().clone(), "fencing");
+    domain::ports::ActivityCommandPort::save(store.as_ref(), &theirs)
+        .await
+        .unwrap();
+
+    let cmd = CreateEntryCommand {
+        user_id: user.id().clone(),
+        mood: Mood::Good,
+        logged_at: test_logged_at(),
+        dimensions: vec![DimensionValue::activities(vec![theirs.id().clone()])],
+    };
+
+    let refused = create_entry::execute(cmd, &deps).await;
+
+    assert!(
+        matches!(
+            refused,
+            Err(application::errors::ApplicationError::Domain(
+                domain::errors::DomainError::Forbidden(_)
+            ))
+        ),
+        "tagging a stranger's activity must be refused, got {refused:?}"
+    );
+    assert_eq!(store.entry_count(), 0, "nothing should have been written");
+}
+
+#[tokio::test]
+async fn an_entry_cannot_wear_an_activity_that_does_not_exist() {
+    let (store, deps) = deps();
+    let user = test_user("alice");
+
+    let cmd = CreateEntryCommand {
+        user_id: user.id().clone(),
+        mood: Mood::Good,
+        logged_at: test_logged_at(),
+        dimensions: vec![DimensionValue::activities(vec![
+            domain::activity::ActivityId::generate(),
+        ])],
+    };
+
+    assert!(create_entry::execute(cmd, &deps).await.is_err());
+    assert_eq!(store.entry_count(), 0);
+}
+
+#[tokio::test]
+async fn an_archived_activity_cannot_be_tagged_onto_a_new_entry() {
+    let (store, deps) = deps();
+    let user = test_user("alice");
+
+    let mut retired = domain::testing::test_activity(user.id().clone(), "fencing");
+    retired.archive().unwrap();
+    domain::ports::ActivityCommandPort::save(store.as_ref(), &retired)
+        .await
+        .unwrap();
+
+    let cmd = CreateEntryCommand {
+        user_id: user.id().clone(),
+        mood: Mood::Good,
+        logged_at: test_logged_at(),
+        dimensions: vec![DimensionValue::activities(vec![retired.id().clone()])],
+    };
+
+    let refused = create_entry::execute(cmd, &deps).await;
+
+    assert!(
+        matches!(
+            refused,
+            Err(application::errors::ApplicationError::Validation(_))
+        ),
+        "an archived activity is retired, not forbidden, got {refused:?}"
+    );
+    assert_eq!(store.entry_count(), 0);
+}
+
+#[tokio::test]
+async fn unarchiving_makes_an_activity_taggable_again() {
+    let (store, deps) = deps();
+    let user = test_user("alice");
+
+    let mut activity = domain::testing::test_activity(user.id().clone(), "fencing");
+    activity.archive().unwrap();
+    activity.unarchive().unwrap();
+    domain::ports::ActivityCommandPort::save(store.as_ref(), &activity)
+        .await
+        .unwrap();
+
+    let cmd = CreateEntryCommand {
+        user_id: user.id().clone(),
+        mood: Mood::Good,
+        logged_at: test_logged_at(),
+        dimensions: vec![DimensionValue::activities(vec![activity.id().clone()])],
+    };
+
+    create_entry::execute(cmd, &deps).await.unwrap();
+
+    assert_eq!(store.entry_count(), 1);
+}
+
+#[tokio::test]
+async fn many_entries_land_in_one_request() {
+    let store = Arc::new(InMemoryStore::new());
+    let content: Arc<dyn EntryDimensionPort> =
+        Arc::new(InMemoryDimensionStore::new(DimensionKind::Content));
+    let user = test_user("alice");
+
+    let deps = application::entry::use_cases::create_entries::Deps {
+        entries: store.clone(),
+        dimensions: vec![content],
+        activities: store.clone(),
+        events: store.clone(),
+    };
+
+    let wanted: Vec<CreateEntryCommand> = [Mood::Good, Mood::Bad, Mood::Rad]
+        .into_iter()
+        .map(|mood| CreateEntryCommand {
+            user_id: user.id().clone(),
+            mood,
+            logged_at: test_logged_at(),
+            dimensions: vec![],
+        })
+        .collect();
+
+    let created =
+        application::entry::use_cases::create_entries::execute(user.id().clone(), wanted, &deps)
+            .await
+            .unwrap();
+
+    assert_eq!(created.len(), 3);
+    assert_eq!(store.entry_count(), 3);
+    assert_eq!(
+        store.published_events().len(),
+        3,
+        "each entry is its own event"
+    );
+}
+
+#[tokio::test]
+async fn one_bad_activity_refuses_the_whole_batch() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = test_user("alice");
+    let stranger = test_user("mallory");
+
+    let theirs = domain::testing::test_activity(stranger.id().clone(), "fencing");
+    domain::ports::ActivityCommandPort::save(store.as_ref(), &theirs)
+        .await
+        .unwrap();
+
+    let deps = application::entry::use_cases::create_entries::Deps {
+        entries: store.clone(),
+        dimensions: vec![],
+        activities: store.clone(),
+        events: store.clone(),
+    };
+
+    let wanted = vec![
+        CreateEntryCommand {
+            user_id: user.id().clone(),
+            mood: Mood::Good,
+            logged_at: test_logged_at(),
+            dimensions: vec![],
+        },
+        CreateEntryCommand {
+            user_id: user.id().clone(),
+            mood: Mood::Bad,
+            logged_at: test_logged_at(),
+            dimensions: vec![DimensionValue::activities(vec![theirs.id().clone()])],
+        },
+    ];
+
+    let refused =
+        application::entry::use_cases::create_entries::execute(user.id().clone(), wanted, &deps)
+            .await;
+
+    assert!(refused.is_err());
+    assert_eq!(
+        store.entry_count(),
+        0,
+        "the first entry must not survive a batch that was refused"
+    );
+}
diff --git a/crates/application/tests/entry/dimension_test.rs b/crates/application/tests/entry/dimension_test.rs
index 3743777..4dd7169 100644
--- a/crates/application/tests/entry/dimension_test.rs
+++ b/crates/application/tests/entry/dimension_test.rs
@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-use domain::activity::ActivityId;
 use domain::attachment::{PhotoId, VoiceMemoId};
 use domain::dimension::{DimensionKind, DimensionValue};
 use domain::entry::{Mood, MoodEntry};
@@ -105,11 +104,16 @@ async fn an_entry_composes_every_kind_of_dimension_it_has() {
     let store = Arc::new(domain::testing::InMemoryStore::new());
     let user = test_user("erin");
 
-    let activity_id = ActivityId::generate();
+    let activity = domain::testing::test_activity(user.id().clone(), "reading");
+    domain::ports::ActivityCommandPort::save(store.as_ref(), &activity)
+        .await
+        .unwrap();
+    let activity_id = activity.id().clone();
     let photo_id = PhotoId::generate();
     let voice_memo_id = VoiceMemoId::generate();
 
     let deps = create_entry::Deps {
+        activities: store.clone(),
         entries: store.clone(),
         dimensions: dimensions.ports(),
         events: store.clone(),
diff --git a/crates/application/tests/entry/filter_test.rs b/crates/application/tests/entry/filter_test.rs
deleted file mode 100644
index 12f8025..0000000
--- a/crates/application/tests/entry/filter_test.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use std::sync::Arc;
-
-use domain::entry::Mood;
-use domain::ports::MoodEntryCommandPort;
-use domain::testing::{InMemoryStore, test_activity, test_entry, test_user};
-
-use application::entry::queries::{FilterByActivityQuery, FilterByMoodQuery};
-use application::entry::use_cases::{filter_by_activity, filter_by_mood};
-
-#[tokio::test]
-async fn filters_by_mood() {
-    let store = Arc::new(InMemoryStore::new());
-    let user = test_user("alice");
-
-    store
-        .save(&test_entry(user.id().clone(), Mood::Good))
-        .await
-        .unwrap();
-    store
-        .save(&test_entry(user.id().clone(), Mood::Good))
-        .await
-        .unwrap();
-    store
-        .save(&test_entry(user.id().clone(), Mood::Bad))
-        .await
-        .unwrap();
-
-    let deps = filter_by_mood::Deps {
-        query: store.clone(),
-    };
-
-    let query = FilterByMoodQuery {
-        user_id: user.id().clone(),
-        mood: Mood::Good,
-    };
-
-    let entries = filter_by_mood::execute(query, &deps).await.unwrap();
-    assert_eq!(entries.len(), 2);
-}
-
-#[tokio::test]
-async fn filters_by_activity() {
-    let store = Arc::new(InMemoryStore::new());
-    let user = test_user("alice");
-    let activity = test_activity(user.id().clone(), "exercise");
-
-    let tagged = test_entry(user.id().clone(), Mood::Good);
-    store.save(&tagged).await.unwrap();
-    store.assign_activities(tagged.id(), vec![activity.id().clone()]);
-
-    store
-        .save(&test_entry(user.id().clone(), Mood::Meh))
-        .await
-        .unwrap();
-
-    let deps = filter_by_activity::Deps {
-        query: store.clone(),
-    };
-
-    let query = FilterByActivityQuery {
-        user_id: user.id().clone(),
-        activity_id: activity.id().clone(),
-    };
-
-    let entries = filter_by_activity::execute(query, &deps).await.unwrap();
-    assert_eq!(entries.len(), 1);
-}
diff --git a/crates/application/tests/entry/list_entries_test.rs b/crates/application/tests/entry/list_entries_test.rs
index 1d4738d..99b5227 100644
--- a/crates/application/tests/entry/list_entries_test.rs
+++ b/crates/application/tests/entry/list_entries_test.rs
@@ -1,60 +1,165 @@
 use std::sync::Arc;
 
-use domain::entry::Mood;
+use domain::entry::{EntrySelection, Mood, Pagination};
 use domain::ports::MoodEntryCommandPort;
-use domain::testing::{InMemoryStore, test_entry, test_user};
+use domain::testing::{InMemoryStore, test_activity, test_entry, test_user};
+use domain::user::User;
 
 use application::entry::queries::ListEntriesQuery;
 use application::entry::use_cases::list_entries;
 
+const A_GENEROUS_PAGE: i64 = 500;
+
+fn everything_of(user: &User) -> ListEntriesQuery {
+    ListEntriesQuery {
+        selection: EntrySelection::everything_of(user.id().clone()),
+        page: Pagination::new(A_GENEROUS_PAGE, 0, A_GENEROUS_PAGE).unwrap(),
+    }
+}
+
+async fn logged(store: &Arc<InMemoryStore>, user: &User, mood: Mood) -> domain::entry::MoodEntry {
+    let entry = test_entry(user.id().clone(), mood);
+    store.save(&entry).await.unwrap();
+
+    entry
+}
+
 #[tokio::test]
-async fn lists_entries_for_user() {
+async fn lists_only_the_asking_account() {
     let store = Arc::new(InMemoryStore::new());
     let alice = test_user("alice");
     let bob = test_user("bob");
 
-    store
-        .save(&test_entry(alice.id().clone(), Mood::Good))
-        .await
-        .unwrap();
-    store
-        .save(&test_entry(alice.id().clone(), Mood::Rad))
-        .await
-        .unwrap();
-    store
-        .save(&test_entry(bob.id().clone(), Mood::Meh))
-        .await
-        .unwrap();
+    logged(&store, &alice, Mood::Good).await;
+    logged(&store, &alice, Mood::Rad).await;
+    logged(&store, &bob, Mood::Meh).await;
 
     let deps = list_entries::Deps {
         query: store.clone(),
     };
+    let page = list_entries::execute(everything_of(&alice), &deps)
+        .await
+        .unwrap();
 
-    let query = ListEntriesQuery {
-        limit: None,
-        offset: None,
-        user_id: alice.id().clone(),
-        range: None,
-    };
-
-    let entries = list_entries::execute(query, &deps).await.unwrap();
-    assert_eq!(entries.len(), 2);
+    assert_eq!(page.items().len(), 2);
+    assert_eq!(page.total(), 2);
 }
 
 #[tokio::test]
-async fn returns_empty_for_user_with_no_entries() {
+async fn an_account_with_nothing_logged_gets_an_empty_page() {
     let store = Arc::new(InMemoryStore::new());
     let deps = list_entries::Deps {
         query: store.clone(),
     };
 
+    let page = list_entries::execute(everything_of(&test_user("nobody")), &deps)
+        .await
+        .unwrap();
+
+    assert!(page.items().is_empty());
+    assert_eq!(page.total(), 0);
+    assert!(!page.more_after_this());
+}
+
+#[tokio::test]
+async fn the_total_counts_the_selection_not_the_page() {
+    let store = Arc::new(InMemoryStore::new());
+    let alice = test_user("alice");
+
+    for _ in 0..7 {
+        logged(&store, &alice, Mood::Good).await;
+    }
+
+    let deps = list_entries::Deps {
+        query: store.clone(),
+    };
     let query = ListEntriesQuery {
-        limit: None,
-        offset: None,
-        user_id: test_user("nobody").id().clone(),
-        range: None,
+        selection: EntrySelection::everything_of(alice.id().clone()),
+        page: Pagination::new(3, 0, A_GENEROUS_PAGE).unwrap(),
     };
 
-    let entries = list_entries::execute(query, &deps).await.unwrap();
-    assert!(entries.is_empty());
+    let page = list_entries::execute(query, &deps).await.unwrap();
+
+    assert_eq!(page.items().len(), 3, "the page holds what was asked for");
+    assert_eq!(page.total(), 7, "the total is what a client pages through");
+    assert!(page.more_after_this());
+}
+
+#[tokio::test]
+async fn the_last_page_says_there_is_nothing_after_it() {
+    let store = Arc::new(InMemoryStore::new());
+    let alice = test_user("alice");
+
+    for _ in 0..5 {
+        logged(&store, &alice, Mood::Good).await;
+    }
+
+    let deps = list_entries::Deps {
+        query: store.clone(),
+    };
+    let query = ListEntriesQuery {
+        selection: EntrySelection::everything_of(alice.id().clone()),
+        page: Pagination::new(3, 3, A_GENEROUS_PAGE).unwrap(),
+    };
+
+    let page = list_entries::execute(query, &deps).await.unwrap();
+
+    assert_eq!(page.items().len(), 2);
+    assert_eq!(page.total(), 5);
+    assert!(!page.more_after_this());
+}
+
+#[tokio::test]
+async fn a_selection_can_narrow_to_one_mood() {
+    let store = Arc::new(InMemoryStore::new());
+    let alice = test_user("alice");
+
+    logged(&store, &alice, Mood::Good).await;
+    logged(&store, &alice, Mood::Good).await;
+    logged(&store, &alice, Mood::Bad).await;
+
+    let deps = list_entries::Deps {
+        query: store.clone(),
+    };
+    let query = ListEntriesQuery {
+        selection: EntrySelection::everything_of(alice.id().clone()).of_mood(Some(Mood::Good)),
+        page: Pagination::new(A_GENEROUS_PAGE, 0, A_GENEROUS_PAGE).unwrap(),
+    };
+
+    let page = list_entries::execute(query, &deps).await.unwrap();
+
+    assert_eq!(page.items().len(), 2);
+    assert_eq!(page.total(), 2);
+}
+
+#[tokio::test]
+async fn a_selection_can_narrow_to_one_activity() {
+    let store = Arc::new(InMemoryStore::new());
+    let alice = test_user("alice");
+    let exercise = test_activity(alice.id().clone(), "exercise");
+
+    let tagged = logged(&store, &alice, Mood::Good).await;
+    store.assign_activities(tagged.id(), vec![exercise.id().clone()]);
+    logged(&store, &alice, Mood::Meh).await;
+
+    let deps = list_entries::Deps {
+        query: store.clone(),
+    };
+    let query = ListEntriesQuery {
+        selection: EntrySelection::everything_of(alice.id().clone())
+            .tagged_with(Some(exercise.id().clone())),
+        page: Pagination::new(A_GENEROUS_PAGE, 0, A_GENEROUS_PAGE).unwrap(),
+    };
+
+    let page = list_entries::execute(query, &deps).await.unwrap();
+
+    assert_eq!(page.items().len(), 1);
+    assert_eq!(page.items()[0].id(), tagged.id());
+}
+
+#[tokio::test]
+async fn a_page_bigger_than_the_server_serves_is_refused() {
+    assert!(Pagination::new(1_000, 0, 200).is_err());
+    assert!(Pagination::new(0, 0, 200).is_err());
+    assert!(Pagination::new(10, -1, 200).is_err());
 }
diff --git a/crates/application/tests/entry/mood_stats_test.rs b/crates/application/tests/entry/mood_stats_test.rs
index 845aa47..0588c68 100644
--- a/crates/application/tests/entry/mood_stats_test.rs
+++ b/crates/application/tests/entry/mood_stats_test.rs
@@ -80,3 +80,72 @@ fn user_in(name: &str, timezone: &str) -> domain::user::User {
     user.update_timezone(Some(Timezone::new(timezone).unwrap()));
     user
 }
+
+fn a_user_in_warsaw() -> domain::user::User {
+    user_in("alice", "Europe/Warsaw")
+}
+
+async fn stats_of(
+    store: &Arc<InMemoryStore>,
+    user: &domain::user::User,
+    range: Option<domain::entry::DateRange>,
+) -> get_mood_stats::MoodStats {
+    let deps = get_mood_stats::Deps {
+        query: store.clone(),
+        users: store.clone(),
+    };
+
+    get_mood_stats::execute(
+        MoodStatsQuery {
+            user_id: user.id().clone(),
+            range,
+        },
+        &deps,
+    )
+    .await
+    .unwrap()
+}
+
+#[tokio::test]
+async fn the_bounds_are_the_days_the_journal_actually_spans() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for days_ago in [0, 5, 40] {
+        let entry = domain::testing::test_entry_days_ago(user.id().clone(), Mood::Good, days_ago);
+        MoodEntryCommandPort::save(store.as_ref(), &entry)
+            .await
+            .unwrap();
+    }
+
+    let stats = stats_of(&store, &user, None).await;
+
+    let today = domain::entry::Date::from_instant(
+        &chrono::Utc::now().fixed_offset(),
+        &domain::user::Timezone::new("Europe/Warsaw").unwrap(),
+    );
+
+    assert_eq!(
+        stats.last_logged_on,
+        Some(today),
+        "the newest entry was logged today"
+    );
+    assert!(
+        stats.first_logged_on.unwrap() < today,
+        "the oldest was forty days back"
+    );
+}
+
+#[tokio::test]
+async fn an_empty_journal_has_no_bounds() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let stats = stats_of(&store, &user, None).await;
+
+    assert_eq!(stats.total_entries, 0);
+    assert_eq!(stats.first_logged_on, None);
+    assert_eq!(stats.last_logged_on, None);
+}
diff --git a/crates/application/tests/entry/replace_activity_test.rs b/crates/application/tests/entry/replace_activity_test.rs
index ea6184b..f767941 100644
--- a/crates/application/tests/entry/replace_activity_test.rs
+++ b/crates/application/tests/entry/replace_activity_test.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use domain::activity::ActivityId;
 use domain::entry::Mood;
-use domain::ports::{ActivityCommandPort, MoodEntryCommandPort, MoodEntryQueryPort};
+use domain::ports::{ActivityCommandPort, MoodEntryCommandPort};
 use domain::testing::{InMemoryStore, test_activity, test_entry, test_user};
 
 use application::entry::use_cases::replace_activity;
@@ -29,8 +29,8 @@ async fn replaces_activity_on_entries() {
         .await
         .unwrap();
 
-    let now_tagged_new = store.find_by_activity(user.id(), new.id()).await.unwrap();
-    let still_tagged_old = store.find_by_activity(user.id(), old.id()).await.unwrap();
+    let now_tagged_new = tagged_with(&store, &user, new.id()).await;
+    let still_tagged_old = tagged_with(&store, &user, old.id()).await;
 
     assert_eq!(now_tagged_new.len(), 1);
     assert!(still_tagged_old.is_empty());
@@ -80,3 +80,17 @@ async fn rejects_target_owned_by_different_user() {
     .await;
     assert!(result.is_err());
 }
+
+async fn tagged_with(
+    store: &Arc<InMemoryStore>,
+    user: &domain::user::User,
+    activity_id: &domain::activity::ActivityId,
+) -> Vec<domain::entry::MoodEntry> {
+    let selection = domain::entry::EntrySelection::everything_of(user.id().clone())
+        .tagged_with(Some(activity_id.clone()));
+    let page = domain::entry::Pagination::new(500, 0, 500).unwrap();
+
+    domain::ports::MoodEntryQueryPort::select(store.as_ref(), &selection, page)
+        .await
+        .unwrap()
+}
diff --git a/crates/application/tests/entry/update_entry_test.rs b/crates/application/tests/entry/update_entry_test.rs
index 76ebf2b..22d408c 100644
--- a/crates/application/tests/entry/update_entry_test.rs
+++ b/crates/application/tests/entry/update_entry_test.rs
@@ -7,7 +7,8 @@ use domain::entry::Mood;
 use domain::ports::EntryDimensionPort;
 use domain::ports::MoodEntryCommandPort;
 use domain::testing::{
-    InMemoryDimensionStore, InMemoryStore, test_entry, test_logged_at, test_user,
+    InMemoryActivityDimension, InMemoryDimensionStore, InMemoryStore, test_entry, test_logged_at,
+    test_user,
 };
 use domain::user::UserId;
 
@@ -26,6 +27,7 @@ async fn setup() -> (
     store.save(&entry).await.unwrap();
 
     let deps = update_entry::Deps {
+        activities: store.clone(),
         command: store.clone(),
         dimensions: vec![
             Arc::new(InMemoryDimensionStore::new(DimensionKind::Content))
@@ -45,9 +47,9 @@ async fn updates_mood() {
 
     let cmd = UpdateEntryCommand {
         entry_id: entry.id().clone(),
-        mood: Mood::Rad,
+        mood: Some(Mood::Rad),
         logged_at: Some(test_logged_at()),
-        dimensions: vec![],
+        dimensions: Some(vec![]),
     };
 
     let updated = update_entry::execute(cmd, user_id, &deps).await.unwrap();
@@ -60,6 +62,7 @@ async fn updates_mood() {
 async fn updating_nonexistent_entry_fails() {
     let store = Arc::new(InMemoryStore::new());
     let deps = update_entry::Deps {
+        activities: store.clone(),
         command: store.clone(),
         dimensions: vec![
             Arc::new(InMemoryDimensionStore::new(DimensionKind::Content))
@@ -72,9 +75,9 @@ async fn updating_nonexistent_entry_fails() {
 
     let cmd = UpdateEntryCommand {
         entry_id: domain::entry::MoodEntryId::generate(),
-        mood: Mood::Good,
+        mood: Some(Mood::Good),
         logged_at: Some(test_logged_at()),
-        dimensions: vec![],
+        dimensions: Some(vec![]),
     };
 
     let result = update_entry::execute(cmd, UserId::generate(), &deps).await;
@@ -87,9 +90,9 @@ async fn rejects_update_by_different_user() {
 
     let cmd = UpdateEntryCommand {
         entry_id: entry.id().clone(),
-        mood: Mood::Rad,
+        mood: Some(Mood::Rad),
         logged_at: Some(test_logged_at()),
-        dimensions: vec![],
+        dimensions: Some(vec![]),
     };
 
     let other_user = UserId::generate();
@@ -103,9 +106,9 @@ async fn an_update_carrying_no_date_leaves_the_entry_where_it_was() {
 
     let cmd = UpdateEntryCommand {
         entry_id: entry.id().clone(),
-        mood: Mood::Rad,
+        mood: Some(Mood::Rad),
         logged_at: None,
-        dimensions: vec![],
+        dimensions: Some(vec![]),
     };
 
     let updated = update_entry::execute(cmd, user_id, &deps).await.unwrap();
@@ -124,12 +127,131 @@ async fn an_update_carrying_a_date_moves_the_entry_to_it() {
 
     let cmd = UpdateEntryCommand {
         entry_id: entry.id().clone(),
-        mood: Mood::Rad,
+        mood: Some(Mood::Rad),
         logged_at: Some(moved_to),
-        dimensions: vec![],
+        dimensions: Some(vec![]),
     };
 
     let updated = update_entry::execute(cmd, user_id, &deps).await.unwrap();
 
     assert_eq!(updated.logged_at(), &moved_to);
 }
+
+async fn an_entry_already_wearing(
+    user: &domain::user::User,
+    activity: &domain::activity::Activity,
+) -> (
+    Arc<InMemoryStore>,
+    update_entry::Deps,
+    domain::entry::MoodEntry,
+) {
+    let store = Arc::new(InMemoryStore::new());
+    let entry = test_entry(user.id().clone(), Mood::Meh);
+    MoodEntryCommandPort::save(store.as_ref(), &entry)
+        .await
+        .unwrap();
+
+    domain::ports::ActivityCommandPort::save(store.as_ref(), activity)
+        .await
+        .unwrap();
+
+    let tags: Arc<InMemoryActivityDimension> =
+        Arc::new(InMemoryActivityDimension::sharing(store.clone()));
+    tags.save(
+        entry.id(),
+        &[domain::dimension::DimensionValue::activities(vec![
+            activity.id().clone(),
+        ])],
+    )
+    .await
+    .unwrap();
+
+    let deps = update_entry::Deps {
+        activities: store.clone(),
+        command: store.clone(),
+        dimensions: vec![tags as Arc<dyn EntryDimensionPort>],
+        query: store.clone(),
+        media_storage: store.clone(),
+        events: store.clone(),
+    };
+
+    (store, deps, entry)
+}
+
+#[tokio::test]
+async fn an_entry_that_already_wears_an_archived_activity_can_still_be_edited() {
+    let user = test_user("alice");
+    let mut retired = domain::testing::test_activity(user.id().clone(), "fencing");
+    retired.archive().unwrap();
+
+    let (_store, deps, entry) = an_entry_already_wearing(&user, &retired).await;
+
+    let cmd = UpdateEntryCommand {
+        entry_id: entry.id().clone(),
+        mood: Some(Mood::Rad),
+        logged_at: None,
+        dimensions: Some(vec![domain::dimension::DimensionValue::activities(vec![
+            retired.id().clone(),
+        ])]),
+    };
+
+    let updated = update_entry::execute(cmd, entry.user_id().clone(), &deps)
+        .await
+        .expect("archived activities remain on the entries that already wear them");
+
+    assert_eq!(updated.mood(), Mood::Rad);
+}
+
+#[tokio::test]
+async fn an_archived_activity_cannot_be_added_to_an_entry_that_lacks_it() {
+    let user = test_user("alice");
+    let mut retired = domain::testing::test_activity(user.id().clone(), "fencing");
+    retired.archive().unwrap();
+
+    let worn = domain::testing::test_activity(user.id().clone(), "reading");
+    let (store, deps, entry) = an_entry_already_wearing(&user, &worn).await;
+
+    domain::ports::ActivityCommandPort::save(store.as_ref(), &retired)
+        .await
+        .unwrap();
+
+    let cmd = UpdateEntryCommand {
+        entry_id: entry.id().clone(),
+        mood: Some(Mood::Rad),
+        logged_at: None,
+        dimensions: Some(vec![domain::dimension::DimensionValue::activities(vec![
+            worn.id().clone(),
+            retired.id().clone(),
+        ])]),
+    };
+
+    let refused = update_entry::execute(cmd, entry.user_id().clone(), &deps).await;
+
+    assert!(
+        matches!(
+            refused,
+            Err(application::errors::ApplicationError::Validation(_))
+        ),
+        "editing an entry is not a way past the archive, got {refused:?}"
+    );
+}
+
+#[tokio::test]
+async fn an_archived_activity_can_be_taken_off_an_entry() {
+    let user = test_user("alice");
+    let mut retired = domain::testing::test_activity(user.id().clone(), "fencing");
+    retired.archive().unwrap();
+
+    let (_store, deps, entry) = an_entry_already_wearing(&user, &retired).await;
+
+    let cmd = UpdateEntryCommand {
+        entry_id: entry.id().clone(),
+        mood: Some(Mood::Rad),
+        logged_at: None,
+        dimensions: Some(vec![]),
+    };
+
+    update_entry::execute(cmd, entry.user_id().clone(), &deps)
+        .await
+        .expect("dropping a retired tag is always allowed");
+}
diff --git a/crates/application/tests/import/wall_clock_test.rs b/crates/application/tests/import/wall_clock_test.rs
index a7c43d5..72ec106 100644
--- a/crates/application/tests/import/wall_clock_test.rs
+++ b/crates/application/tests/import/wall_clock_test.rs
@@ -67,13 +67,12 @@ async fn import(
 }
 
 async fn instants_of(store: &Arc<InMemoryStore>, user: &User) -> Vec<String> {
-    let mut held: Vec<String> =
-        MoodEntryQueryPort::find_by_user(store.as_ref(), user.id(), None, None)
-            .await
-            .unwrap()
-            .iter()
-            .map(|entry| entry.logged_at().to_rfc3339())
-            .collect();
+    let mut held: Vec<String> = MoodEntryQueryPort::find_all_by_user(store.as_ref(), user.id())
+        .await
+        .unwrap()
+        .iter()
+        .map(|entry| entry.logged_at().to_rfc3339())
+        .collect();
     held.sort();
 
     held
@@ -194,3 +193,73 @@ async fn importing_the_same_export_twice_does_not_duplicate_anything() {
     assert_eq!(again.skipped, 1);
     assert_eq!(instants_of(&store, &user).await.len(), 1);
 }
+
+#[tokio::test]
+async fn re_importing_the_same_file_adds_nothing() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in(&store, Some("Europe/Warsaw")).await;
+
+    let rows = vec![
+        ("2026-08-25".to_string(), "20:00".to_string(), 4),
+        ("2026-08-26".to_string(), "09:30".to_string(), 2),
+    ];
+
+    let first = import(&store, &user, rows.clone()).await.unwrap();
+    assert_eq!(first.imported, 2);
+
+    let again = import(&store, &user, rows).await.unwrap();
+
+    assert_eq!(again.imported, 0, "every row was already here");
+    assert_eq!(again.skipped, 2);
+    assert_eq!(
+        store.entry_count(),
+        2,
+        "re-importing must not double the history"
+    );
+}
+
+#[tokio::test]
+async fn an_entry_held_in_utc_still_matches_a_row_written_in_local_time() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in(&store, Some("Europe/Warsaw")).await;
+
+    let eight_in_the_evening_in_warsaw =
+        chrono::DateTime::parse_from_rfc3339("2026-08-25T18:00:00+00:00").unwrap();
+    let held = domain::entry::MoodEntry::new(
+        user.id().clone(),
+        domain::entry::Mood::Good,
+        eight_in_the_evening_in_warsaw,
+    );
+    domain::ports::MoodEntryCommandPort::save(store.as_ref(), &held)
+        .await
+        .unwrap();
+
+    let outcome = import(
+        &store,
+        &user,
+        vec![("2026-08-25".to_string(), "20:00".to_string(), 4)],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        outcome.imported, 0,
+        "the same instant is the same entry whether it is held as +00:00 or +02:00"
+    );
+    assert_eq!(store.entry_count(), 1);
+}
+
+#[tokio::test]
+async fn a_row_repeated_inside_one_file_lands_once() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in(&store, Some("Europe/Warsaw")).await;
+
+    let repeated = ("2026-08-25".to_string(), "20:00".to_string(), 4);
+    let outcome = import(&store, &user, vec![repeated.clone(), repeated])
+        .await
+        .unwrap();
+
+    assert_eq!(outcome.imported, 1);
+    assert_eq!(outcome.skipped, 1);
+    assert_eq!(store.entry_count(), 1);
+}
diff --git a/crates/application/tests/media.rs b/crates/application/tests/media.rs
new file mode 100644
index 0000000..afdae4e
--- /dev/null
+++ b/crates/application/tests/media.rs
@@ -0,0 +1,2 @@
+#[path = "media/custody_test.rs"]
+mod custody_test;
diff --git a/crates/application/tests/media/custody_test.rs b/crates/application/tests/media/custody_test.rs
new file mode 100644
index 0000000..0c31556
--- /dev/null
+++ b/crates/application/tests/media/custody_test.rs
@@ -0,0 +1,138 @@
+use std::sync::Arc;
+
+use domain::attachment::{ContentType, MediaUpload};
+use domain::errors::DomainError;
+use domain::ports::MediaStoragePort;
+use domain::testing::{FakeMediaStorage, InMemoryStore, test_user};
+
+use application::errors::ApplicationError;
+use application::media::use_cases::{delete_photo, delete_voice_memo, upload_photo};
+
+fn an_upload() -> MediaUpload {
+    MediaUpload::new(vec![1, 2, 3], ContentType::new("image/png").unwrap()).unwrap()
+}
+
+fn upload_deps(storage: Arc<FakeMediaStorage>, store: Arc<InMemoryStore>) -> upload_photo::Deps {
+    upload_photo::Deps {
+        storage,
+        ownership: store,
+    }
+}
+
+#[tokio::test]
+async fn uploading_claims_the_photo_for_the_uploader() {
+    let storage = Arc::new(FakeMediaStorage::holding_nothing());
+    let store = Arc::new(InMemoryStore::new());
+    let owner = test_user("alice");
+
+    let photo_id = upload_photo::execute(
+        owner.id().clone(),
+        an_upload(),
+        &upload_deps(storage.clone(), store.clone()),
+    )
+    .await
+    .unwrap();
+
+    let deps = delete_photo::Deps {
+        storage: storage.clone(),
+        ownership: store.clone(),
+    };
+
+    delete_photo::execute(photo_id.clone(), owner.id().clone(), &deps)
+        .await
+        .expect("the owner may delete their own photo");
+
+    assert!(!storage.holds_photo(&photo_id));
+}
+
+#[tokio::test]
+async fn a_stranger_cannot_delete_someone_elses_photo() {
+    let storage = Arc::new(FakeMediaStorage::holding_nothing());
+    let store = Arc::new(InMemoryStore::new());
+    let owner = test_user("alice");
+    let stranger = test_user("mallory");
+
+    let photo_id = upload_photo::execute(
+        owner.id().clone(),
+        an_upload(),
+        &upload_deps(storage.clone(), store.clone()),
+    )
+    .await
+    .unwrap();
+
+    let deps = delete_photo::Deps {
+        storage: storage.clone(),
+        ownership: store.clone(),
+    };
+
+    let refused = delete_photo::execute(photo_id.clone(), stranger.id().clone(), &deps).await;
+
+    assert!(
+        matches!(
+            refused,
+            Err(ApplicationError::Domain(DomainError::Forbidden(_)))
+        ),
+        "a stranger must be refused, got {refused:?}"
+    );
+    assert!(
+        storage.holds_photo(&photo_id),
+        "the blob must survive a refused delete"
+    );
+}
+
+#[tokio::test]
+async fn media_nobody_claimed_cannot_be_deleted_by_anyone() {
+    let storage = Arc::new(FakeMediaStorage::holding_nothing());
+    let store = Arc::new(InMemoryStore::new());
+    let caller = test_user("alice");
+
+    let orphan = storage.store_photo(an_upload()).await.unwrap();
+
+    let deps = delete_photo::Deps {
+        storage: storage.clone(),
+        ownership: store.clone(),
+    };
+
+    let refused = delete_photo::execute(orphan.clone(), caller.id().clone(), &deps).await;
+
+    assert!(
+        matches!(
+            refused,
+            Err(ApplicationError::Domain(DomainError::NotFound(_)))
+        ),
+        "an unclaimed blob has no owner to check against, got {refused:?}"
+    );
+    assert!(storage.holds_photo(&orphan));
+}
+
+#[tokio::test]
+async fn a_voice_memo_id_is_not_a_photo_id() {
+    let storage = Arc::new(FakeMediaStorage::holding_nothing());
+    let store = Arc::new(InMemoryStore::new());
+    let owner = test_user("alice");
+
+    let photo_id = upload_photo::execute(
+        owner.id().clone(),
+        an_upload(),
+        &upload_deps(storage.clone(), store.clone()),
+    )
+    .await
+    .unwrap();
+
+    let memo_id = domain::attachment::VoiceMemoId::from_uuid(photo_id.value());
+
+    let deps = delete_voice_memo::Deps {
+        storage: storage.clone(),
+        ownership: store.clone(),
+    };
+
+    let refused = delete_voice_memo::execute(memo_id, owner.id().clone(), &deps).await;
+
+    assert!(
+        matches!(
+            refused,
+            Err(ApplicationError::Domain(DomainError::NotFound(_)))
+        ),
+        "claiming a photo must not claim a voice memo that shares its uuid, got {refused:?}"
+    );
+}
diff --git a/crates/application/tests/push.rs b/crates/application/tests/push.rs
new file mode 100644
index 0000000..c6eea14
--- /dev/null
+++ b/crates/application/tests/push.rs
@@ -0,0 +1,2 @@
+#[path = "push/subscription_test.rs"]
+mod subscription_test;
diff --git a/crates/application/tests/push/subscription_test.rs b/crates/application/tests/push/subscription_test.rs
new file mode 100644
index 0000000..cc62762
--- /dev/null
+++ b/crates/application/tests/push/subscription_test.rs
@@ -0,0 +1,112 @@
+use std::sync::Arc;
+
+use domain::ports::PushSubscriptionQueryPort;
+use domain::testing::{InMemoryStore, test_user};
+
+use application::push::commands::{SubscribePushCommand, UnsubscribePushCommand};
+use application::push::use_cases::{subscribe, unsubscribe};
+
+const ENDPOINT: &str = "https://push.example.com/a-device";
+
+fn a_subscription(user_id: domain::user::UserId) -> SubscribePushCommand {
+    SubscribePushCommand {
+        user_id,
+        endpoint: ENDPOINT.into(),
+        p256dh: "a-key".into(),
+        auth: "a-secret".into(),
+    }
+}
+
+#[tokio::test]
+async fn subscribing_twice_keeps_one_subscription() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = test_user("alice");
+
+    let deps = subscribe::Deps {
+        push_command: store.clone(),
+        push_query: store.clone(),
+    };
+
+    subscribe::execute(a_subscription(user.id().clone()), &deps)
+        .await
+        .unwrap();
+    let first = store.find_by_endpoint(ENDPOINT).await.unwrap().unwrap();
+
+    subscribe::execute(a_subscription(user.id().clone()), &deps)
+        .await
+        .unwrap();
+
+    let held = store.find_by_user(user.id()).await.unwrap();
+
+    assert_eq!(held.len(), 1, "one device is one subscription");
+    assert_eq!(
+        held[0].id(),
+        first.id(),
+        "re-subscribing renews the subscription rather than minting a new one"
+    );
+}
+
+#[tokio::test]
+async fn a_stranger_cannot_unsubscribe_someone_elses_device() {
+    let store = Arc::new(InMemoryStore::new());
+    let owner = test_user("alice");
+    let stranger = test_user("mallory");
+
+    let deps = subscribe::Deps {
+        push_command: store.clone(),
+        push_query: store.clone(),
+    };
+    subscribe::execute(a_subscription(owner.id().clone()), &deps)
+        .await
+        .unwrap();
+
+    let deps = unsubscribe::Deps {
+        push_command: store.clone(),
+    };
+
+    unsubscribe::execute(
+        UnsubscribePushCommand {
+            user_id: stranger.id().clone(),
+            endpoint: ENDPOINT.into(),
+        },
+        &deps,
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        store.find_by_user(owner.id()).await.unwrap().len(),
+        1,
+        "the owner's device must still be subscribed"
+    );
+}
+
+#[tokio::test]
+async fn the_owner_can_unsubscribe_their_own_device() {
+    let store = Arc::new(InMemoryStore::new());
+    let owner = test_user("alice");
+
+    let deps = subscribe::Deps {
+        push_command: store.clone(),
+        push_query: store.clone(),
+    };
+    subscribe::execute(a_subscription(owner.id().clone()), &deps)
+        .await
+        .unwrap();
+
+    let deps = unsubscribe::Deps {
+        push_command: store.clone(),
+    };
+
+    unsubscribe::execute(
+        UnsubscribePushCommand {
+            user_id: owner.id().clone(),
+            endpoint: ENDPOINT.into(),
+        },
+        &deps,
+    )
+    .await
+    .unwrap();
+
+    assert!(store.find_by_user(owner.id()).await.unwrap().is_empty());
+}
diff --git a/crates/application/tests/reminder/process_due_test.rs b/crates/application/tests/reminder/process_due_test.rs
index 3d9d803..df62f55 100644
--- a/crates/application/tests/reminder/process_due_test.rs
+++ b/crates/application/tests/reminder/process_due_test.rs
@@ -1,6 +1,6 @@
 use std::sync::{Arc, Mutex};
 
-use chrono::Utc;
+use chrono::{Duration, Utc};
 
 use domain::errors::DomainError;
 use domain::ports::{ReminderCommandPort, ReminderSenderPort, UserCommandPort};
@@ -71,8 +71,10 @@ async fn a_failing_send_does_not_abort_the_sweep() {
     let sender = Arc::new(FlakySender::new(broken.id().clone()));
     let deps = process_due_reminders::Deps {
         reminder_query: store.clone(),
+        reminder_command: store.clone(),
         user_query: store.clone(),
         sender: sender.clone(),
+        grace: Duration::minutes(30),
     };
 
     let sent = process_due_reminders::execute(&deps).await.unwrap();
@@ -85,3 +87,89 @@ async fn a_failing_send_does_not_abort_the_sweep() {
         "both users should have been attempted regardless of order, got {attempts:?}"
     );
 }
+
+struct CountingSender {
+    attempts: Mutex<Vec<UserId>>,
+}
+
+impl CountingSender {
+    fn new() -> Self {
+        Self {
+            attempts: Mutex::new(Vec::new()),
+        }
+    }
+
+    fn count(&self) -> usize {
+        self.attempts.lock().unwrap().len()
+    }
+}
+
+#[async_trait::async_trait]
+impl ReminderSenderPort for CountingSender {
+    async fn send_reminder(&self, user_id: &UserId) -> Result<(), DomainError> {
+        self.attempts.lock().unwrap().push(user_id.clone());
+
+        Ok(())
+    }
+}
+
+#[tokio::test]
+async fn a_reminder_is_sent_once_however_often_the_sweep_runs() {
+    let store = Arc::new(InMemoryStore::new());
+
+    let mut user = test_user("nadia");
+    user.update_timezone(Some(Timezone::new("UTC").unwrap()));
+    UserCommandPort::save(&*store, &user).await.unwrap();
+    ReminderCommandPort::save(&*store, &due_now(user.id().clone()))
+        .await
+        .unwrap();
+
+    let sender = Arc::new(CountingSender::new());
+    let deps = process_due_reminders::Deps {
+        reminder_query: store.clone(),
+        reminder_command: store.clone(),
+        user_query: store.clone(),
+        sender: sender.clone(),
+        grace: Duration::minutes(30),
+    };
+
+    for _ in 0..5 {
+        process_due_reminders::execute(&deps).await.unwrap();
+    }
+
+    assert_eq!(
+        sender.count(),
+        1,
+        "five sweeps inside one grace window must still send one reminder"
+    );
+}
+
+#[tokio::test]
+async fn a_send_that_fails_is_retried_by_the_next_sweep() {
+    let store = Arc::new(InMemoryStore::new());
+
+    let mut user = test_user("broken");
+    user.update_timezone(Some(Timezone::new("UTC").unwrap()));
+    UserCommandPort::save(&*store, &user).await.unwrap();
+    ReminderCommandPort::save(&*store, &due_now(user.id().clone()))
+        .await
+        .unwrap();
+
+    let sender = Arc::new(FlakySender::new(user.id().clone()));
+    let deps = process_due_reminders::Deps {
+        reminder_query: store.clone(),
+        reminder_command: store.clone(),
+        user_query: store.clone(),
+        sender: sender.clone(),
+        grace: Duration::minutes(30),
+    };
+
+    process_due_reminders::execute(&deps).await.unwrap();
+    process_due_reminders::execute(&deps).await.unwrap();
+
+    assert_eq!(
+        sender.attempts().len(),
+        2,
+        "nothing was delivered, so the occurrence is still owed"
+    );
+}
diff --git a/crates/application/tests/user/change_password_test.rs b/crates/application/tests/user/change_password_test.rs
index 17dfc09..826910e 100644
--- a/crates/application/tests/user/change_password_test.rs
+++ b/crates/application/tests/user/change_password_test.rs
@@ -17,6 +17,7 @@ async fn setup() -> (Arc<InMemoryStore>, change_password::Deps, User) {
     store.save(&user).await.unwrap();
 
     let deps = change_password::Deps {
+        refresh_sessions: store.clone(),
         user_command: store.clone(),
         user_query: store.clone(),
         password_hasher: Arc::new(FakePasswordHasher),
@@ -65,3 +66,64 @@ async fn rejects_nonexistent_user() {
     let result = change_password::execute(cmd, &deps).await;
     assert!(result.is_err());
 }
+
+#[tokio::test]
+async fn changing_a_password_revokes_every_live_session() {
+    let (store, deps, user) = setup().await;
+
+    for _ in 0..3 {
+        domain::ports::RefreshSessionCommandPort::create(
+            store.as_ref(),
+            &domain::auth::RefreshSession::new(user.id().clone(), 3_600),
+        )
+        .await
+        .unwrap();
+    }
+
+    assert_eq!(store.refresh_sessions.read().unwrap().len(), 3);
+
+    change_password::execute(
+        ChangePasswordCommand {
+            user_id: user.id().clone(),
+            current_password: "secret".into(),
+            new_password: "new-secret".into(),
+        },
+        &deps,
+    )
+    .await
+    .unwrap();
+
+    assert!(
+        store.refresh_sessions.read().unwrap().is_empty(),
+        "a stolen refresh token must not survive a password change"
+    );
+}
+
+#[tokio::test]
+async fn a_refused_password_change_leaves_sessions_alone() {
+    let (store, deps, user) = setup().await;
+
+    domain::ports::RefreshSessionCommandPort::create(
+        store.as_ref(),
+        &domain::auth::RefreshSession::new(user.id().clone(), 3_600),
+    )
+    .await
+    .unwrap();
+
+    let refused = change_password::execute(
+        ChangePasswordCommand {
+            user_id: user.id().clone(),
+            current_password: "not-the-password".into(),
+            new_password: "new-secret".into(),
+        },
+        &deps,
+    )
+    .await;
+
+    assert!(refused.is_err());
+    assert_eq!(
+        store.refresh_sessions.read().unwrap().len(),
+        1,
+        "a failed attempt must not log the account out"
+    );
+}
diff --git a/crates/application/tests/user/clear_data_test.rs b/crates/application/tests/user/clear_data_test.rs
index 79fee43..b26738e 100644
--- a/crates/application/tests/user/clear_data_test.rs
+++ b/crates/application/tests/user/clear_data_test.rs
@@ -1,33 +1,160 @@
 use std::sync::Arc;
 
-use domain::entry::Mood;
-use domain::ports::{ActivityCommandPort, MoodEntryCommandPort, ReminderCommandPort};
+use domain::entry::{Date, DateSpan, Mood};
+use domain::metric::{DailyMetric, MetricValue, Source, Steps};
+use domain::ports::{
+    ActivityCommandPort, CycleStartCommandPort, CycleStartQueryPort, DailyMetricCommandPort,
+    DailyMetricQueryPort, MediaOwnershipPort, MoodEntryCommandPort, RejectionCommandPort,
+    RejectionQueryPort, ReminderCommandPort, UserQueryPort,
+};
+use domain::rejection::{RejectedMetric, RejectionDetail, RejectionOrigin};
 use domain::testing::{InMemoryStore, test_activity, test_entry, test_reminder, test_user};
+use domain::user::User;
 
 use application::user::use_cases::clear_data;
 
-#[tokio::test]
-async fn clears_all_user_data() {
-    let store = Arc::new(InMemoryStore::new());
+fn on(day: &str) -> Date {
+    Date::from_persistence(day.parse().unwrap())
+}
+
+fn everything() -> DateSpan {
+    DateSpan::new(on("1970-01-01"), on("9999-12-31")).unwrap()
+}
+
+async fn an_account_with_everything_in_it(store: &Arc<InMemoryStore>) -> User {
     let user = test_user("alice");
-    let entry = test_entry(user.id().clone(), Mood::Good);
-    let activity = test_activity(user.id().clone(), "gaming");
-    let reminder = test_reminder(user.id().clone());
+    domain::ports::UserCommandPort::save(store.as_ref(), &user)
+        .await
+        .unwrap();
 
-    MoodEntryCommandPort::save(&*store, &entry).await.unwrap();
-    ActivityCommandPort::save(&*store, &activity).await.unwrap();
-    ReminderCommandPort::save(&*store, &reminder).await.unwrap();
+    MoodEntryCommandPort::save(store.as_ref(), &test_entry(user.id().clone(), Mood::Good))
+        .await
+        .unwrap();
+    ActivityCommandPort::save(store.as_ref(), &test_activity(user.id().clone(), "gaming"))
+        .await
+        .unwrap();
+    ReminderCommandPort::save(store.as_ref(), &test_reminder(user.id().clone()))
+        .await
+        .unwrap();
+    DailyMetricCommandPort::save(
+        store.as_ref(),
+        &[DailyMetric::new(
+            user.id().clone(),
+            on("2026-08-20"),
+            MetricValue::Steps(Steps::new(8_412).unwrap()),
+            Source::Manual,
+        )],
+    )
+    .await
+    .unwrap();
+    CycleStartCommandPort::record(store.as_ref(), user.id(), &on("2026-08-01"))
+        .await
+        .unwrap();
+    RejectionCommandPort::record(
+        store.as_ref(),
+        &[RejectedMetric::new(
+            user.id().clone(),
+            RejectionOrigin::Import,
+            RejectionDetail::new(None, Some(on("2026-08-19")), "steps", Some(-1)),
+            String::from("steps cannot be negative"),
+        )],
+    )
+    .await
+    .unwrap();
+    MediaOwnershipPort::remember(
+        store.as_ref(),
+        user.id(),
+        (&domain::attachment::PhotoId::generate()).into(),
+    )
+    .await
+    .unwrap();
 
-    let deps = clear_data::Deps {
-        dimensions: vec![],
-        entry_query: store.clone(),
+    user
+}
+
+fn deps(store: &Arc<InMemoryStore>) -> clear_data::Deps {
+    clear_data::Deps {
         cascade: store.clone(),
         media_storage: store.clone(),
-    };
-
-    clear_data::execute(user.id().clone(), &deps).await.unwrap();
-
-    assert_eq!(store.entry_count(), 0);
-    assert_eq!(store.activity_count(), 0);
-    assert_eq!(store.reminder_count(), 0);
+        media_ownership: store.clone(),
+    }
+}
+
+#[tokio::test]
+async fn clearing_leaves_nothing_the_user_logged() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = an_account_with_everything_in_it(&store).await;
+
+    clear_data::execute(user.id().clone(), &deps(&store))
+        .await
+        .unwrap();
+
+    assert_eq!(store.entry_count(), 0, "entries");
+    assert_eq!(store.activity_count(), 0, "activities");
+    assert_eq!(store.reminder_count(), 0, "reminders");
+
+    let metrics = DailyMetricQueryPort::find_by_span(store.as_ref(), user.id(), &everything())
+        .await
+        .unwrap();
+    assert!(metrics.is_empty(), "daily metrics");
+
+    let starts = CycleStartQueryPort::find_by_user(store.as_ref(), user.id())
+        .await
+        .unwrap();
+    assert!(starts.is_empty(), "cycle starts");
+
+    let rejections = RejectionQueryPort::find_recent_by_user(store.as_ref(), user.id())
+        .await
+        .unwrap();
+    assert!(rejections.is_empty(), "rejected metrics");
+
+    let media = MediaOwnershipPort::owned_by(store.as_ref(), user.id())
+        .await
+        .unwrap();
+    assert!(media.is_empty(), "media ownership");
+}
+
+#[tokio::test]
+async fn clearing_keeps_the_account_itself() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = an_account_with_everything_in_it(&store).await;
+
+    clear_data::execute(user.id().clone(), &deps(&store))
+        .await
+        .unwrap();
+
+    assert!(
+        UserQueryPort::find_by_id(store.as_ref(), user.id())
+            .await
+            .unwrap()
+            .is_some(),
+        "clearing data is not deleting the account"
+    );
+}
+
+#[tokio::test]
+async fn clearing_one_account_leaves_another_alone() {
+    let store = Arc::new(InMemoryStore::new());
+    let alice = an_account_with_everything_in_it(&store).await;
+
+    let bob = test_user("bob");
+    domain::ports::UserCommandPort::save(store.as_ref(), &bob)
+        .await
+        .unwrap();
+    MoodEntryCommandPort::save(store.as_ref(), &test_entry(bob.id().clone(), Mood::Rad))
+        .await
+        .unwrap();
+    CycleStartCommandPort::record(store.as_ref(), bob.id(), &on("2026-07-01"))
+        .await
+        .unwrap();
+
+    clear_data::execute(alice.id().clone(), &deps(&store))
+        .await
+        .unwrap();
+
+    assert_eq!(store.entry_count(), 1, "bob's entry must survive");
+    let starts = CycleStartQueryPort::find_by_user(store.as_ref(), bob.id())
+        .await
+        .unwrap();
+    assert_eq!(starts.len(), 1, "bob's cycle start must survive");
 }
diff --git a/crates/application/tests/user/delete_user_test.rs b/crates/application/tests/user/delete_user_test.rs
index f82277d..8517528 100644
--- a/crates/application/tests/user/delete_user_test.rs
+++ b/crates/application/tests/user/delete_user_test.rs
@@ -11,11 +11,10 @@ use application::user::use_cases::delete_user;
 
 fn deps(store: &Arc<InMemoryStore>) -> delete_user::Deps {
     delete_user::Deps {
-        dimensions: vec![],
         user_query: store.clone(),
-        entry_query: store.clone(),
         cascade: store.clone(),
         media_storage: store.clone(),
+        media_ownership: store.clone(),
         events: store.clone(),
     }
 }
diff --git a/crates/bootstrap/src/factory.rs b/crates/bootstrap/src/factory.rs
index d9ac0f7..e2bd318 100644
--- a/crates/bootstrap/src/factory.rs
+++ b/crates/bootstrap/src/factory.rs
@@ -48,12 +48,17 @@ pub async fn build(config: AppConfig) -> Result<Context, Box<dyn std::error::Err
     let weather_store = Arc::new(sqlite::repositories::SqliteWeatherDimensionRepository::new(
         pool.clone(),
     ));
+    let activity_store =
+        Arc::new(sqlite::repositories::SqliteRelationDimensionRepository::activities(pool.clone()));
+    let media_ownership = Arc::new(sqlite::repositories::SqliteMediaOwnershipRepository::new(
+        pool.clone(),
+    ));
 
     let dimensions: Vec<Arc<dyn domain::ports::EntryDimensionPort>> = vec![
         Arc::new(sqlite::repositories::SqliteContentDimensionRepository::new(
             pool.clone(),
         )),
-        Arc::new(sqlite::repositories::SqliteRelationDimensionRepository::activities(pool.clone())),
+        activity_store.clone(),
         Arc::new(sqlite::repositories::SqliteRelationDimensionRepository::photos(pool.clone())),
         Arc::new(
             sqlite::repositories::SqliteRelationDimensionRepository::voice_memos(pool.clone()),
@@ -178,10 +183,12 @@ pub async fn build(config: AppConfig) -> Result<Context, Box<dyn std::error::Err
         entry_query,
         dimensions,
         weather_store: weather_store.clone(),
+        activity_store: activity_store.clone(),
         provider_connection_command,
         provider_connection_query,
         credential_cipher,
         now_playing,
+        weather_enabled: weather_lookup.is_some(),
         recording_lookup: recording_lookup.clone(),
         activity_command,
         activity_query,
@@ -207,6 +214,8 @@ pub async fn build(config: AppConfig) -> Result<Context, Box<dyn std::error::Err
         password_hasher: Arc::new(password_hasher),
         event_publisher: Arc::new(event_publisher),
         media_storage: Arc::new(media_storage),
+        media_ownership,
+        job_view: job_queue.clone(),
         backup_writer: Arc::new(exporter::ZipBackupWriter),
         backup_reader: Arc::new(importer::KmoodBackupAdapter),
         extract_writer: Arc::new(exporter::MarkdownExtractWriter),
diff --git a/crates/config/src/entry_config.rs b/crates/config/src/entry_config.rs
index ebf636b..28eec5c 100644
--- a/crates/config/src/entry_config.rs
+++ b/crates/config/src/entry_config.rs
@@ -2,6 +2,7 @@ const DEFAULT_MAX_CONTENT_LENGTH: usize = 65_536;
 const DEFAULT_MAX_PHOTOS: usize = 10;
 const DEFAULT_MAX_VOICE_MEMOS: usize = 5;
 const DEFAULT_MAX_ACTIVITIES_PER_ENTRY: usize = 50;
+const DEFAULT_MAX_ENTRIES_PER_PAGE: i64 = 200;
 
 #[derive(Debug, Clone, serde::Deserialize)]
 #[serde(default)]
@@ -10,6 +11,7 @@ pub struct EntryConfig {
     pub max_photos: usize,
     pub max_voice_memos: usize,
     pub max_activities_per_entry: usize,
+    pub max_entries_per_page: i64,
 }
 
 impl Default for EntryConfig {
@@ -19,6 +21,7 @@ impl Default for EntryConfig {
             max_photos: DEFAULT_MAX_PHOTOS,
             max_voice_memos: DEFAULT_MAX_VOICE_MEMOS,
             max_activities_per_entry: DEFAULT_MAX_ACTIVITIES_PER_ENTRY,
+            max_entries_per_page: DEFAULT_MAX_ENTRIES_PER_PAGE,
         }
     }
 }
diff --git a/crates/config/src/lib.rs b/crates/config/src/lib.rs
index 03c3974..b3e198c 100644
--- a/crates/config/src/lib.rs
+++ b/crates/config/src/lib.rs
@@ -8,6 +8,7 @@ mod loader;
 mod preset;
 mod provider_config;
 mod push_config;
+mod rate_limit_config;
 mod server_config;
 mod storage_config;
 mod worker_config;
@@ -22,6 +23,7 @@ pub use loader::load;
 pub use preset::{PresetActivity, PresetConfig};
 pub use provider_config::ProviderConfig;
 pub use push_config::PushConfig;
+pub use rate_limit_config::RateLimitConfig;
 pub use server_config::{CorsConfig, ServerConfig};
 pub use storage_config::{MediaBackend, StorageConfig};
 pub use worker_config::WorkerConfig;
diff --git a/crates/config/src/rate_limit_config.rs b/crates/config/src/rate_limit_config.rs
new file mode 100644
index 0000000..3121429
--- /dev/null
+++ b/crates/config/src/rate_limit_config.rs
@@ -0,0 +1,24 @@
+const DEFAULT_ENABLED: bool = true;
+const DEFAULT_REQUESTS_PER_SECOND: u64 = 20;
+const DEFAULT_BURST: u32 = 60;
+const DEFAULT_TRUST_FORWARDED_FOR: bool = false;
+
+#[derive(Debug, Clone, serde::Deserialize)]
+#[serde(default)]
+pub struct RateLimitConfig {
+    pub enabled: bool,
+    pub requests_per_second: u64,
+    pub burst: u32,
+    pub trust_forwarded_for: bool,
+}
+
+impl Default for RateLimitConfig {
+    fn default() -> Self {
+        Self {
+            enabled: DEFAULT_ENABLED,
+            requests_per_second: DEFAULT_REQUESTS_PER_SECOND,
+            burst: DEFAULT_BURST,
+            trust_forwarded_for: DEFAULT_TRUST_FORWARDED_FOR,
+        }
+    }
+}
diff --git a/crates/config/src/server_config.rs b/crates/config/src/server_config.rs
index 71a3773..f415fc6 100644
--- a/crates/config/src/server_config.rs
+++ b/crates/config/src/server_config.rs
@@ -1,3 +1,5 @@
+use super::rate_limit_config::RateLimitConfig;
+
 const DEFAULT_HOST: &str = "0.0.0.0";
 const DEFAULT_PORT: u16 = 3000;
 const DEFAULT_MAX_BODY_SIZE: usize = 10 * 1024 * 1024;
@@ -11,6 +13,7 @@ pub struct ServerConfig {
     pub max_body_size: usize,
     pub spa_dir: String,
     pub cors: CorsConfig,
+    pub rate_limit: RateLimitConfig,
 }
 
 impl Default for ServerConfig {
@@ -21,6 +24,7 @@ impl Default for ServerConfig {
             max_body_size: DEFAULT_MAX_BODY_SIZE,
             spa_dir: DEFAULT_SPA_DIR.into(),
             cors: CorsConfig::default(),
+            rate_limit: RateLimitConfig::default(),
         }
     }
 }
diff --git a/crates/config/src/worker_config.rs b/crates/config/src/worker_config.rs
index 88c0d56..1bae632 100644
--- a/crates/config/src/worker_config.rs
+++ b/crates/config/src/worker_config.rs
@@ -2,6 +2,7 @@ const DEFAULT_POLL_SECONDS: u64 = 15;
 const DEFAULT_SWEEP_SECONDS: u64 = 900;
 const DEFAULT_SESSION_CLEANUP_SECONDS: u64 = 3600;
 const DEFAULT_REMINDER_SECONDS: u64 = 60;
+const DEFAULT_REMINDER_GRACE_MINUTES: i64 = 30;
 const DEFAULT_JOBS_PER_POLL: usize = 20;
 const DEFAULT_ENQUEUED_PER_SWEEP: usize = 200;
 const DEFAULT_MOST_ATTEMPTS: u32 = 5;
@@ -15,6 +16,7 @@ pub struct WorkerConfig {
     pub sweep_seconds: u64,
     pub session_cleanup_seconds: u64,
     pub reminder_seconds: u64,
+    pub reminder_grace_minutes: i64,
     pub jobs_per_poll: usize,
     pub enqueued_per_sweep: usize,
     pub most_attempts: u32,
@@ -29,6 +31,7 @@ impl Default for WorkerConfig {
             sweep_seconds: DEFAULT_SWEEP_SECONDS,
             session_cleanup_seconds: DEFAULT_SESSION_CLEANUP_SECONDS,
             reminder_seconds: DEFAULT_REMINDER_SECONDS,
+            reminder_grace_minutes: DEFAULT_REMINDER_GRACE_MINUTES,
             jobs_per_poll: DEFAULT_JOBS_PER_POLL,
             enqueued_per_sweep: DEFAULT_ENQUEUED_PER_SWEEP,
             most_attempts: DEFAULT_MOST_ATTEMPTS,
diff --git a/crates/domain/src/api_token/api_token.rs b/crates/domain/src/api_token/api_token.rs
index ae3d468..0d36dea 100644
--- a/crates/domain/src/api_token/api_token.rs
+++ b/crates/domain/src/api_token/api_token.rs
@@ -3,14 +3,14 @@ use chrono::{DateTime, Utc};
 use crate::provider::ProviderName;
 use crate::user::UserId;
 
-use super::{ApiTokenId, TokenDigest, TokenScope};
+use super::{ApiTokenId, TokenDigest, TokenScope, TokenScopes};
 
 pub struct ApiTokenData {
     pub id: ApiTokenId,
     pub user_id: UserId,
     pub name: ProviderName,
     pub digest: TokenDigest,
-    pub scope: TokenScope,
+    pub scopes: TokenScopes,
     pub created_at: DateTime<Utc>,
     pub last_used_at: Option<DateTime<Utc>>,
 }
@@ -21,19 +21,24 @@ pub struct ApiToken {
     user_id: UserId,
     name: ProviderName,
     digest: TokenDigest,
-    scope: TokenScope,
+    scopes: TokenScopes,
     created_at: DateTime<Utc>,
     last_used_at: Option<DateTime<Utc>>,
 }
 
 impl ApiToken {
-    pub fn new(user_id: UserId, name: ProviderName, digest: TokenDigest) -> Self {
+    pub fn new(
+        user_id: UserId,
+        name: ProviderName,
+        digest: TokenDigest,
+        scopes: TokenScopes,
+    ) -> Self {
         Self {
             id: ApiTokenId::generate(),
             user_id,
             name,
             digest,
-            scope: TokenScope::WriteMetrics,
+            scopes,
             created_at: Utc::now(),
             last_used_at: None,
         }
@@ -45,7 +50,7 @@ impl ApiToken {
             user_id: data.user_id,
             name: data.name,
             digest: data.digest,
-            scope: data.scope,
+            scopes: data.scopes,
             created_at: data.created_at,
             last_used_at: data.last_used_at,
         }
@@ -69,8 +74,12 @@ impl ApiToken {
         &self.digest
     }
 
-    pub fn scope(&self) -> TokenScope {
-        self.scope
+    pub fn scopes(&self) -> &TokenScopes {
+        &self.scopes
+    }
+
+    pub fn allows(&self, scope: TokenScope) -> bool {
+        self.scopes.allows(scope)
     }
 
     pub fn created_at(&self) -> &DateTime<Utc> {
diff --git a/crates/domain/src/api_token/mod.rs b/crates/domain/src/api_token/mod.rs
index be4d074..b362db8 100644
--- a/crates/domain/src/api_token/mod.rs
+++ b/crates/domain/src/api_token/mod.rs
@@ -3,9 +3,11 @@ mod api_token_id;
 mod minted_api_token;
 mod token_digest;
 mod token_scope;
+mod token_scopes;
 
 pub use api_token::{ApiToken, ApiTokenData};
 pub use api_token_id::ApiTokenId;
 pub use minted_api_token::MintedApiToken;
 pub use token_digest::TokenDigest;
 pub use token_scope::TokenScope;
+pub use token_scopes::TokenScopes;
diff --git a/crates/domain/src/api_token/token_scope.rs b/crates/domain/src/api_token/token_scope.rs
index 6969510..e4a2da3 100644
--- a/crates/domain/src/api_token/token_scope.rs
+++ b/crates/domain/src/api_token/token_scope.rs
@@ -1,21 +1,59 @@
+const READ_JOURNAL: &str = "readJournal";
+const WRITE_JOURNAL: &str = "writeJournal";
 const WRITE_METRICS: &str = "writeMetrics";
+const READ_PROFILE: &str = "readProfile";
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum TokenScope {
+    ReadJournal,
+    WriteJournal,
     WriteMetrics,
+    ReadProfile,
 }
 
 impl TokenScope {
+    pub const ALL: [TokenScope; 4] = [
+        Self::ReadJournal,
+        Self::WriteJournal,
+        Self::WriteMetrics,
+        Self::ReadProfile,
+    ];
+
     pub fn name(&self) -> &'static str {
         match self {
+            Self::ReadJournal => READ_JOURNAL,
+            Self::WriteJournal => WRITE_JOURNAL,
             Self::WriteMetrics => WRITE_METRICS,
+            Self::ReadProfile => READ_PROFILE,
+        }
+    }
+
+    pub fn describes(&self) -> &'static str {
+        match self {
+            Self::ReadJournal => {
+                "read entries, activities, the calendar, statistics, correlations, cycle records and daily metrics"
+            }
+            Self::WriteJournal => {
+                "create, change and delete entries, activities, cycle records, reminders and media"
+            }
+            Self::WriteMetrics => "write daily metrics, attributed to this token's name",
+            Self::ReadProfile => "read the account profile, its preferences and its connections",
         }
     }
 
     pub fn from_name(name: &str) -> Option<Self> {
         match name {
+            READ_JOURNAL => Some(Self::ReadJournal),
+            WRITE_JOURNAL => Some(Self::WriteJournal),
             WRITE_METRICS => Some(Self::WriteMetrics),
+            READ_PROFILE => Some(Self::ReadProfile),
             _ => None,
         }
     }
 }
+
+impl std::fmt::Display for TokenScope {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.name())
+    }
+}
diff --git a/crates/domain/src/api_token/token_scopes.rs b/crates/domain/src/api_token/token_scopes.rs
new file mode 100644
index 0000000..ec701fa
--- /dev/null
+++ b/crates/domain/src/api_token/token_scopes.rs
@@ -0,0 +1,62 @@
+use std::collections::BTreeSet;
+
+use crate::errors::DomainError;
+
+use super::TokenScope;
+
+const SEPARATOR: char = ' ';
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TokenScopes(BTreeSet<TokenScope>);
+
+impl TokenScopes {
+    pub fn new(wanted: impl IntoIterator<Item = TokenScope>) -> Result<Self, DomainError> {
+        let held: BTreeSet<TokenScope> = wanted.into_iter().collect();
+
+        if held.is_empty() {
+            return Err(DomainError::InvalidInput(
+                "a token that grants nothing is not worth minting: name at least one scope".into(),
+            ));
+        }
+
+        Ok(Self(held))
+    }
+
+    pub fn from_names<'a>(names: impl IntoIterator<Item = &'a str>) -> Result<Self, DomainError> {
+        let mut wanted = BTreeSet::new();
+
+        for name in names {
+            let scope = TokenScope::from_name(name).ok_or_else(|| {
+                DomainError::InvalidInput(format!("{name} is not a scope this server grants"))
+            })?;
+
+            wanted.insert(scope);
+        }
+
+        Self::new(wanted)
+    }
+
+    pub fn from_persistence(stored: &str) -> Option<Self> {
+        let names: Vec<&str> = stored.split(SEPARATOR).filter(|s| !s.is_empty()).collect();
+
+        Self::from_names(names).ok()
+    }
+
+    pub fn allows(&self, scope: TokenScope) -> bool {
+        self.0.contains(&scope)
+    }
+
+    pub fn names(&self) -> Vec<&'static str> {
+        self.0.iter().map(TokenScope::name).collect()
+    }
+
+    pub fn to_persistence(&self) -> String {
+        self.names().join(&SEPARATOR.to_string())
+    }
+}
+
+impl std::fmt::Display for TokenScopes {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.to_persistence())
+    }
+}
diff --git a/crates/domain/src/attachment/media_ref.rs b/crates/domain/src/attachment/media_ref.rs
new file mode 100644
index 0000000..c7d313b
--- /dev/null
+++ b/crates/domain/src/attachment/media_ref.rs
@@ -0,0 +1,78 @@
+use super::{PhotoId, VoiceMemoId};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum MediaKind {
+    Photo,
+    VoiceMemo,
+}
+
+impl MediaKind {
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::Photo => "photo",
+            Self::VoiceMemo => "voice_memo",
+        }
+    }
+
+    pub fn from_name(name: &str) -> Option<Self> {
+        match name {
+            "photo" => Some(Self::Photo),
+            "voice_memo" => Some(Self::VoiceMemo),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct MediaRef {
+    kind: MediaKind,
+    id: uuid::Uuid,
+}
+
+impl MediaRef {
+    pub fn to_photo(&self) -> Option<PhotoId> {
+        match self.kind {
+            MediaKind::Photo => Some(PhotoId::from_uuid(self.id)),
+            MediaKind::VoiceMemo => None,
+        }
+    }
+
+    pub fn to_voice_memo(&self) -> Option<VoiceMemoId> {
+        match self.kind {
+            MediaKind::VoiceMemo => Some(VoiceMemoId::from_uuid(self.id)),
+            MediaKind::Photo => None,
+        }
+    }
+
+    pub fn kind(&self) -> MediaKind {
+        self.kind
+    }
+
+    pub fn id(&self) -> uuid::Uuid {
+        self.id
+    }
+}
+
+impl From<&PhotoId> for MediaRef {
+    fn from(id: &PhotoId) -> Self {
+        Self {
+            kind: MediaKind::Photo,
+            id: id.value(),
+        }
+    }
+}
+
+impl From<&VoiceMemoId> for MediaRef {
+    fn from(id: &VoiceMemoId) -> Self {
+        Self {
+            kind: MediaKind::VoiceMemo,
+            id: id.value(),
+        }
+    }
+}
+
+impl std::fmt::Display for MediaRef {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{} {}", self.kind.name(), self.id)
+    }
+}
diff --git a/crates/domain/src/attachment/mod.rs b/crates/domain/src/attachment/mod.rs
index 82a7664..995392f 100644
--- a/crates/domain/src/attachment/mod.rs
+++ b/crates/domain/src/attachment/mod.rs
@@ -1,9 +1,11 @@
 mod content_type;
+mod media_ref;
 mod media_upload;
 mod photo_id;
 mod voice_memo_id;
 
 pub use content_type::ContentType;
+pub use media_ref::{MediaKind, MediaRef};
 pub use media_upload::MediaUpload;
 pub use photo_id::PhotoId;
 pub use voice_memo_id::VoiceMemoId;
diff --git a/crates/domain/src/entry/entry_selection.rs b/crates/domain/src/entry/entry_selection.rs
new file mode 100644
index 0000000..a8a20ad
--- /dev/null
+++ b/crates/domain/src/entry/entry_selection.rs
@@ -0,0 +1,69 @@
+use chrono::{DateTime, Utc};
+
+use crate::activity::ActivityId;
+use crate::user::UserId;
+
+use super::{DateRange, Mood};
+
+#[derive(Debug, Clone)]
+pub struct EntrySelection {
+    user_id: UserId,
+    logged_within: Option<DateRange>,
+    mood: Option<Mood>,
+    tagged_with: Option<ActivityId>,
+    changed_since: Option<DateTime<Utc>>,
+}
+
+impl EntrySelection {
+    pub fn everything_of(user_id: UserId) -> Self {
+        Self {
+            user_id,
+            logged_within: None,
+            mood: None,
+            tagged_with: None,
+            changed_since: None,
+        }
+    }
+
+    pub fn logged_within(mut self, range: Option<DateRange>) -> Self {
+        self.logged_within = range;
+        self
+    }
+
+    pub fn of_mood(mut self, mood: Option<Mood>) -> Self {
+        self.mood = mood;
+        self
+    }
+
+    pub fn tagged_with(mut self, activity_id: Option<ActivityId>) -> Self {
+        self.tagged_with = activity_id;
+        self
+    }
+
+    pub fn changed_since(mut self, instant: Option<DateTime<Utc>>) -> Self {
+        self.changed_since = instant;
+        self
+    }
+}
+
+impl EntrySelection {
+    pub fn user_id(&self) -> &UserId {
+        &self.user_id
+    }
+
+    pub fn range(&self) -> Option<&DateRange> {
+        self.logged_within.as_ref()
+    }
+
+    pub fn mood(&self) -> Option<Mood> {
+        self.mood
+    }
+
+    pub fn activity(&self) -> Option<&ActivityId> {
+        self.tagged_with.as_ref()
+    }
+
+    pub fn since(&self) -> Option<DateTime<Utc>> {
+        self.changed_since
+    }
+}
diff --git a/crates/domain/src/entry/mod.rs b/crates/domain/src/entry/mod.rs
index 21ee0e8..b2963eb 100644
--- a/crates/domain/src/entry/mod.rs
+++ b/crates/domain/src/entry/mod.rs
@@ -3,15 +3,19 @@ mod date;
 mod date_range;
 mod date_span;
 mod day_mood;
+mod entry_selection;
 mod mood;
 mod mood_entry;
 mod mood_entry_id;
+mod pagination;
 
 pub use content::Content;
 pub use date::Date;
 pub use date_range::DateRange;
 pub use date_span::DateSpan;
 pub use day_mood::DayMood;
+pub use entry_selection::EntrySelection;
 pub use mood::Mood;
 pub use mood_entry::{MoodEntry, MoodEntryData};
 pub use mood_entry_id::MoodEntryId;
+pub use pagination::{Page, Pagination};
diff --git a/crates/domain/src/entry/mood.rs b/crates/domain/src/entry/mood.rs
index 5577143..3ab82e5 100644
--- a/crates/domain/src/entry/mood.rs
+++ b/crates/domain/src/entry/mood.rs
@@ -11,10 +11,28 @@ pub enum Mood {
     Rad = 5,
 }
 
+const AWFUL: &str = "Awful";
+const BAD: &str = "Bad";
+const MEH: &str = "Meh";
+const GOOD: &str = "Good";
+const RAD: &str = "Rad";
+
 impl Mood {
+    pub const ALL: [Mood; 5] = [Self::Awful, Self::Bad, Self::Meh, Self::Good, Self::Rad];
+
     pub fn value(&self) -> u8 {
         *self as u8
     }
+
+    pub fn label(&self) -> &'static str {
+        match self {
+            Self::Awful => AWFUL,
+            Self::Bad => BAD,
+            Self::Meh => MEH,
+            Self::Good => GOOD,
+            Self::Rad => RAD,
+        }
+    }
 }
 
 impl TryFrom<u8> for Mood {
diff --git a/crates/domain/src/entry/pagination.rs b/crates/domain/src/entry/pagination.rs
new file mode 100644
index 0000000..2e70a93
--- /dev/null
+++ b/crates/domain/src/entry/pagination.rs
@@ -0,0 +1,86 @@
+use crate::errors::DomainError;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Pagination {
+    limit: i64,
+    offset: i64,
+}
+
+impl Pagination {
+    pub fn new(limit: i64, offset: i64, most_per_page: i64) -> Result<Self, DomainError> {
+        if limit < 1 {
+            return Err(DomainError::InvalidInput(
+                "a page of nothing is not a page: ask for at least one".into(),
+            ));
+        }
+
+        if limit > most_per_page {
+            return Err(DomainError::InvalidInput(format!(
+                "this server serves at most {most_per_page} entries per page, and {limit} were asked for"
+            )));
+        }
+
+        if offset < 0 {
+            return Err(DomainError::InvalidInput(
+                "a page cannot start before the beginning".into(),
+            ));
+        }
+
+        Ok(Self { limit, offset })
+    }
+
+    pub fn limit(&self) -> i64 {
+        self.limit
+    }
+
+    pub fn offset(&self) -> i64 {
+        self.offset
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Page<T> {
+    items: Vec<T>,
+    total: u64,
+    at: Pagination,
+}
+
+impl<T> Page<T> {
+    pub fn new(items: Vec<T>, total: u64, at: Pagination) -> Self {
+        Self { items, total, at }
+    }
+
+    pub fn items(&self) -> &[T] {
+        &self.items
+    }
+
+    pub fn into_items(self) -> Vec<T> {
+        self.items
+    }
+
+    pub fn total(&self) -> u64 {
+        self.total
+    }
+
+    pub fn limit(&self) -> i64 {
+        self.at.limit()
+    }
+
+    pub fn offset(&self) -> i64 {
+        self.at.offset()
+    }
+
+    pub fn more_after_this(&self) -> bool {
+        let seen = self.at.offset().saturating_add(self.items.len() as i64);
+
+        (seen as u64) < self.total
+    }
+
+    pub fn map<U>(self, transform: impl FnMut(T) -> U) -> Page<U> {
+        Page {
+            items: self.items.into_iter().map(transform).collect(),
+            total: self.total,
+            at: self.at,
+        }
+    }
+}
diff --git a/crates/domain/src/macros.rs b/crates/domain/src/macros.rs
index ee7028d..073782c 100644
--- a/crates/domain/src/macros.rs
+++ b/crates/domain/src/macros.rs
@@ -48,11 +48,16 @@ macro_rules! bounded_metric {
         pub struct $name($inner);
 
         impl $name {
+            pub const MINIMUM: $inner = $min;
+            pub const MAXIMUM: $inner = $max;
+
             pub fn new(value: $inner) -> Result<Self, crate::errors::DomainError> {
-                if !($min..=$max).contains(&value) {
+                if !(Self::MINIMUM..=Self::MAXIMUM).contains(&value) {
                     return Err(crate::errors::DomainError::InvalidInput(format!(
                         concat!($label, " must be between {} and {}, got {}"),
-                        $min, $max, value
+                        Self::MINIMUM,
+                        Self::MAXIMUM,
+                        value
                     )));
                 }
 
diff --git a/crates/domain/src/metric/metric_kind.rs b/crates/domain/src/metric/metric_kind.rs
index 2dec488..aa05ffd 100644
--- a/crates/domain/src/metric/metric_kind.rs
+++ b/crates/domain/src/metric/metric_kind.rs
@@ -7,6 +7,12 @@ const EXERCISE_MINUTES: &str = "exerciseMinutes";
 const SCREEN_TIME_MINUTES: &str = "screenTimeMinutes";
 const ALCOHOLIC_DRINKS: &str = "alcoholicDrinks";
 
+const STEPS_UNIT: &str = "steps";
+const MINUTES_UNIT: &str = "minutes";
+const BEATS_PER_MINUTE_UNIT: &str = "bpm";
+const MILLISECONDS_UNIT: &str = "milliseconds";
+const DRINKS_UNIT: &str = "drinks";
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum MetricKind {
     Steps,
@@ -44,6 +50,47 @@ impl MetricKind {
         }
     }
 
+    pub fn unit(&self) -> &'static str {
+        match self {
+            Self::Steps => STEPS_UNIT,
+            Self::SleepMinutes | Self::AwakeMinutes => MINUTES_UNIT,
+            Self::RestingHeartRate => BEATS_PER_MINUTE_UNIT,
+            Self::Hrv => MILLISECONDS_UNIT,
+            Self::ExerciseMinutes | Self::ScreenTimeMinutes => MINUTES_UNIT,
+            Self::AlcoholicDrinks => DRINKS_UNIT,
+        }
+    }
+
+    pub fn bounds(&self) -> (i64, i64) {
+        use crate::metric::{
+            AlcoholicDrinks, AwakeMinutes, ExerciseMinutes, Hrv, RestingHeartRate,
+            ScreenTimeMinutes, SleepMinutes, Steps,
+        };
+
+        match self {
+            Self::Steps => (Steps::MINIMUM.into(), Steps::MAXIMUM.into()),
+            Self::SleepMinutes => (SleepMinutes::MINIMUM.into(), SleepMinutes::MAXIMUM.into()),
+            Self::AwakeMinutes => (AwakeMinutes::MINIMUM.into(), AwakeMinutes::MAXIMUM.into()),
+            Self::RestingHeartRate => (
+                RestingHeartRate::MINIMUM.into(),
+                RestingHeartRate::MAXIMUM.into(),
+            ),
+            Self::Hrv => (Hrv::MINIMUM.into(), Hrv::MAXIMUM.into()),
+            Self::ExerciseMinutes => (
+                ExerciseMinutes::MINIMUM.into(),
+                ExerciseMinutes::MAXIMUM.into(),
+            ),
+            Self::ScreenTimeMinutes => (
+                ScreenTimeMinutes::MINIMUM.into(),
+                ScreenTimeMinutes::MAXIMUM.into(),
+            ),
+            Self::AlcoholicDrinks => (
+                AlcoholicDrinks::MINIMUM.into(),
+                AlcoholicDrinks::MAXIMUM.into(),
+            ),
+        }
+    }
+
     pub fn from_name(name: &str) -> Option<Self> {
         match name {
             STEPS => Some(Self::Steps),
diff --git a/crates/domain/src/ports/entry.rs b/crates/domain/src/ports/entry.rs
index a66a048..bf462db 100644
--- a/crates/domain/src/ports/entry.rs
+++ b/crates/domain/src/ports/entry.rs
@@ -1,5 +1,5 @@
 use crate::activity::ActivityId;
-use crate::entry::{DateRange, Mood, MoodEntry, MoodEntryId};
+use crate::entry::{DateRange, EntrySelection, MoodEntry, MoodEntryId, Pagination};
 use crate::errors::DomainError;
 use crate::user::UserId;
 
@@ -27,28 +27,21 @@ pub trait MoodEntryCommandPort: Send + Sync {
 #[async_trait::async_trait]
 pub trait MoodEntryQueryPort: Send + Sync {
     async fn find_by_id(&self, id: &MoodEntryId) -> Result<Option<MoodEntry>, DomainError>;
-    async fn find_by_user(
+    async fn find_all_by_user(&self, user_id: &UserId) -> Result<Vec<MoodEntry>, DomainError>;
+
+    async fn select(
         &self,
-        user_id: &UserId,
-        limit: Option<i64>,
-        offset: Option<i64>,
+        selection: &EntrySelection,
+        page: Pagination,
     ) -> Result<Vec<MoodEntry>, DomainError>;
 
+    async fn count(&self, selection: &EntrySelection) -> Result<u64, DomainError>;
+
     async fn find_by_date_range(
         &self,
         user_id: &UserId,
         range: &DateRange,
     ) -> Result<Vec<MoodEntry>, DomainError>;
 
-    async fn find_by_mood(
-        &self,
-        user_id: &UserId,
-        mood: Mood,
-    ) -> Result<Vec<MoodEntry>, DomainError>;
-
-    async fn find_by_activity(
-        &self,
-        user_id: &UserId,
-        activity_id: &ActivityId,
-    ) -> Result<Vec<MoodEntry>, DomainError>;
+    async fn count_tagged_with(&self, activity_id: &ActivityId) -> Result<u64, DomainError>;
 }
diff --git a/crates/domain/src/ports/import_export.rs b/crates/domain/src/ports/import_export.rs
index adec9c4..8943046 100644
--- a/crates/domain/src/ports/import_export.rs
+++ b/crates/domain/src/ports/import_export.rs
@@ -1,4 +1,5 @@
 use crate::activity::Activity;
+use crate::attachment::ContentType;
 use crate::cycle::CycleStartRestore;
 use crate::dimension::ComposedEntry;
 use crate::errors::DomainError;
@@ -9,6 +10,7 @@ use crate::user::UserPreferences;
 pub struct MediaBlob {
     pub id: String,
     pub data: Vec<u8>,
+    pub content_type: ContentType,
 }
 
 pub struct BackupMedia {
diff --git a/crates/domain/src/ports/job.rs b/crates/domain/src/ports/job.rs
index ed7e1b9..1dcf690 100644
--- a/crates/domain/src/ports/job.rs
+++ b/crates/domain/src/ports/job.rs
@@ -51,6 +51,11 @@ pub trait WeatherBacklogQueryPort: Send + Sync {
         &self,
         most: usize,
     ) -> Result<Vec<UnwatchedPlace>, DomainError>;
+
+    async fn find_place_without_weather(
+        &self,
+        entry_id: &crate::entry::MoodEntryId,
+    ) -> Result<Option<UnwatchedPlace>, DomainError>;
 }
 
 #[async_trait::async_trait]
@@ -60,6 +65,11 @@ pub trait RecordingBackfillQueryPort: Send + Sync {
         most: usize,
     ) -> Result<Vec<UnidentifiedSong>, DomainError>;
 
+    async fn find_song_without_a_recording(
+        &self,
+        entry_id: &crate::entry::MoodEntryId,
+    ) -> Result<Option<UnidentifiedSong>, DomainError>;
+
     async fn record_identity(
         &self,
         entry_id: &crate::entry::MoodEntryId,
diff --git a/crates/domain/src/ports/media.rs b/crates/domain/src/ports/media.rs
index 6e6f69b..f53e05b 100644
--- a/crates/domain/src/ports/media.rs
+++ b/crates/domain/src/ports/media.rs
@@ -1,5 +1,6 @@
-use crate::attachment::{ContentType, MediaUpload, PhotoId, VoiceMemoId};
+use crate::attachment::{ContentType, MediaRef, MediaUpload, PhotoId, VoiceMemoId};
 use crate::errors::DomainError;
+use crate::user::UserId;
 
 pub struct MediaFile {
     pub data: Vec<u8>,
@@ -15,3 +16,12 @@ pub trait MediaStoragePort: Send + Sync {
     async fn delete_photo(&self, id: &PhotoId) -> Result<(), DomainError>;
     async fn delete_voice_memo(&self, id: &VoiceMemoId) -> Result<(), DomainError>;
 }
+
+#[async_trait::async_trait]
+pub trait MediaOwnershipPort: Send + Sync {
+    async fn remember(&self, owner: &UserId, media: MediaRef) -> Result<(), DomainError>;
+    async fn owner_of(&self, media: MediaRef) -> Result<Option<UserId>, DomainError>;
+    async fn owned_by(&self, owner: &UserId) -> Result<Vec<MediaRef>, DomainError>;
+    async fn forget(&self, media: MediaRef) -> Result<(), DomainError>;
+    async fn forget_all_by_user(&self, owner: &UserId) -> Result<(), DomainError>;
+}
diff --git a/crates/domain/src/ports/mod.rs b/crates/domain/src/ports/mod.rs
index 2fb903b..189256f 100644
--- a/crates/domain/src/ports/mod.rs
+++ b/crates/domain/src/ports/mod.rs
@@ -39,7 +39,7 @@ pub use job::{
     JobQueueCommandPort, JobQueueQueryPort, RecordingBackfillQueryPort, UnidentifiedSong,
     UnwatchedPlace, WeatherBacklogQueryPort, WeatherLookupPort,
 };
-pub use media::{MediaFile, MediaStoragePort};
+pub use media::{MediaFile, MediaOwnershipPort, MediaStoragePort};
 pub use metric::{DailyMetricCommandPort, DailyMetricQueryPort};
 pub use music::{NowPlayingPort, RecordingLookupPort};
 pub use provider::{ProviderConnectionCommandPort, ProviderConnectionQueryPort};
@@ -47,7 +47,7 @@ pub use push::{PushSubscriptionCommandPort, PushSubscriptionQueryPort};
 pub use rejection::{RejectionCommandPort, RejectionQueryPort};
 pub use reminder::{ReminderCommandPort, ReminderQueryPort, ReminderSenderPort};
 pub use restore::{
-    BackupReaderPort, RestorableActivity, RestorableContents, RestorableEntry, RestorableMetric,
-    RestorableReminder,
+    BackupReaderPort, RestorableActivity, RestorableContents, RestorableEntry, RestorableMedia,
+    RestorableMetric, RestorableReminder,
 };
 pub use user::{UserCommandPort, UserQueryPort};
diff --git a/crates/domain/src/ports/push.rs b/crates/domain/src/ports/push.rs
index 01e1fd0..9425aad 100644
--- a/crates/domain/src/ports/push.rs
+++ b/crates/domain/src/ports/push.rs
@@ -6,7 +6,8 @@ use crate::user::UserId;
 pub trait PushSubscriptionCommandPort: Send + Sync {
     async fn save(&self, subscription: &PushSubscription) -> Result<(), DomainError>;
     async fn delete(&self, id: &PushSubscriptionId) -> Result<(), DomainError>;
-    async fn delete_by_endpoint(&self, endpoint: &str) -> Result<(), DomainError>;
+    async fn delete_by_endpoint(&self, user_id: &UserId, endpoint: &str)
+    -> Result<(), DomainError>;
     async fn delete_all_by_user(&self, user_id: &UserId) -> Result<(), DomainError>;
 }
 
diff --git a/crates/domain/src/ports/restore.rs b/crates/domain/src/ports/restore.rs
index a0ce671..72b671a 100644
--- a/crates/domain/src/ports/restore.rs
+++ b/crates/domain/src/ports/restore.rs
@@ -1,3 +1,4 @@
+use crate::attachment::ContentType;
 use crate::errors::DomainError;
 
 pub struct RestorableEntry {
@@ -32,8 +33,14 @@ pub struct RestorableContents {
     pub activities: Vec<RestorableActivity>,
     pub reminders: Vec<RestorableReminder>,
     pub tracks_cycle: bool,
-    pub photos: Vec<(String, Vec<u8>)>,
-    pub voice_memos: Vec<(String, Vec<u8>)>,
+    pub photos: Vec<RestorableMedia>,
+    pub voice_memos: Vec<RestorableMedia>,
+}
+
+pub struct RestorableMedia {
+    pub id: String,
+    pub data: Vec<u8>,
+    pub content_type: Option<ContentType>,
 }
 
 #[async_trait::async_trait]
diff --git a/crates/domain/src/push/push_subscription.rs b/crates/domain/src/push/push_subscription.rs
index e63891b..ea0cc85 100644
--- a/crates/domain/src/push/push_subscription.rs
+++ b/crates/domain/src/push/push_subscription.rs
@@ -45,6 +45,12 @@ impl PushSubscription {
         }
     }
 
+    pub fn renew(&mut self, user_id: UserId, p256dh: String, auth: String) {
+        self.user_id = user_id;
+        self.p256dh = p256dh;
+        self.auth = auth;
+    }
+
     pub fn id(&self) -> &PushSubscriptionId {
         &self.id
     }
diff --git a/crates/domain/src/reminder/due_occurrence.rs b/crates/domain/src/reminder/due_occurrence.rs
new file mode 100644
index 0000000..6d42661
--- /dev/null
+++ b/crates/domain/src/reminder/due_occurrence.rs
@@ -0,0 +1,62 @@
+use chrono::{DateTime, Datelike, Duration, NaiveDate, NaiveTime, TimeDelta, Utc};
+
+use crate::user::Timezone;
+
+use super::DaySchedule;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct DueOccurrence {
+    scheduled_for: DateTime<Utc>,
+}
+
+impl DueOccurrence {
+    pub fn scheduled_for(&self) -> DateTime<Utc> {
+        self.scheduled_for
+    }
+}
+
+pub fn occurrence_reached(
+    schedule: &DaySchedule,
+    last_sent_at: Option<DateTime<Utc>>,
+    now: DateTime<Utc>,
+    timezone: &Timezone,
+    grace: Duration,
+) -> Option<DueOccurrence> {
+    let local_today = now.with_timezone(&timezone.resolve()).date_naive();
+
+    [local_today, local_today.pred_opt()?]
+        .into_iter()
+        .filter_map(|local_date| scheduled_instant(schedule, local_date, timezone))
+        .filter(|scheduled| reached_but_not_stale(*scheduled, now, grace))
+        .filter(|scheduled| not_already_sent(*scheduled, last_sent_at))
+        .max()
+        .map(|scheduled_for| DueOccurrence { scheduled_for })
+}
+
+fn scheduled_instant(
+    schedule: &DaySchedule,
+    local_date: NaiveDate,
+    timezone: &Timezone,
+) -> Option<DateTime<Utc>> {
+    let time = schedule.time_for(local_date.weekday())?;
+
+    placed_in(local_date, time, timezone)
+}
+
+fn placed_in(local_date: NaiveDate, time: NaiveTime, timezone: &Timezone) -> Option<DateTime<Utc>> {
+    local_date
+        .and_time(time)
+        .and_local_timezone(timezone.resolve())
+        .earliest()
+        .map(|placed| placed.with_timezone(&Utc))
+}
+
+fn reached_but_not_stale(scheduled: DateTime<Utc>, now: DateTime<Utc>, grace: Duration) -> bool {
+    let since = now.signed_duration_since(scheduled);
+
+    since >= TimeDelta::zero() && since < grace
+}
+
+fn not_already_sent(scheduled: DateTime<Utc>, last_sent_at: Option<DateTime<Utc>>) -> bool {
+    last_sent_at.is_none_or(|sent| sent < scheduled)
+}
diff --git a/crates/domain/src/reminder/mod.rs b/crates/domain/src/reminder/mod.rs
index 1a16fc6..14bbf12 100644
--- a/crates/domain/src/reminder/mod.rs
+++ b/crates/domain/src/reminder/mod.rs
@@ -1,7 +1,9 @@
 mod day_schedule;
+mod due_occurrence;
 mod reminder;
 mod reminder_id;
 
 pub use day_schedule::DaySchedule;
+pub use due_occurrence::DueOccurrence;
 pub use reminder::Reminder;
 pub use reminder_id::ReminderId;
diff --git a/crates/domain/src/reminder/reminder.rs b/crates/domain/src/reminder/reminder.rs
index f0eaee5..a0b5d12 100644
--- a/crates/domain/src/reminder/reminder.rs
+++ b/crates/domain/src/reminder/reminder.rs
@@ -1,7 +1,8 @@
-use chrono::{DateTime, Utc};
+use chrono::{DateTime, Duration, Utc};
 
-use crate::user::UserId;
+use crate::user::{Timezone, UserId};
 
+use super::due_occurrence::{DueOccurrence, occurrence_reached};
 use super::{DaySchedule, ReminderId};
 
 #[derive(Debug, Clone)]
@@ -11,6 +12,7 @@ pub struct Reminder {
     schedule: DaySchedule,
     enabled: bool,
     created_at: DateTime<Utc>,
+    last_sent_at: Option<DateTime<Utc>>,
 }
 
 impl Reminder {
@@ -21,6 +23,7 @@ impl Reminder {
             schedule,
             enabled: true,
             created_at: Utc::now(),
+            last_sent_at: None,
         }
     }
 
@@ -30,6 +33,7 @@ impl Reminder {
         schedule: DaySchedule,
         enabled: bool,
         created_at: DateTime<Utc>,
+        last_sent_at: Option<DateTime<Utc>>,
     ) -> Self {
         Self {
             id,
@@ -37,6 +41,7 @@ impl Reminder {
             schedule,
             enabled,
             created_at,
+            last_sent_at,
         }
     }
 }
@@ -61,6 +66,23 @@ impl Reminder {
     pub fn created_at(&self) -> &DateTime<Utc> {
         &self.created_at
     }
+
+    pub fn last_sent_at(&self) -> Option<DateTime<Utc>> {
+        self.last_sent_at
+    }
+
+    pub fn occurrence_reached(
+        &self,
+        now: DateTime<Utc>,
+        timezone: &Timezone,
+        grace: Duration,
+    ) -> Option<DueOccurrence> {
+        if !self.enabled {
+            return None;
+        }
+
+        occurrence_reached(&self.schedule, self.last_sent_at, now, timezone, grace)
+    }
 }
 
 impl Reminder {
@@ -75,4 +97,8 @@ impl Reminder {
     pub fn disable(&mut self) {
         self.enabled = false;
     }
+
+    pub fn mark_sent(&mut self, occurrence: DueOccurrence) {
+        self.last_sent_at = Some(occurrence.scheduled_for());
+    }
 }
diff --git a/crates/domain/src/testing/fakes/activity_dimension.rs b/crates/domain/src/testing/fakes/activity_dimension.rs
new file mode 100644
index 0000000..4f2727a
--- /dev/null
+++ b/crates/domain/src/testing/fakes/activity_dimension.rs
@@ -0,0 +1,54 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::dimension::{DimensionKind, DimensionValue, lookup};
+use crate::entry::MoodEntryId;
+use crate::errors::DomainError;
+
+use super::store::InMemoryStore;
+
+pub struct InMemoryActivityDimension {
+    store: Arc<InMemoryStore>,
+}
+
+impl InMemoryActivityDimension {
+    pub fn sharing(store: Arc<InMemoryStore>) -> Self {
+        Self { store }
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::EntryDimensionPort for InMemoryActivityDimension {
+    async fn load(
+        &self,
+        entry_ids: &[MoodEntryId],
+    ) -> Result<HashMap<MoodEntryId, DimensionValue>, DomainError> {
+        let tagged = self.store.entry_activities.read().unwrap();
+
+        Ok(entry_ids
+            .iter()
+            .filter_map(|id| tagged.get(id).map(|ids| (id.clone(), ids.clone())))
+            .filter(|(_, ids)| !ids.is_empty())
+            .map(|(id, ids)| (id, DimensionValue::activities(ids)))
+            .collect())
+    }
+
+    async fn save(
+        &self,
+        entry_id: &MoodEntryId,
+        values: &[DimensionValue],
+    ) -> Result<(), DomainError> {
+        let mut tagged = self.store.entry_activities.write().unwrap();
+
+        let names_activities = values
+            .iter()
+            .any(|value| value.kind() == DimensionKind::Activities);
+
+        match names_activities {
+            true => tagged.insert(entry_id.clone(), lookup::activities_in(values).to_vec()),
+            false => tagged.remove(entry_id),
+        };
+
+        Ok(())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/media_storage.rs b/crates/domain/src/testing/fakes/media_storage.rs
index 15bc607..b9e6145 100644
--- a/crates/domain/src/testing/fakes/media_storage.rs
+++ b/crates/domain/src/testing/fakes/media_storage.rs
@@ -5,9 +5,11 @@ use crate::attachment::{ContentType, MediaUpload, PhotoId, VoiceMemoId};
 use crate::errors::DomainError;
 use crate::ports::MediaFile;
 
+type Blob = (Vec<u8>, ContentType);
+
 pub struct FakeMediaStorage {
-    photos: RwLock<HashMap<PhotoId, Vec<u8>>>,
-    voice_memos: RwLock<HashMap<VoiceMemoId, Vec<u8>>>,
+    photos: RwLock<HashMap<PhotoId, Blob>>,
+    voice_memos: RwLock<HashMap<VoiceMemoId, Blob>>,
     deletions_attempted: RwLock<Vec<String>>,
     refusing_to_delete: bool,
 }
@@ -30,17 +32,49 @@ impl FakeMediaStorage {
     }
 
     pub fn put_photo(&self, id: &PhotoId, bytes: &[u8]) {
+        self.put_photo_as(
+            id,
+            bytes,
+            ContentType::from_persistence("image/jpeg".into()),
+        );
+    }
+
+    pub fn put_photo_as(&self, id: &PhotoId, bytes: &[u8], content_type: ContentType) {
         self.photos
             .write()
             .unwrap()
-            .insert(id.clone(), bytes.to_vec());
+            .insert(id.clone(), (bytes.to_vec(), content_type));
     }
 
     pub fn put_voice_memo(&self, id: &VoiceMemoId, bytes: &[u8]) {
+        self.put_voice_memo_as(
+            id,
+            bytes,
+            ContentType::from_persistence("audio/webm".into()),
+        );
+    }
+
+    pub fn put_voice_memo_as(&self, id: &VoiceMemoId, bytes: &[u8], content_type: ContentType) {
         self.voice_memos
             .write()
             .unwrap()
-            .insert(id.clone(), bytes.to_vec());
+            .insert(id.clone(), (bytes.to_vec(), content_type));
+    }
+
+    pub fn type_of_photo(&self, id: &PhotoId) -> Option<ContentType> {
+        self.photos
+            .read()
+            .unwrap()
+            .get(id)
+            .map(|(_, content_type)| content_type.clone())
+    }
+
+    pub fn type_of_voice_memo(&self, id: &VoiceMemoId) -> Option<ContentType> {
+        self.voice_memos
+            .read()
+            .unwrap()
+            .get(id)
+            .map(|(_, content_type)| content_type.clone())
     }
 
     pub fn holds_photo(&self, id: &PhotoId) -> bool {
@@ -70,23 +104,28 @@ impl Default for FakeMediaStorage {
 impl crate::ports::MediaStoragePort for FakeMediaStorage {
     async fn store_photo(&self, upload: MediaUpload) -> Result<PhotoId, DomainError> {
         let id = PhotoId::generate();
-        self.put_photo(&id, upload.data());
+        self.put_photo_as(&id, upload.data(), upload.content_type().clone());
 
         Ok(id)
     }
 
     async fn store_voice_memo(&self, upload: MediaUpload) -> Result<VoiceMemoId, DomainError> {
         let id = VoiceMemoId::generate();
-        self.put_voice_memo(&id, upload.data());
+        self.put_voice_memo_as(&id, upload.data(), upload.content_type().clone());
 
         Ok(id)
     }
 
     async fn get_photo(&self, id: &PhotoId) -> Result<Option<MediaFile>, DomainError> {
-        Ok(self.photos.read().unwrap().get(id).map(|bytes| MediaFile {
-            data: bytes.clone(),
-            content_type: ContentType::from_persistence("image/jpeg".into()),
-        }))
+        Ok(self
+            .photos
+            .read()
+            .unwrap()
+            .get(id)
+            .map(|(data, content_type)| MediaFile {
+                data: data.clone(),
+                content_type: content_type.clone(),
+            }))
     }
 
     async fn get_voice_memo(&self, id: &VoiceMemoId) -> Result<Option<MediaFile>, DomainError> {
@@ -95,9 +134,9 @@ impl crate::ports::MediaStoragePort for FakeMediaStorage {
             .read()
             .unwrap()
             .get(id)
-            .map(|bytes| MediaFile {
-                data: bytes.clone(),
-                content_type: ContentType::from_persistence("audio/webm".into()),
+            .map(|(data, content_type)| MediaFile {
+                data: data.clone(),
+                content_type: content_type.clone(),
             }))
     }
 
diff --git a/crates/domain/src/testing/fakes/mod.rs b/crates/domain/src/testing/fakes/mod.rs
index 01b8a10..ef49a3a 100644
--- a/crates/domain/src/testing/fakes/mod.rs
+++ b/crates/domain/src/testing/fakes/mod.rs
@@ -1,3 +1,4 @@
+mod activity_dimension;
 mod api_token_secret;
 mod cipher;
 mod dimension_store;
@@ -13,6 +14,7 @@ mod store_cycle;
 mod store_entry;
 mod store_infra;
 mod store_job;
+mod store_media;
 mod store_metric;
 mod store_provider;
 mod store_rejection;
@@ -20,6 +22,7 @@ mod store_reminder;
 mod store_user;
 mod weather;
 
+pub use activity_dimension::InMemoryActivityDimension;
 pub use api_token_secret::FakeApiTokenSecret;
 pub use cipher::FakeCredentialCipher;
 pub use dimension_store::InMemoryDimensionStore;
diff --git a/crates/domain/src/testing/fakes/store.rs b/crates/domain/src/testing/fakes/store.rs
index 590e92c..d713c84 100644
--- a/crates/domain/src/testing/fakes/store.rs
+++ b/crates/domain/src/testing/fakes/store.rs
@@ -45,6 +45,7 @@ pub struct InMemoryStore {
     pub(super) dependent_dimensions: RwLock<Vec<std::sync::Arc<InMemoryDimensionStore>>>,
     pub(super) events: RwLock<Vec<EventEnvelope>>,
     pub(super) sent_reminders: RwLock<Vec<UserId>>,
+    pub(super) media_owners: RwLock<HashMap<crate::attachment::MediaRef, UserId>>,
 }
 
 impl InMemoryStore {
@@ -71,6 +72,7 @@ impl InMemoryStore {
             dependent_dimensions: RwLock::new(Vec::new()),
             events: RwLock::new(Vec::new()),
             sent_reminders: RwLock::new(Vec::new()),
+            media_owners: RwLock::new(HashMap::new()),
         }
     }
 
diff --git a/crates/domain/src/testing/fakes/store_entry.rs b/crates/domain/src/testing/fakes/store_entry.rs
index 629d709..e106937 100644
--- a/crates/domain/src/testing/fakes/store_entry.rs
+++ b/crates/domain/src/testing/fakes/store_entry.rs
@@ -1,5 +1,5 @@
 use crate::activity::ActivityId;
-use crate::entry::{DateRange, Mood, MoodEntry, MoodEntryId};
+use crate::entry::{DateRange, EntrySelection, MoodEntry, MoodEntryId, Pagination};
 use crate::errors::DomainError;
 use crate::user::UserId;
 
@@ -84,26 +84,28 @@ impl crate::ports::MoodEntryQueryPort for InMemoryStore {
         Ok(self.entries.read().unwrap().get(id).cloned())
     }
 
-    async fn find_by_user(
+    async fn find_all_by_user(&self, user_id: &UserId) -> Result<Vec<MoodEntry>, DomainError> {
+        Ok(self.newest_first(|entry| entry.user_id() == user_id))
+    }
+
+    async fn select(
         &self,
-        user_id: &UserId,
-        limit: Option<i64>,
-        offset: Option<i64>,
+        selection: &EntrySelection,
+        page: Pagination,
     ) -> Result<Vec<MoodEntry>, DomainError> {
-        let mut entries: Vec<_> = self
-            .entries
-            .read()
-            .unwrap()
-            .values()
-            .filter(|e| e.user_id() == user_id)
-            .cloned()
-            .collect();
+        let matching = self.newest_first(|entry| self.matches(entry, selection));
 
-        let offset = offset.unwrap_or(0) as usize;
-        let limit = limit.unwrap_or(i64::MAX) as usize;
-        entries = entries.into_iter().skip(offset).take(limit).collect();
+        Ok(matching
+            .into_iter()
+            .skip(page.offset() as usize)
+            .take(page.limit() as usize)
+            .collect())
+    }
 
-        Ok(entries)
+    async fn count(&self, selection: &EntrySelection) -> Result<u64, DomainError> {
+        Ok(self
+            .newest_first(|entry| self.matches(entry, selection))
+            .len() as u64)
     }
 
     async fn find_by_date_range(
@@ -125,41 +127,69 @@ impl crate::ports::MoodEntryQueryPort for InMemoryStore {
             .collect())
     }
 
-    async fn find_by_mood(
-        &self,
-        user_id: &UserId,
-        mood: Mood,
-    ) -> Result<Vec<MoodEntry>, DomainError> {
-        Ok(self
-            .entries
+    async fn count_tagged_with(&self, activity_id: &ActivityId) -> Result<u64, DomainError> {
+        let tagged = self
+            .entry_activities
             .read()
             .unwrap()
             .values()
-            .filter(|e| e.user_id() == user_id && e.mood() == mood)
-            .cloned()
-            .collect())
-    }
+            .filter(|ids| ids.contains(activity_id))
+            .count();
 
-    async fn find_by_activity(
-        &self,
-        user_id: &UserId,
-        activity_id: &ActivityId,
-    ) -> Result<Vec<MoodEntry>, DomainError> {
-        Ok(self
-            .entries
-            .read()
-            .unwrap()
-            .values()
-            .filter(|e| {
-                e.user_id() == user_id
-                    && self
-                        .entry_activities
-                        .read()
-                        .unwrap()
-                        .get(e.id())
-                        .is_some_and(|ids| ids.contains(activity_id))
-            })
-            .cloned()
-            .collect())
+        Ok(tagged as u64)
+    }
+}
+
+impl InMemoryStore {
+    fn newest_first(&self, wanted: impl Fn(&MoodEntry) -> bool) -> Vec<MoodEntry> {
+        let mut found: Vec<MoodEntry> = self
+            .entries
+            .read()
+            .unwrap()
+            .values()
+            .filter(|entry| wanted(entry))
+            .cloned()
+            .collect();
+
+        found.sort_by(|left, right| right.logged_at().cmp(left.logged_at()));
+
+        found
+    }
+
+    fn matches(&self, entry: &MoodEntry, selection: &EntrySelection) -> bool {
+        if entry.user_id() != selection.user_id() {
+            return false;
+        }
+
+        if let Some(range) = selection.range()
+            && (entry.logged_at() < range.start() || entry.logged_at() > range.end())
+        {
+            return false;
+        }
+
+        if let Some(mood) = selection.mood()
+            && entry.mood() != mood
+        {
+            return false;
+        }
+
+        if let Some(activity_id) = selection.activity()
+            && !self
+                .entry_activities
+                .read()
+                .unwrap()
+                .get(entry.id())
+                .is_some_and(|ids| ids.contains(activity_id))
+        {
+            return false;
+        }
+
+        if let Some(since) = selection.since()
+            && *entry.updated_at() <= since
+        {
+            return false;
+        }
+
+        true
     }
 }
diff --git a/crates/domain/src/testing/fakes/store_infra.rs b/crates/domain/src/testing/fakes/store_infra.rs
index 92c66f8..3d6cb93 100644
--- a/crates/domain/src/testing/fakes/store_infra.rs
+++ b/crates/domain/src/testing/fakes/store_infra.rs
@@ -49,45 +49,54 @@ impl crate::ports::MediaStoragePort for InMemoryStore {
     }
 }
 
+impl InMemoryStore {
+    fn forget_what_the_user_logged(&self, user_id: &UserId) {
+        self.entries
+            .write()
+            .unwrap()
+            .retain(|_, entry| entry.user_id() != user_id);
+        self.activities
+            .write()
+            .unwrap()
+            .retain(|_, activity| activity.user_id() != user_id);
+        self.reminders
+            .write()
+            .unwrap()
+            .retain(|_, reminder| reminder.user_id() != user_id);
+        self.daily_metrics
+            .write()
+            .unwrap()
+            .retain(|metric| metric.user_id() != user_id);
+        self.cycle_starts
+            .write()
+            .unwrap()
+            .retain(|(held, _)| held != user_id);
+        self.rejections
+            .write()
+            .unwrap()
+            .retain(|rejected| rejected.user_id() != user_id);
+        self.media_owners
+            .write()
+            .unwrap()
+            .retain(|_, owner| owner != user_id);
+    }
+}
+
 #[async_trait::async_trait]
 impl crate::ports::CascadeDeletePort for InMemoryStore {
     async fn delete_all_user_data(&self, user_id: &UserId) -> Result<(), DomainError> {
         self.cascade_to_dimensions(&self.entry_ids_of(user_id));
 
-        self.entries
-            .write()
-            .unwrap()
-            .retain(|_, e| e.user_id() != user_id);
-        self.activities
-            .write()
-            .unwrap()
-            .retain(|_, a| a.user_id() != user_id);
-        self.reminders
-            .write()
-            .unwrap()
-            .retain(|_, r| r.user_id() != user_id);
-        self.daily_metrics
-            .write()
-            .unwrap()
-            .retain(|m| m.user_id() != user_id);
+        self.forget_what_the_user_logged(user_id);
+
         Ok(())
     }
 
     async fn delete_user_account(&self, user_id: &UserId) -> Result<(), DomainError> {
         self.cascade_to_dimensions(&self.entry_ids_of(user_id));
 
-        self.entries
-            .write()
-            .unwrap()
-            .retain(|_, e| e.user_id() != user_id);
-        self.activities
-            .write()
-            .unwrap()
-            .retain(|_, a| a.user_id() != user_id);
-        self.reminders
-            .write()
-            .unwrap()
-            .retain(|_, r| r.user_id() != user_id);
+        self.forget_what_the_user_logged(user_id);
+
         self.refresh_sessions
             .write()
             .unwrap()
@@ -96,11 +105,16 @@ impl crate::ports::CascadeDeletePort for InMemoryStore {
             .write()
             .unwrap()
             .retain(|_, s| s.user_id() != user_id);
-        self.daily_metrics
+        self.provider_connections
             .write()
             .unwrap()
-            .retain(|m| m.user_id() != user_id);
+            .retain(|c| c.user_id() != user_id);
+        self.api_tokens
+            .write()
+            .unwrap()
+            .retain(|t| t.user_id() != user_id);
         self.users.write().unwrap().remove(user_id);
+
         Ok(())
     }
 
@@ -147,10 +161,13 @@ impl InMemoryStore {
 #[async_trait::async_trait]
 impl crate::ports::PushSubscriptionCommandPort for InMemoryStore {
     async fn save(&self, subscription: &PushSubscription) -> Result<(), DomainError> {
-        self.push_subscriptions
-            .write()
-            .unwrap()
-            .insert(subscription.id().clone(), subscription.clone());
+        let mut held = self.push_subscriptions.write().unwrap();
+
+        held.retain(|id, existing| {
+            id == subscription.id() || existing.endpoint() != subscription.endpoint()
+        });
+        held.insert(subscription.id().clone(), subscription.clone());
+
         Ok(())
     }
 
@@ -159,11 +176,15 @@ impl crate::ports::PushSubscriptionCommandPort for InMemoryStore {
         Ok(())
     }
 
-    async fn delete_by_endpoint(&self, endpoint: &str) -> Result<(), DomainError> {
+    async fn delete_by_endpoint(
+        &self,
+        user_id: &UserId,
+        endpoint: &str,
+    ) -> Result<(), DomainError> {
         self.push_subscriptions
             .write()
             .unwrap()
-            .retain(|_, s| s.endpoint() != endpoint);
+            .retain(|_, s| s.user_id() != user_id || s.endpoint() != endpoint);
         Ok(())
     }
 
diff --git a/crates/domain/src/testing/fakes/store_job.rs b/crates/domain/src/testing/fakes/store_job.rs
index 29f8f28..fe48bb1 100644
--- a/crates/domain/src/testing/fakes/store_job.rs
+++ b/crates/domain/src/testing/fakes/store_job.rs
@@ -172,6 +172,15 @@ impl crate::ports::RecordingBackfillQueryPort for InMemoryStore {
             .collect())
     }
 
+    async fn find_song_without_a_recording(
+        &self,
+        entry_id: &crate::entry::MoodEntryId,
+    ) -> Result<Option<UnidentifiedSong>, DomainError> {
+        let waiting = self.find_songs_without_a_recording(usize::MAX).await?;
+
+        Ok(waiting.into_iter().find(|song| &song.entry_id == entry_id))
+    }
+
     async fn record_identity(
         &self,
         entry_id: &crate::entry::MoodEntryId,
@@ -241,4 +250,15 @@ impl crate::ports::WeatherBacklogQueryPort for InMemoryStore {
             })
             .collect())
     }
+
+    async fn find_place_without_weather(
+        &self,
+        entry_id: &crate::entry::MoodEntryId,
+    ) -> Result<Option<crate::ports::UnwatchedPlace>, DomainError> {
+        let waiting = self.find_places_without_weather(usize::MAX).await?;
+
+        Ok(waiting
+            .into_iter()
+            .find(|place| &place.entry_id == entry_id))
+    }
 }
diff --git a/crates/domain/src/testing/fakes/store_media.rs b/crates/domain/src/testing/fakes/store_media.rs
new file mode 100644
index 0000000..7836315
--- /dev/null
+++ b/crates/domain/src/testing/fakes/store_media.rs
@@ -0,0 +1,47 @@
+use crate::attachment::MediaRef;
+use crate::errors::DomainError;
+use crate::user::UserId;
+
+use super::store::InMemoryStore;
+
+#[async_trait::async_trait]
+impl crate::ports::MediaOwnershipPort for InMemoryStore {
+    async fn remember(&self, owner: &UserId, media: MediaRef) -> Result<(), DomainError> {
+        self.media_owners
+            .write()
+            .unwrap()
+            .insert(media, owner.clone());
+
+        Ok(())
+    }
+
+    async fn owner_of(&self, media: MediaRef) -> Result<Option<UserId>, DomainError> {
+        Ok(self.media_owners.read().unwrap().get(&media).cloned())
+    }
+
+    async fn owned_by(&self, owner: &UserId) -> Result<Vec<MediaRef>, DomainError> {
+        Ok(self
+            .media_owners
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|(_, held)| *held == owner)
+            .map(|(media, _)| *media)
+            .collect())
+    }
+
+    async fn forget(&self, media: MediaRef) -> Result<(), DomainError> {
+        self.media_owners.write().unwrap().remove(&media);
+
+        Ok(())
+    }
+
+    async fn forget_all_by_user(&self, owner: &UserId) -> Result<(), DomainError> {
+        self.media_owners
+            .write()
+            .unwrap()
+            .retain(|_, held| held != owner);
+
+        Ok(())
+    }
+}
diff --git a/crates/domain/src/testing/mod.rs b/crates/domain/src/testing/mod.rs
index 663ec68..afd361b 100644
--- a/crates/domain/src/testing/mod.rs
+++ b/crates/domain/src/testing/mod.rs
@@ -4,6 +4,6 @@ mod fakes;
 pub use factories::*;
 pub use fakes::{
     FakeApiTokenSecret, FakeCredentialCipher, FakeMediaStorage, FakeNowPlaying, FakePasswordHasher,
-    FakeRecordingLookup, FakeWeatherLookup, InMemoryDimensionStore, InMemoryStore, OneTokenStore,
-    RefusingApiTokenStore, RefusingRejectionTrace,
+    FakeRecordingLookup, FakeWeatherLookup, InMemoryActivityDimension, InMemoryDimensionStore,
+    InMemoryStore, OneTokenStore, RefusingApiTokenStore, RefusingRejectionTrace,
 };
diff --git a/crates/domain/tests/api_token/api_token_test.rs b/crates/domain/tests/api_token/api_token_test.rs
index 7ccbccc..4bc2276 100644
--- a/crates/domain/tests/api_token/api_token_test.rs
+++ b/crates/domain/tests/api_token/api_token_test.rs
@@ -1,12 +1,17 @@
-use domain::api_token::{ApiToken, MintedApiToken, TokenDigest, TokenScope};
+use domain::api_token::{ApiToken, MintedApiToken, TokenDigest, TokenScope, TokenScopes};
 use domain::provider::ProviderName;
 use domain::user::UserId;
 
 fn a_token() -> ApiToken {
+    token_granting([TokenScope::WriteMetrics])
+}
+
+fn token_granting(scopes: impl IntoIterator<Item = TokenScope>) -> ApiToken {
     ApiToken::new(
         UserId::generate(),
         ProviderName::new("iphone-shortcuts").unwrap(),
         TokenDigest::from_persistence("digest-of-the-secret".into()),
+        TokenScopes::new(scopes).unwrap(),
     )
 }
 
@@ -15,7 +20,7 @@ fn a_fresh_token_has_never_been_used() {
     let token = a_token();
 
     assert!(token.last_used_at().is_none());
-    assert_eq!(token.scope(), TokenScope::WriteMetrics);
+    assert!(token.allows(TokenScope::WriteMetrics));
 }
 
 #[test]
@@ -36,13 +41,58 @@ fn the_name_a_token_carries_is_the_provider_its_writes_are_attributed_to() {
 
 #[test]
 fn every_scope_survives_a_round_trip_through_its_name() {
-    assert_eq!(
-        TokenScope::from_name(TokenScope::WriteMetrics.name()),
-        Some(TokenScope::WriteMetrics)
-    );
+    for scope in TokenScope::ALL {
+        assert_eq!(TokenScope::from_name(scope.name()), Some(scope));
+    }
+
     assert_eq!(TokenScope::from_name("read-everything"), None);
 }
 
+#[test]
+fn a_token_grants_only_what_it_was_minted_for() {
+    let token = token_granting([TokenScope::ReadJournal]);
+
+    assert!(token.allows(TokenScope::ReadJournal));
+    assert!(!token.allows(TokenScope::WriteJournal));
+    assert!(!token.allows(TokenScope::WriteMetrics));
+    assert!(!token.allows(TokenScope::ReadProfile));
+}
+
+#[test]
+fn a_token_that_grants_nothing_cannot_be_minted() {
+    assert!(TokenScopes::new([]).is_err());
+    assert!(TokenScopes::from_names(Vec::<&str>::new()).is_err());
+}
+
+#[test]
+fn an_unknown_scope_name_is_refused_rather_than_ignored() {
+    let refused = TokenScopes::from_names(["readJournal", "readEverything"]);
+
+    assert!(
+        refused.is_err(),
+        "a typo must not quietly mint a narrower token than asked for"
+    );
+}
+
+#[test]
+fn scopes_survive_a_round_trip_through_persistence() {
+    let held = TokenScopes::new([TokenScope::ReadJournal, TokenScope::WriteJournal]).unwrap();
+
+    assert_eq!(
+        TokenScopes::from_persistence(&held.to_persistence()),
+        Some(held)
+    );
+}
+
+#[test]
+fn a_stored_scope_this_build_cannot_read_makes_the_whole_set_unreadable() {
+    assert_eq!(
+        TokenScopes::from_persistence("readJournal writeEverything"),
+        None
+    );
+    assert_eq!(TokenScopes::from_persistence(""), None);
+}
+
 #[test]
 fn a_minted_token_keeps_the_secret_out_of_its_debug_output() {
     let minted = MintedApiToken::new(a_token(), "kmood_supersecretvalue".into());
diff --git a/crates/domain/tests/reminder.rs b/crates/domain/tests/reminder.rs
index 0a8a48d..407130c 100644
--- a/crates/domain/tests/reminder.rs
+++ b/crates/domain/tests/reminder.rs
@@ -1,2 +1,5 @@
+#[path = "reminder/due_occurrence_test.rs"]
+mod due_occurrence_test;
+
 #[path = "reminder/reminder_test.rs"]
 mod reminder_test;
diff --git a/crates/domain/tests/reminder/due_occurrence_test.rs b/crates/domain/tests/reminder/due_occurrence_test.rs
new file mode 100644
index 0000000..58e8cca
--- /dev/null
+++ b/crates/domain/tests/reminder/due_occurrence_test.rs
@@ -0,0 +1,169 @@
+use chrono::{DateTime, Duration, NaiveTime, TimeZone, Utc, Weekday};
+
+use domain::reminder::{DaySchedule, Reminder};
+use domain::user::{Timezone, UserId};
+
+const GRACE: Duration = Duration::minutes(30);
+
+fn warsaw() -> Timezone {
+    Timezone::new("Europe/Warsaw").unwrap()
+}
+
+fn at(time: &str) -> NaiveTime {
+    NaiveTime::parse_from_str(time, "%H:%M").unwrap()
+}
+
+fn instant(text: &str) -> DateTime<Utc> {
+    DateTime::parse_from_rfc3339(text)
+        .unwrap()
+        .with_timezone(&Utc)
+}
+
+fn every_day_at(time: &str) -> Reminder {
+    Reminder::new(UserId::generate(), DaySchedule::every_day_at(at(time)))
+}
+
+#[test]
+fn a_reminder_is_due_once_its_local_time_has_arrived() {
+    let reminder = every_day_at("20:00");
+    let just_after_eight_in_warsaw = instant("2026-08-27T18:01:00Z");
+
+    assert!(
+        reminder
+            .occurrence_reached(just_after_eight_in_warsaw, &warsaw(), GRACE)
+            .is_some()
+    );
+}
+
+#[test]
+fn a_reminder_is_not_due_before_its_local_time() {
+    let reminder = every_day_at("20:00");
+    let half_past_seven_in_warsaw = instant("2026-08-27T17:30:00Z");
+
+    assert!(
+        reminder
+            .occurrence_reached(half_past_seven_in_warsaw, &warsaw(), GRACE)
+            .is_none()
+    );
+}
+
+#[test]
+fn the_same_occurrence_is_never_due_twice() {
+    let mut reminder = every_day_at("20:00");
+    let first_sweep = instant("2026-08-27T18:01:00Z");
+
+    let occurrence = reminder
+        .occurrence_reached(first_sweep, &warsaw(), GRACE)
+        .expect("the reminder should be due on the first sweep");
+
+    reminder.mark_sent(occurrence);
+
+    for minute in 2..=25 {
+        let later = instant(&format!("2026-08-27T18:{minute:02}:00Z"));
+
+        assert!(
+            reminder
+                .occurrence_reached(later, &warsaw(), GRACE)
+                .is_none(),
+            "a reminder already sent must not be sent again at 18:{minute:02}"
+        );
+    }
+}
+
+#[test]
+fn the_next_days_occurrence_is_due_again() {
+    let mut reminder = every_day_at("20:00");
+    let today = instant("2026-08-27T18:01:00Z");
+
+    let occurrence = reminder
+        .occurrence_reached(today, &warsaw(), GRACE)
+        .unwrap();
+    reminder.mark_sent(occurrence);
+
+    let tomorrow = instant("2026-08-28T18:01:00Z");
+
+    assert!(
+        reminder
+            .occurrence_reached(tomorrow, &warsaw(), GRACE)
+            .is_some(),
+        "a new day is a new occurrence"
+    );
+}
+
+#[test]
+fn an_occurrence_late_yesterday_is_still_reachable_after_local_midnight() {
+    let schedule = {
+        let mut schedule = DaySchedule::new();
+        schedule.set_time(Weekday::Thu, Some(at("23:50")));
+        schedule
+    };
+    let reminder = Reminder::new(UserId::generate(), schedule);
+
+    let ten_past_midnight_on_friday = instant("2026-08-27T22:10:00Z");
+
+    assert!(
+        reminder
+            .occurrence_reached(ten_past_midnight_on_friday, &warsaw(), GRACE)
+            .is_some(),
+        "a reminder scheduled just before midnight must survive the day boundary"
+    );
+}
+
+#[test]
+fn an_occurrence_older_than_the_grace_window_is_not_resurrected() {
+    let reminder = every_day_at("08:00");
+    let late_that_evening = instant("2026-08-27T19:00:00Z");
+
+    assert!(
+        reminder
+            .occurrence_reached(late_that_evening, &warsaw(), GRACE)
+            .is_none(),
+        "a worker starting late must not fire this morning's reminder"
+    );
+}
+
+#[test]
+fn a_disabled_reminder_is_never_due() {
+    let mut reminder = every_day_at("20:00");
+    reminder.disable();
+
+    assert!(
+        reminder
+            .occurrence_reached(instant("2026-08-27T18:01:00Z"), &warsaw(), GRACE)
+            .is_none()
+    );
+}
+
+#[test]
+fn a_day_with_no_time_set_is_never_due() {
+    let schedule = {
+        let mut schedule = DaySchedule::new();
+        schedule.set_time(Weekday::Mon, Some(at("20:00")));
+        schedule
+    };
+    let reminder = Reminder::new(UserId::generate(), schedule);
+
+    let a_thursday = instant("2026-08-27T18:01:00Z");
+
+    assert!(
+        reminder
+            .occurrence_reached(a_thursday, &warsaw(), GRACE)
+            .is_none()
+    );
+}
+
+#[test]
+fn the_scheduled_instant_is_resolved_in_the_users_own_zone() {
+    let reminder = every_day_at("20:00");
+    let warsaw_evening = instant("2026-08-27T18:01:00Z");
+
+    let occurrence = reminder
+        .occurrence_reached(warsaw_evening, &warsaw(), GRACE)
+        .unwrap();
+
+    assert_eq!(
+        occurrence.scheduled_for(),
+        Utc.with_ymd_and_hms(2026, 8, 27, 18, 0, 0).unwrap(),
+        "8 PM in Warsaw in August is 18:00Z"
+    );
+}
diff --git a/crates/server/src/main.rs b/crates/server/src/main.rs
index 2d19f96..de9a895 100644
--- a/crates/server/src/main.rs
+++ b/crates/server/src/main.rs
@@ -28,9 +28,12 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
         "listening; background work runs in the k-mood-worker process"
     );
 
-    axum::serve(listener, router)
-        .with_graceful_shutdown(bootstrap::shutdown::on_signal())
-        .await?;
+    axum::serve(
+        listener,
+        router.into_make_service_with_connect_info::<std::net::SocketAddr>(),
+    )
+    .with_graceful_shutdown(bootstrap::shutdown::on_signal())
+    .await?;
 
     tracing::info!("k-mood server shut down gracefully");
 
diff --git a/crates/worker/Cargo.toml b/crates/worker/Cargo.toml
index b23d0e5..33a62e1 100644
--- a/crates/worker/Cargo.toml
+++ b/crates/worker/Cargo.toml
@@ -12,5 +12,6 @@ bootstrap.workspace = true
 domain.workspace = true
 application.workspace = true
 config.workspace = true
+chrono.workspace = true
 tokio.workspace = true
 tracing.workspace = true
diff --git a/crates/worker/src/loops.rs b/crates/worker/src/loops.rs
index 718f120..fde1e44 100644
--- a/crates/worker/src/loops.rs
+++ b/crates/worker/src/loops.rs
@@ -1,17 +1,19 @@
 use std::sync::Arc;
-use std::time::Duration;
+use std::time::Duration as StdDuration;
+
+use chrono::Duration;
 
 use application::job::use_cases::{run_due_jobs, sweep_recording_backlog, sweep_weather_backlog};
 use application::reminder::use_cases::process_due_reminders;
 use config::WorkerConfig;
 use domain::ports::{
     EntryDimensionPort, JobQueueCommandPort, RecordingBackfillQueryPort, RecordingLookupPort,
-    RefreshSessionCommandPort, ReminderQueryPort, ReminderSenderPort, UserQueryPort,
-    WeatherBacklogQueryPort, WeatherLookupPort,
+    RefreshSessionCommandPort, ReminderCommandPort, ReminderQueryPort, ReminderSenderPort,
+    UserQueryPort, WeatherBacklogQueryPort, WeatherLookupPort,
 };
 
 pub fn every(seconds: u64) -> tokio::time::Interval {
-    let mut interval = tokio::time::interval(Duration::from_secs(seconds.max(1)));
+    let mut interval = tokio::time::interval(StdDuration::from_secs(seconds.max(1)));
     interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
 
     interval
@@ -106,14 +108,17 @@ pub async fn sweep_for_work(
 
 pub async fn send_due_reminders(
     reminder_query: Arc<dyn ReminderQueryPort>,
+    reminder_command: Arc<dyn ReminderCommandPort>,
     user_query: Arc<dyn UserQueryPort>,
     sender: Arc<dyn ReminderSenderPort>,
     worker: WorkerConfig,
 ) {
     let deps = process_due_reminders::Deps {
         reminder_query,
+        reminder_command,
         user_query,
         sender,
+        grace: Duration::minutes(worker.reminder_grace_minutes),
     };
 
     let mut ticks = every(worker.reminder_seconds);
diff --git a/crates/worker/src/main.rs b/crates/worker/src/main.rs
index ae1f33a..c2debad 100644
--- a/crates/worker/src/main.rs
+++ b/crates/worker/src/main.rs
@@ -54,6 +54,7 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
     let reminders = context.reminder_sender.clone().map(|sender| {
         tokio::spawn(loops::send_due_reminders(
             context.state.reminder_query.clone(),
+            context.state.reminder_command.clone(),
             context.state.user_query.clone(),
             sender,
             worker,
diff --git a/docs/adr/0014-media-ownership-is-recorded-not-inferred.md b/docs/adr/0014-media-ownership-is-recorded-not-inferred.md
new file mode 100644
index 0000000..8fe7045
--- /dev/null
+++ b/docs/adr/0014-media-ownership-is-recorded-not-inferred.md
@@ -0,0 +1,24 @@
+# Media ownership is recorded, not inferred from the entries that wear it
+
+`MediaStoragePort` is a blob store — local filesystem or S3 behind `object_store` — and blobs have no owner. `DELETE /api/v1/media/photos/{id}` therefore authenticated the caller and then threw the id away, so any account could delete any other account's photo or voice memo by naming its uuid.
+
+Ownership could not be checked because nothing recorded it. The only trace was the `entry_photos` join, and that trace does not exist for the case the endpoint is for: a photo uploaded and then dropped before the entry was ever saved.
+
+## Considered Options
+
+- **Infer the owner from `entry_photos` joined to `mood_entries`** — free, and wrong for exactly the uploads the delete endpoint serves. A just-uploaded blob has no entry, so it would be undeletable or unprotected, and which of the two depends on how the absence is read.
+- **Namespace the object key by user (`photos/{user_id}/{uuid}`)** — ownership becomes structural and needs no table. It also puts the account id in every media URL the SPA renders, and rewrites every `get`/`delete` signature so the caller must already know the owner, which is the thing being established.
+
+## Consequences
+
+A `media_owners` table records `(kind, media_id, user_id)` at upload, behind a new `MediaOwnershipPort`. The blob store stays ignorant of users, which is correct: object stores do not do authorization.
+
+`MediaRef` carries the kind alongside the uuid so one port serves both photos and voice memos without six near-duplicate methods. Because the kind is part of the key, a `PhotoId` and a `VoiceMemoId` sharing a uuid are still two different objects, and claiming one does not claim the other.
+
+Media restored from a backup is claimed for the restoring account, so a restore does not produce blobs nobody owns.
+
+The migration backfills owners from `entry_photos` and `entry_voice_memos`. Blobs stranded by an abandoned upload predating this table have no owner and cannot be deleted through the API — they are unreachable rather than dangerous, and a sweep for them is work this document does not do.
+
+## The read path is still unauthenticated
+
+`GET /api/v1/media/photos/{id}` takes no bearer token, because the SPA renders photos in `<img src>` and cannot attach one. Access rests on the uuid being unguessable. That is a deliberate capability URL, not an oversight, and it is recorded here because it is indistinguishable from one in the handler. Closing it means fetching blobs through XHR and object URLs, or a cookie scoped to the media routes, and neither is worth doing until media is shared beyond the account that uploaded it.
diff --git a/docs/adr/0015-one-canonical-instant-in-the-column.md b/docs/adr/0015-one-canonical-instant-in-the-column.md
new file mode 100644
index 0000000..b396335
--- /dev/null
+++ b/docs/adr/0015-one-canonical-instant-in-the-column.md
@@ -0,0 +1,32 @@
+# A MoodEntry's instant is stored in one canonical form
+
+`logged_at` is a `DateTime<FixedOffset>` written to a TEXT column with `to_rfc3339()`, so the offset it happened to arrive in went into the column. Every range query compares that column as a string:
+
+```sql
+WHERE user_id = ? AND logged_at >= ? AND logged_at <= ? ORDER BY logged_at DESC
+```
+
+Text ordering only agrees with instant ordering while every row carries the same offset. `2026-08-25T00:30:00+02:00` sorts after `2026-08-25T00:00:00+00:00` and precedes it in time. Mixed offsets are reachable: `update_profile` lets an account change timezone, and the importer stamps each row with the offset in force on that row's own date, so a year of imported history already spans two.
+
+The in-memory fake could not catch this. It compares `DateTime<FixedOffset>` values, and chrono compares instants — the fake was right and the database was wrong, which is the one direction the fake rules do not warn about.
+
+## Considered Options
+
+- **A second sortable column beside `logged_at`** — keeps the offset a row arrived in. Two representations of one fact, both writable, and nothing forces them to agree.
+- **An integer epoch column** — sorts and compares correctly and reads as nothing at all in a `sqlite3` session, on a table that is otherwise legible text.
+
+## Consequences
+
+`sortable_instant` converts to UTC and formats to second precision, and is the single place any instant becomes column text. Writes, range predicates and the cascade's range delete all go through it, so a query cannot be written against one convention and stored data another.
+
+The offset a client sent is not preserved. Per ADR 0001 nothing derives a day boundary from it — the User's timezone does that — so the offset was a rendering, not data. `MoodEntry` carries the instant it was logged, and one instant now has one spelling. The SPA reads `loggedAt` through `new Date(...)` in every place it touches it, so it renders in the viewer's own zone either way.
+
+Second precision is the granularity the importer works in, and it makes two spellings of one moment compare equal.
+
+Migration 015 rewrites existing rows with SQLite's own time parser, which reads the offset suffix and normalizes to UTC, and adds an index on `(user_id, logged_at)` now that the column's order means something.
+
+## Import dedup had to move with it
+
+`import_entries` skipped a row when `(logged_at.to_rfc3339(), mood)` matched a stored entry — a comparison of renderings. Once stored rows read back as `+00:00` and the importer derives `+02:00` for the same instant, that key stops matching and a re-import duplicates the whole file.
+
+`AlreadyHere` keys on the instant and the mood instead, so the same moment is the same entry whichever offset either side is spelled in. It is also updated as rows are accepted, which the old set was not, so a file that repeats a row internally no longer imports it twice.
diff --git a/docs/adr/0016-a-reminder-remembers-what-it-sent.md b/docs/adr/0016-a-reminder-remembers-what-it-sent.md
new file mode 100644
index 0000000..922c49d
--- /dev/null
+++ b/docs/adr/0016-a-reminder-remembers-what-it-sent.md
@@ -0,0 +1,24 @@
+# A Reminder remembers the occurrence it sent
+
+`process_due_reminders` decided a reminder was due by subtracting the scheduled time from the local wall clock and accepting a difference of nought to five minutes. The worker polls every sixty seconds. Every reminder therefore fired five times, once per tick, and `Reminder` held no state that could tell the second tick the first had already sent.
+
+The same subtraction failed across midnight. A reminder set for 23:50 was compared against a 00:05 wall clock as a `NaiveTime` difference, which is large and negative, so the sweep that should have delivered it skipped it instead.
+
+## Considered Options
+
+- **Widen the poll interval to match the window** — one line, and it trades duplicate sends for a reminder arriving up to five minutes late while still fixing nothing about midnight. The window and the interval stay coupled, so tuning either reintroduces the bug.
+- **A sent-today marker keyed on the local date** — enough for one reminder a day, and wrong for the two-reminders-a-day case the domain language already allows ("one for morning check-in, one for evening").
+
+## Consequences
+
+`Reminder` carries `last_sent_at`, and the question it answers is not "is it roughly this time" but "which scheduled occurrence has been reached, and was that one already sent". `occurrence_reached` resolves the scheduled wall clock into the User's zone, takes it as an instant, and offers it only when the instant has passed, is inside the grace window, and is later than whatever was last sent. `mark_sent` stores the occurrence's own instant, not the moment of sending, so the comparison is against the schedule rather than against the clock.
+
+Yesterday's local date is considered alongside today's, which is what carries a 23:50 reminder over the midnight boundary.
+
+The window is a configured grace rather than a constant, defaulting to thirty minutes. It bounds how late a delivery may still be attempted — a worker restarted at noon does not fire the morning's reminder — and it no longer has to agree with the poll interval, because the duplicate is prevented by the recorded occurrence and not by the arithmetic.
+
+A send that fails is not marked, so the next sweep inside the window tries again. A send that succeeds but whose write fails is logged at error and may repeat, which is the right way round: this is a notification, and one arriving twice costs less than one that never arrives.
+
+## The sweep no longer stops for one account
+
+The loop carried a comment saying one user with no reachable device must not stop the sweep for everyone behind them, and it was half true. A failing `send_reminder` was caught, but a failing `find_by_id` propagated with `?` and abandoned the rest. Reading the account behind a reminder now degrades the same way delivering to it does: logged, skipped, sweep continues.
diff --git a/docs/adr/0017-clearing-data-is-not-resetting-the-account.md b/docs/adr/0017-clearing-data-is-not-resetting-the-account.md
new file mode 100644
index 0000000..d88d3b6
--- /dev/null
+++ b/docs/adr/0017-clearing-data-is-not-resetting-the-account.md
@@ -0,0 +1,21 @@
+# Clearing an account's data empties what it logged, not what it is
+
+`delete_all_user_data` deleted four tables — entries, activities, reminders, daily metrics — and logged "all user data cleared". Cycle starts, rejected metrics and media ownership survived it, and so did every blob the account had uploaded but never attached to an entry.
+
+The tables were missed because the account row stays, so nothing cascades. `delete_user_account` has no such gap: it deletes the users row and `foreign_keys` is on, so `ON DELETE CASCADE` reaches everything hanging off it.
+
+## What counts as data
+
+CompleteBackup already draws the line this needed: it carries everything an account knows and explicitly "no credentials and no RejectedMetrics". Clearing follows the same seam, one table further out.
+
+Emptied: MoodEntries, Activities, Reminders, DailyMetrics, CycleStarts, RejectedMetrics, and the media a User owns. A RejectedMetric is a trace of the account's own readings, so clearing the readings and keeping the complaints about them would be incoherent — it goes, even though a backup does not carry it.
+
+Kept: the account, its UserPreferences, its sessions and push subscriptions, its ApiTokens and its ProviderConnections. A preference is a choice the User made, not something they logged; clearing cycle records while leaving cycle tracking on is a coherent state and turning it off silently is not. Credentials are revoked deliberately, one at a time, and a request to clear a journal is not a request to break every automation writing into it.
+
+## Consequences
+
+The table list is a named constant the cascade loops over, so a new user-scoped table is one line rather than one forgotten `DELETE`. `InMemoryStore` clears the same set through one shared method, because a fake that forgets a table cannot fail the test that would have caught this.
+
+Media is no longer resolved by composing entries and reading their photo ids. `MediaOwnershipPort::owned_by` returns everything the account owns, so a blob uploaded and abandoned before its entry was saved is cleared with the rest — the orphan that the entry-shaped question could never see. `clear_data` and `delete_user` lost their `dimensions` and `entry_query` dependencies as a result; `delete_entries_by_date_range` keeps the entry-shaped path, because it deletes a subset of entries and ownership does not say which entry a blob belongs to.
+
+Ownership is still read before the cascade runs, for the same reason it always was: the cascade deletes the rows that name the blobs.
diff --git a/docs/adr/0018-tokens-grant-scopes-sessions-own-the-account.md b/docs/adr/0018-tokens-grant-scopes-sessions-own-the-account.md
new file mode 100644
index 0000000..c1426f2
--- /dev/null
+++ b/docs/adr/0018-tokens-grant-scopes-sessions-own-the-account.md
@@ -0,0 +1,22 @@
+# A token grants named scopes; only a session owns the account
+
+`ApiToken` carried a single-variant `TokenScope::WriteMetrics`, and only the metric-write routes accepted one. Every other route took `AuthenticatedUser`, which validated a JWT and nothing else. A client that was not the SPA therefore had exactly two options: write metrics, or hold the account's password and log in as the user.
+
+That is the right boundary for an importer and the wrong one for a desktop widget, which needs to read entries and write them and should never be trusted with the password.
+
+## Considered Options
+
+- **Let `AuthenticatedUser` accept any api token** — one line, and it hands every token the whole account, including minting further tokens and restoring a backup over the top of the data. A credential that can mint credentials is not a narrower credential.
+- **One scope per token** — matches the column that already existed and forces a widget to juggle two secrets to read and write. The set is the natural unit; a token is a role, not a permission.
+
+## Consequences
+
+`TokenScopes` is a non-empty set, so a token that grants nothing cannot be minted, and an unknown scope name is refused rather than dropped — a typo must not quietly produce a narrower token than the one asked for. A stored set containing a scope this build cannot read makes the whole token unreadable, the same way an unreadable metric row is refused rather than half-understood.
+
+The four scopes name what a client does rather than which routes it calls: `readJournal`, `writeJournal`, `writeMetrics`, `readProfile`. Routes are grouped behind one extractor each — `JournalReader`, `JournalWriter`, `MetricWriter`, `ProfileReader` — so the scope a route needs is visible in its signature and a new route must choose one to compile.
+
+`SessionUser` replaces `AuthenticatedUser` and accepts a JWT only. It guards what no token may reach: the password, the profile, provider credentials, push registration, backup, restore, import, and minting or revoking tokens. The rename is the point — "authenticated" no longer distinguishes the two things that can authenticate.
+
+`writeMetrics` keeps its old meaning exactly, so the token's name still becomes the Provider its metric writes are attributed to. A token without `writeMetrics` never reaches that path and its name is only a label.
+
+Migration 016 backfills every existing token with `writeMetrics`, which is what it already had, and drops the old column. An importer minted before this change keeps working and gains nothing.
diff --git a/docs/adr/0019-a-page-is-a-selection-and-a-window.md b/docs/adr/0019-a-page-is-a-selection-and-a-window.md
new file mode 100644
index 0000000..f259c59
--- /dev/null
+++ b/docs/adr/0019-a-page-is-a-selection-and-a-window.md
@@ -0,0 +1,28 @@
+# Reading entries is one selection and one window, not four query methods
+
+`MoodEntryQueryPort` grew a method per question: `find_by_user` with an optional limit and offset, `find_by_date_range`, `find_by_mood`, `find_by_activity`. Only the first paged, none counted, and none composed — a client could not ask for "this month's bad days, twenty at a time", and `GET /entries/filter/mood/5` returned every matching entry an account had ever written.
+
+Without a count, `GET /entries` could only be paged by fetching until a short page came back, and a client polling for changes had to refetch the whole journal because `updatedAt` was returned but never queryable.
+
+## Considered Options
+
+- **Add limit, offset and a count to each existing method** — four signatures growing the same four parameters, and still no way to combine two narrowings.
+- **Add the paging methods beside the old ones** — no risk to the internal readers, and two ways to ask the same question, which is the shape this document exists to remove.
+
+## Consequences
+
+`EntrySelection` names what to read — account, date range, mood, activity, changed-since — and `Pagination` names the window over it. The port offers `select` and `count` against that pair, and one SQL builder assembles both from the same conditions, so a filter can never apply to the page and not the count.
+
+`find_by_mood` and `find_by_activity` are gone; they were only ever the API's. `find_by_user` became `find_all_by_user` with no window at all, because every remaining caller — backup, extract, import, restore, stats — wants the whole account and said so by passing `None, None`. The two paths are now honestly different: one page of a selection, or everything.
+
+`Pagination::new` refuses a page of nothing, a negative offset, and a page larger than the server serves, so an unbounded read is not expressible rather than merely discouraged. The bound is configuration, reported by `GET /api/v1/server`, not a constant.
+
+`Page` carries the total for the whole selection alongside the items, so `hasMore` is a fact rather than an inference from a short page.
+
+`/entries/filter/mood/{mood}` and `/entries/filter/activity/{id}` stay, and now delegate to the same handler with one parameter preset. They are a convenience over the selection, not a second way to read.
+
+## What a polling client should do
+
+`updatedSince` returns only entries changed after an instant, which is why `updated_at` is indexed. A widget refreshing every minute asks for what changed rather than for the journal, and the answer is usually empty.
+
+This is a poll, not a subscription: an entry deleted since the last poll leaves no trace in the result, so a client that must notice deletions still needs an occasional full read. Recording tombstones to make deletion observable is real work for a case a personal journal has not yet needed.
diff --git a/docs/adr/0020-one-refusal-shape.md b/docs/adr/0020-one-refusal-shape.md
new file mode 100644
index 0000000..3a7adc7
--- /dev/null
+++ b/docs/adr/0020-one-refusal-shape.md
@@ -0,0 +1,21 @@
+# Every refusal is one shape, and the spec says so
+
+A client talking to this API had to parse four different failure bodies: `{"error":{"code","message"}}` from a handler, `{"error":"..."}` from the auth extractor, the same again from the path-id extractor, and axum's plain text when a JSON body would not parse. None of the four appeared in the OpenAPI document, which described zero refusals across sixty-four operations.
+
+Login and refresh — the first two calls any client makes — returned `Json<serde_json::Value>` and were documented with a description and no schema, so a generated client received an untyped blob from the endpoints it needs most.
+
+## Consequences
+
+`ErrorResponse` lives in `api-types` beside every other payload, and `refuse` is the single function that builds one. The auth and path-id rejections call it; `Body` and `Params` replace axum's `Json` and `Query` extractors so a malformed request is refused in the same shape as everything else; the rate limiter's 429 uses it too.
+
+A scope refusal is now 403 rather than 401. The distinction matters to a client: 401 means the credential is not valid, and retrying with the same one is pointless; 403 means it is valid and insufficient, and the answer is a token minted with more.
+
+Every operation declares its refusals, and four contract tests hold the line: every success carries a schema, every operation documents a 4xx, every guarded operation documents both 401 and 403, and every refusal references `ErrorResponse` and nothing else. A new endpoint that skips this fails the suite rather than shipping undocumented.
+
+## The api-types crate says what each type is for
+
+The crate now has three input-and-output modules rather than two: `requests` for bodies a client sends, `params` for query strings, `responses` for bodies it receives. Query parameters were previously mixed among request bodies, which made "what can a client send here" a question about the type's name rather than its module.
+
+Every type carries the suffix of its kind, with no exceptions left — `MoodFrequency` and `ErrorDetail` were the last two, and both were nested payload parts whose names claimed otherwise.
+
+The SPA's zod schemas now mirror the server's type names one for one. That is not cosmetic: aligning them surfaced that `AuthTokenResponse` had modelled `user` as optional to cover both login and refresh, so the SPA had no way to notice the server dropping a field from one of them.
diff --git a/spa/bun.lock b/spa/bun.lock
index 3377392..f2646a9 100644
--- a/spa/bun.lock
+++ b/spa/bun.lock
@@ -1,13 +1,11 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 1,
   "workspaces": {
     "": {
       "name": "start-app",
       "dependencies": {
         "@base-ui/react": "^1.7.0",
         "@fontsource-variable/inter": "^5.3.0",
-        "@shadcn/react": "^0.3.0",
         "@tailwindcss/vite": "^4",
         "@tanstack/react-devtools": "latest",
         "@tanstack/react-query": "^5.102.3",
@@ -18,15 +16,11 @@
         "axios": "^1.19.0",
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
-        "cmdk": "^1.1.1",
         "date-fns": "^4.4.0",
-        "embla-carousel-react": "^8.6.0",
-        "input-otp": "^1.5.0",
         "lucide-react": "^1.34.0",
         "react": "^19.2.6",
         "react-day-picker": "^10.0.1",
         "react-dom": "^19.2.6",
-        "react-resizable-panels": "^4.12.3",
         "recharts": "3.8.0",
         "shadcn": "^4.19.0",
         "tailwind-merge": "^3.6.0",
@@ -260,38 +254,6 @@
 
     "@oxc-project/types": ["@oxc-project/types@0.146.0", "", {}, "sha512-XC0QsnnhVe7sLIWmYmdPw7x5P0h4W8vUU3Nv1ySgWXtvCz8NizoAEpGXA0sOYoJQV2Rl13LgURAHQ5cI5ILCSA=="],
 
-    "@radix-ui/primitive": ["@radix-ui/primitive@1.1.7", "", {}, "sha512-rqWnm76nYT8HoNNqEjpgJ7Pw/DrBj5iBTrmEPo6HTX5+VJyBNOqTdv4g89G63HuR5g0AaENoAcH7Is5fF2kZ8Q=="],
-
-    "@radix-ui/react-compose-refs": ["@radix-ui/react-compose-refs@1.1.5", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-+48PbAAbq3didjJxa+OaWY2ZwgAKsNiRGyeHKszblZMQ+kcpd9pAaT11cMkGEie0vsOi3QdeTE6d5Fe3Gn61kA=="],
-
-    "@radix-ui/react-context": ["@radix-ui/react-context@1.2.2", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RHCUGwKHDr0hDGg4X7ma4JG4/+12qxw8rkh5QKdDldlCvtja6nUx1Ef/8HVrJze81lEsgLQlqjzjGNHantgnQA=="],
-
-    "@radix-ui/react-dialog": ["@radix-ui/react-dialog@1.1.23", "", { "dependencies": { "@radix-ui/primitive": "1.1.7", "@radix-ui/react-compose-refs": "1.1.5", "@radix-ui/react-context": "1.2.2", "@radix-ui/react-dismissable-layer": "1.1.19", "@radix-ui/react-focus-guards": "1.1.6", "@radix-ui/react-focus-scope": "1.1.16", "@radix-ui/react-id": "1.1.4", "@radix-ui/react-portal": "1.1.17", "@radix-ui/react-presence": "1.1.10", "@radix-ui/react-primitive": "2.1.10", "@radix-ui/react-slot": "1.3.3", "@radix-ui/react-use-controllable-state": "1.2.6", "@radix-ui/react-use-layout-effect": "1.1.4", "aria-hidden": "^1.2.4", "react-remove-scroll": "^2.7.2" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-Ksw4WeROkO4rC9k/onilX/Ao2Cr1ku1unMNH+XSCcP4jSXYu7HDsg9n4ojMjVb22XpYjAQ9qfrFlVbru1vXDUA=="],
-
-    "@radix-ui/react-dismissable-layer": ["@radix-ui/react-dismissable-layer@1.1.19", "", { "dependencies": { "@radix-ui/primitive": "1.1.7", "@radix-ui/react-compose-refs": "1.1.5", "@radix-ui/react-primitive": "2.1.10", "@radix-ui/react-use-callback-ref": "1.1.4", "@radix-ui/react-use-effect-event": "0.0.5" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-8g4pfOL9HoKKLWGiypT+dphVqjFfmcXO5GBnhsG6zI+lxAx/8feQpr+1LSN8Re3hiZ+XkLNS4O9ztK11/LzQ6w=="],
-
-    "@radix-ui/react-focus-guards": ["@radix-ui/react-focus-guards@1.1.6", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-RNOJjfZMTyBM6xYmV3IVGXkPjIhcBAuv48POevAXwrGJhkWZ9p1rFoIS1JFooPuT193AZmRsCPhpoVJxx6OPoQ=="],
-
-    "@radix-ui/react-focus-scope": ["@radix-ui/react-focus-scope@1.1.16", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.5", "@radix-ui/react-primitive": "2.1.10", "@radix-ui/react-use-callback-ref": "1.1.4" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-wmRZ2WWLvmt6KHy2rNPOdPUjwq5xOHY02+m+udwJTn0aNIox/rkskAvJTyTLGhPK6KgrUjlJUJpgmx/+wFiFIQ=="],
-
-    "@radix-ui/react-id": ["@radix-ui/react-id@1.1.4", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.4" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-TMQp2llA+RYn7JcjnrMnz7wN4pcVttPZnRZo52PLQsoLVKzNlVwUeHmfePgTgRluXFvlD3GD5g5MOVVTJCO0qA=="],
-
-    "@radix-ui/react-portal": ["@radix-ui/react-portal@1.1.17", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.10", "@radix-ui/react-use-layout-effect": "1.1.4" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-vKQLcWypUnwZVvfV7UkGahH2g6ySe8M8R+zYBwPrv5byZ9QAW6cQVvNKo7GgmD+p8aYb6D9JBuvy8/WhOno2wQ=="],
-
-    "@radix-ui/react-presence": ["@radix-ui/react-presence@1.1.10", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.4" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-3wyzCQ6+ubRA+D4uv9m95JYLXxmOHp05qjrkjeA7uKHHtjpPggQzc6DAb0URl7j67oR0K2foO4ip27TiX037Bw=="],
-
-    "@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.10", "", { "dependencies": { "@radix-ui/react-slot": "1.3.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-MucOnzh6hR5mid6VpkbglRAMYMjKLqRnGBbjXkzjK52fuQDd1qbkx78a5P40mkcnVXJdEVxm26E9OPAiUq7nBg=="],
-
-    "@radix-ui/react-slot": ["@radix-ui/react-slot@1.3.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.5" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-qx7oqnYbxnK9kYI9m317qmFmEgo6ywqWvbTogdj7cL9p3/yx4M48p7Rnw5z3H890cL/ow/EeWJsuTykeZVXP5Q=="],
-
-    "@radix-ui/react-use-callback-ref": ["@radix-ui/react-use-callback-ref@1.1.4", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-R6OUY2e2fA6Yn6s+VSx5KBV6Nx8LQEhu+cz7LCej18rQ1HLyg9PSC9jP/ZNx0o6FAIK9c0F1kHylzSxKsdlkrQ=="],
-
-    "@radix-ui/react-use-controllable-state": ["@radix-ui/react-use-controllable-state@1.2.6", "", { "dependencies": { "@radix-ui/primitive": "1.1.7", "@radix-ui/react-use-effect-event": "0.0.5", "@radix-ui/react-use-layout-effect": "1.1.4" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-uEQJGT97ZA/TgP/Hydw47lHu+/vQj6z/0jA+WeTbK1o9Rx45GImjpD0tc3W5ad3D6XTSR6e1yEO0FvGq6WQfVQ=="],
-
-    "@radix-ui/react-use-effect-event": ["@radix-ui/react-use-effect-event@0.0.5", "", { "dependencies": { "@radix-ui/react-use-layout-effect": "1.1.4" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-7cshFL8HGS/7HEiHH+9kL9HBwp2sa9yX18Knwek6KYWmXwM7pegMgta2AXMQKI+rq3JnfSj9x8wYqFMTdG1Jgg=="],
-
-    "@radix-ui/react-use-layout-effect": ["@radix-ui/react-use-layout-effect@1.1.4", "", { "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-K20DkRkUwDnxEYMBPcg3Y6voLkEy5p5QQmszZgLngKKiC7dzBR/aEuK3w1qlx2JWDUNH6FluahYdgR3BP+QbYw=="],
-
     "@reduxjs/toolkit": ["@reduxjs/toolkit@2.12.0", "", { "dependencies": { "@standard-schema/spec": "^1.0.0", "@standard-schema/utils": "^0.3.0", "immer": "^11.0.0", "redux": "^5.0.1", "redux-thunk": "^3.1.0", "reselect": "^5.1.0" }, "peerDependencies": { "react": "^16.9.0 || ^17.0.0 || ^18 || ^19", "react-redux": "^7.2.1 || ^8.1.3 || ^9.0.0" }, "optionalPeers": ["react", "react-redux"] }, "sha512-KiT+RzZbp6mQET+Mg+h2c97+9j1sNflUxQkIHI7Yuzf6Peu+OYpmkn6nbHWmLLWj+1ZODUJFwGZ7gx3L9R9EOw=="],
 
     "@rolldown/binding-android-arm-eabi": ["@rolldown/binding-android-arm-eabi@1.2.5", "", { "os": "android", "cpu": "arm" }, "sha512-DLe/i+l8ynIBY7XEQ191TeZvCoowIGa18R+dIV30GW7DiOtp74i/xX8hs8GUjW5ARV7VZuie3d6AumSmCwbeRA=="],
@@ -328,8 +290,6 @@
 
     "@sec-ant/readable-stream": ["@sec-ant/readable-stream@0.4.1", "", {}, "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg=="],
 
-    "@shadcn/react": ["@shadcn/react@0.3.0", "", { "peerDependencies": { "@types/react": ">=19", "react": ">=19" }, "optionalPeers": ["@types/react", "react"] }, "sha512-iKN0NuYe850VDHlxEfvppFrpa7CMV3zArTHusXlaSmeFeQhohGbIqclv6WwPTs/44I8EkXQpcuRt6sXEVKkWqQ=="],
-
     "@sindresorhus/merge-streams": ["@sindresorhus/merge-streams@4.0.0", "", {}, "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ=="],
 
     "@solid-primitives/event-listener": ["@solid-primitives/event-listener@2.4.6", "", { "dependencies": { "@solid-primitives/utils": "^6.4.1" }, "peerDependencies": { "solid-js": "^1.6.12" } }, "sha512-5I0YJcTVYIWoMmgBSROBZGcz+ymhew/pGTg2dHW74BUjFKsV8Li4bOZYl0YAGP4mHw5o4UBd9/BEesqBci3wxw=="],
@@ -576,8 +536,6 @@
 
     "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
 
-    "aria-hidden": ["aria-hidden@1.2.6", "", { "dependencies": { "tslib": "^2.0.0" } }, "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA=="],
-
     "aria-query": ["aria-query@5.3.0", "", { "dependencies": { "dequal": "^2.0.3" } }, "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A=="],
 
     "assertion-error": ["assertion-error@2.0.1", "", {}, "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA=="],
@@ -632,8 +590,6 @@
 
     "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
 
-    "cmdk": ["cmdk@1.1.1", "", { "dependencies": { "@radix-ui/react-compose-refs": "^1.1.1", "@radix-ui/react-dialog": "^1.1.6", "@radix-ui/react-id": "^1.1.0", "@radix-ui/react-primitive": "^2.0.2" }, "peerDependencies": { "react": "^18 || ^19 || ^19.0.0-rc", "react-dom": "^18 || ^19 || ^19.0.0-rc" } }, "sha512-Vsv7kFaXm+ptHDMZ7izaRsP70GgrW9NBNGswt9OZaVBLlE0SNpDq8eu/VGXyF9r7M0azK3Wy7OlYXsuyYLFzHg=="],
-
     "code-block-writer": ["code-block-writer@13.0.3", "", {}, "sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg=="],
 
     "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
@@ -732,8 +688,6 @@
 
     "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
 
-    "detect-node-es": ["detect-node-es@1.1.0", "", {}, "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ=="],
-
     "diff": ["diff@8.0.4", "", {}, "sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw=="],
 
     "dom-accessibility-api": ["dom-accessibility-api@0.5.16", "", {}, "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg=="],
@@ -748,12 +702,6 @@
 
     "electron-to-chromium": ["electron-to-chromium@1.5.414", "", {}, "sha512-aYlviXiaXBbzvKgyALpcMmqa3Np3sDr0XnZbEG62n2UpZFbEcjQ4EEMOLGzVPhwVnwTz0lvKY+GcARbunuHekw=="],
 
-    "embla-carousel": ["embla-carousel@8.6.0", "", {}, "sha512-SjWyZBHJPbqxHOzckOfo8lHisEaJWmwd23XppYFYVh10bU66/Pn5tkVkbkCMZVdbUE5eTCI2nD8OyIP4Z+uwkA=="],
-
-    "embla-carousel-react": ["embla-carousel-react@8.6.0", "", { "dependencies": { "embla-carousel": "8.6.0", "embla-carousel-reactive-utils": "8.6.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.1 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-0/PjqU7geVmo6F734pmPqpyHqiM99olvyecY7zdweCw+6tKEXnrE90pBiBbMMU8s5tICemzpQ3hi5EpxzGW+JA=="],
-
-    "embla-carousel-reactive-utils": ["embla-carousel-reactive-utils@8.6.0", "", { "peerDependencies": { "embla-carousel": "8.6.0" } }, "sha512-fMVUDUEx0/uIEDM0Mz3dHznDhfX+znCCDCeIophYb1QGVM7YThSWX+wz11zlYwWFOr74b4QLGg0hrGPJeG2s4A=="],
-
     "emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="],
 
     "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],
@@ -882,8 +830,6 @@
 
     "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
 
-    "get-nonce": ["get-nonce@1.0.1", "", {}, "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q=="],
-
     "get-own-enumerable-keys": ["get-own-enumerable-keys@1.0.0", "", {}, "sha512-PKsK2FSrQCyxcGHsGrLDcK0lx+0Ke+6e8KFFozA9/fIQLhQzPaRvJFdcz7+Axg3jUH/Mq+NI4xa5u/UT2tQskA=="],
 
     "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
@@ -936,8 +882,6 @@
 
     "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
 
-    "input-otp": ["input-otp@1.5.0", "", { "peerDependencies": { "react": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc" } }, "sha512-3AcfdW1sNG0FmSA5hHMBXG7jNW5CdcdKs8ln8JOmn6S2SRkoXoJx+2UwC+ZvjflfnOdHJx0SfQ9/YjlxVYLtGQ=="],
-
     "internmap": ["internmap@2.0.3", "", {}, "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg=="],
 
     "ip-address": ["ip-address@10.5.0", "", {}, "sha512-R5SnVLJmgYYvf2F2ZgwSBnelz5G4q5AxIC277GDfUaNbrZKNANcBC7RHqYYePlszf4kBolVkJauG0ZjHHFh55g=="],
@@ -1192,14 +1136,6 @@
 
     "react-redux": ["react-redux@9.3.0", "", { "dependencies": { "@types/use-sync-external-store": "^0.0.6", "use-sync-external-store": "^1.4.0" }, "peerDependencies": { "@types/react": "^18.2.25 || ^19", "react": "^18.0 || ^19", "redux": "^5.0.0" }, "optionalPeers": ["@types/react", "redux"] }, "sha512-KQopgqFo/p/fgmAs5qz6p5RWaNAzq40WAu7fJIXnQpYxFPbJYtsJPWvGeF2rOBaY/kEuV77AVsX8TsQzKm+A/g=="],
 
-    "react-remove-scroll": ["react-remove-scroll@2.7.2", "", { "dependencies": { "react-remove-scroll-bar": "^2.3.7", "react-style-singleton": "^2.2.3", "tslib": "^2.1.0", "use-callback-ref": "^1.3.3", "use-sidecar": "^1.1.3" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q=="],
-
-    "react-remove-scroll-bar": ["react-remove-scroll-bar@2.3.8", "", { "dependencies": { "react-style-singleton": "^2.2.2", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" }, "optionalPeers": ["@types/react"] }, "sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q=="],
-
-    "react-resizable-panels": ["react-resizable-panels@4.12.3", "", { "peerDependencies": { "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" } }, "sha512-GHMJWnDXui/3RX4bT+cgBP+N3N2nkwcoZATr/2xLFpqQQe7TlBrE0cGM0dUa9ceT7A90tUrSRsiqgRG+g0/2AA=="],
-
-    "react-style-singleton": ["react-style-singleton@2.2.3", "", { "dependencies": { "get-nonce": "^1.0.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ=="],
-
     "readdirp": ["readdirp@5.1.1", "", {}, "sha512-Kko+Y5XQ6fM+Ce3dq3m9YGxnacYZYl9cA1wZjaF3Vbry2L3i1qVg8+CAgNPsXRArPMUMCaOR7oa9Nqntc43JKA=="],
 
     "recast": ["recast@0.23.21", "", { "dependencies": { "ast-types": "^0.16.1", "esprima": "~4.0.0", "source-map": "~0.6.1", "tiny-invariant": "^1.3.3", "tslib": "^2.0.1" } }, "sha512-mFAyJq9vUbSTARLZUvAEf1z3YxlvAwswbmxMx2mPA/MSm4KmpwvwvhsH/NIrZhyOuwD60Lzyw2qh83uCbgTPYw=="],
@@ -1374,10 +1310,6 @@
 
     "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="],
 
-    "use-callback-ref": ["use-callback-ref@1.3.3", "", { "dependencies": { "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg=="],
-
-    "use-sidecar": ["use-sidecar@1.1.3", "", { "dependencies": { "detect-node-es": "^1.1.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ=="],
-
     "use-sync-external-store": ["use-sync-external-store@1.6.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w=="],
 
     "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
diff --git a/spa/package.json b/spa/package.json
index 204e509..8d450af 100644
--- a/spa/package.json
+++ b/spa/package.json
@@ -15,7 +15,6 @@
   "dependencies": {
     "@base-ui/react": "^1.7.0",
     "@fontsource-variable/inter": "^5.3.0",
-    "@shadcn/react": "^0.3.0",
     "@tailwindcss/vite": "^4",
     "@tanstack/react-devtools": "latest",
     "@tanstack/react-query": "^5.102.3",
@@ -26,15 +25,11 @@
     "axios": "^1.19.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
-    "cmdk": "^1.1.1",
     "date-fns": "^4.4.0",
-    "embla-carousel-react": "^8.6.0",
-    "input-otp": "^1.5.0",
     "lucide-react": "^1.34.0",
     "react": "^19.2.6",
     "react-day-picker": "^10.0.1",
     "react-dom": "^19.2.6",
-    "react-resizable-panels": "^4.12.3",
     "recharts": "3.8.0",
     "shadcn": "^4.19.0",
     "tailwind-merge": "^3.6.0",
diff --git a/spa/public/sw.js b/spa/public/sw.js
index 95dff1d..c58f620 100644
--- a/spa/public/sw.js
+++ b/spa/public/sw.js
@@ -1,6 +1,17 @@
-const CACHE_NAME = "k-mood-v1"
+/*
+ * The app shell cache and push handling.
+ *
+ * A new worker deliberately does NOT take over on its own: assets are served
+ * cache-first, so swapping them under a running page can hand it chunks from
+ * two different builds. It waits until the page asks, which it does after
+ * telling the reader a new version is ready.
+ */
+
+const CACHE_NAME = "k-mood-v2"
+const APP_SHELL = "/"
+
 const STATIC_ASSETS = [
-  "/",
+  APP_SHELL,
   "/manifest.json",
   "/logo192.png",
   "/logo512.png",
@@ -11,7 +22,6 @@ self.addEventListener("install", (event) => {
   event.waitUntil(
     caches.open(CACHE_NAME).then((cache) => cache.addAll(STATIC_ASSETS))
   )
-  self.skipWaiting()
 })
 
 self.addEventListener("activate", (event) => {
@@ -20,66 +30,85 @@ self.addEventListener("activate", (event) => {
       .keys()
       .then((keys) =>
         Promise.all(
-          keys.filter((k) => k !== CACHE_NAME).map((k) => caches.delete(k))
+          keys.filter((key) => key !== CACHE_NAME).map((key) => caches.delete(key))
         )
       )
+      .then(() => self.clients.claim())
   )
-  self.clients.claim()
 })
 
+self.addEventListener("message", (event) => {
+  if (event.data?.type === "SKIP_WAITING") self.skipWaiting()
+})
+
+function cache(request, response) {
+  if (!response.ok) return response
+
+  const copy = response.clone()
+  caches
+    .open(CACHE_NAME)
+    .then((store) => store.put(request, copy))
+    .catch(() => {})
+
+  return response
+}
+
 self.addEventListener("fetch", (event) => {
-  const url = new URL(event.request.url)
+  const { request } = event
+  const url = new URL(request.url)
 
+  // The journal is never cached, wherever the server lives.
   if (url.pathname.startsWith("/api/")) return
+  if (request.method !== "GET") return
+  if (url.origin !== self.location.origin) return
 
-  if (event.request.mode === "navigate") {
+  if (request.mode === "navigate") {
     event.respondWith(
-      fetch(event.request)
-        .then((response) => {
-          const clone = response.clone()
-          caches
-            .open(CACHE_NAME)
-            .then((cache) => cache.put(event.request, clone))
-          return response
-        })
-        .catch(() => caches.match("/"))
+      fetch(request)
+        .then((response) => cache(request, response))
+        .catch(() => caches.match(APP_SHELL))
     )
     return
   }
 
   event.respondWith(
-    caches.match(event.request).then((cached) => {
-      const fetched = fetch(event.request).then((response) => {
-        const clone = response.clone()
-        caches.open(CACHE_NAME).then((cache) => cache.put(event.request, clone))
-        return response
-      })
-      return cached || fetched
+    caches.match(request).then((cached) => {
+      const fresh = fetch(request)
+        .then((response) => cache(request, response))
+        .catch(() => cached)
+
+      return cached ?? fresh
     })
   )
 })
 
 self.addEventListener("push", (event) => {
   const data = event.data?.json() ?? {}
-  const title = data.title || "K-Mood"
-  const options = {
-    body: data.body || "How are you feeling?",
-    icon: "/logo192.png",
-    badge: "/logo192.png",
-    data: { url: data.url || "/" },
-  }
-  event.waitUntil(self.registration.showNotification(title, options))
+
+  event.waitUntil(
+    self.registration.showNotification(data.title || "K-Mood", {
+      body: data.body || "How are you feeling?",
+      icon: "/logo192.png",
+      badge: "/logo192.png",
+      data: { url: data.url || APP_SHELL },
+    })
+  )
 })
 
 self.addEventListener("notificationclick", (event) => {
   event.notification.close()
-  const url = event.notification.data?.url || "/"
+  const target = event.notification.data?.url || APP_SHELL
+
   event.waitUntil(
-    clients.matchAll({ type: "window" }).then((windowClients) => {
-      for (const client of windowClients) {
-        if (client.url.includes(url) && "focus" in client) return client.focus()
-      }
-      return clients.openWindow(url)
-    })
+    self.clients
+      .matchAll({ type: "window", includeUncontrolled: true })
+      .then((windows) => {
+        for (const client of windows) {
+          if (client.url.includes(target) && "focus" in client) {
+            return client.focus()
+          }
+        }
+        return self.clients.openWindow(target)
+      })
   )
 })
diff --git a/spa/src/aero-theme.css b/spa/src/aero-theme.css
index 9ac8f07..ee0ae11 100644
--- a/spa/src/aero-theme.css
+++ b/spa/src/aero-theme.css
@@ -6,24 +6,30 @@
 
 /* ── Aero color overrides ─────────────────────────────────────── */
 
-:root {
+/*
+ * One palette, under both selectors. shadcn ships a `.dark` block of its own;
+ * naming it here means it never wins, and there is only one place a colour is
+ * written down. This theme does not have a second mode to switch to.
+ */
+:root,
+.dark {
   --background: transparent;
   --foreground: oklch(0.985 0 0);
-  --card: rgba(255, 255, 255, 0.08);
+  --card: rgba(18, 22, 34, 0.55);
   --card-foreground: oklch(0.985 0 0);
   --popover: rgba(20, 20, 30, 0.85);
   --popover-foreground: oklch(0.985 0 0);
   --primary: oklch(0.852 0.199 91.936);
   --primary-foreground: #fff;
-  --secondary: rgba(255, 255, 255, 0.08);
+  --secondary: rgba(255, 255, 255, 0.12);
   --secondary-foreground: oklch(0.985 0 0);
-  --muted: rgba(255, 255, 255, 0.06);
-  --muted-foreground: rgba(255, 255, 255, 0.6);
+  --muted: rgba(255, 255, 255, 0.1);
+  --muted-foreground: rgba(255, 255, 255, 0.85);
   --accent: rgba(255, 255, 255, 0.1);
   --accent-foreground: oklch(0.985 0 0);
-  --destructive: rgba(200, 60, 60, 0.65);
-  --border: rgba(255, 255, 255, 0.15);
-  --input: rgba(255, 255, 255, 0.1);
+  --destructive: rgba(226, 88, 88, 0.85);
+  --border: rgba(255, 255, 255, 0.22);
+  --input: rgba(255, 255, 255, 0.14);
   --ring: oklch(0.852 0.199 91.936 / 0.4);
   --chart-1: oklch(0.852 0.199 91.936);
   --chart-2: oklch(0.89 0.13 91.936);
@@ -43,46 +49,24 @@
   --aero-primary-mid: oklch(0.89 0.13 91.936);
   --aero-primary-light: oklch(0.93 0.07 91.936);
   --aero-primary-glow: oklch(0.852 0.199 91.936 / 0.3);
-  --aero-glass-bg: rgba(255, 255, 255, 0.12);
-  --aero-glass-border: rgba(255, 255, 255, 0.2);
+  /*
+   * Dark-tinted glass. White text over white glass measured ~1.4:1 against the
+   * bright parts of the photo behind it; a dark ground puts it above 7:1
+   * without touching the background or losing the blur.
+   */
+  --aero-glass-bg: rgba(18, 22, 34, 0.55);
+  --aero-glass-border: rgba(255, 255, 255, 0.22);
   --aero-glass-shadow: 0 8px 32px oklch(0.852 0.199 91.936 / 0.1);
   --aero-glass-inset: inset 0 1px 0 rgba(255, 255, 255, 0.4);
   --aero-blur: 12px;
-}
 
-/* Force dark — override any .dark block from shadcn defaults */
-.dark {
-  --background: transparent;
-  --foreground: oklch(0.985 0 0);
-  --card: rgba(255, 255, 255, 0.08);
-  --card-foreground: oklch(0.985 0 0);
-  --popover: rgba(20, 20, 30, 0.85);
-  --popover-foreground: oklch(0.985 0 0);
-  --primary: oklch(0.852 0.199 91.936);
-  --primary-foreground: #fff;
-  --secondary: rgba(255, 255, 255, 0.08);
-  --secondary-foreground: oklch(0.985 0 0);
-  --muted: rgba(255, 255, 255, 0.06);
-  --muted-foreground: rgba(255, 255, 255, 0.6);
-  --accent: rgba(255, 255, 255, 0.1);
-  --accent-foreground: oklch(0.985 0 0);
-  --destructive: rgba(200, 60, 60, 0.65);
-  --border: rgba(255, 255, 255, 0.15);
-  --input: rgba(255, 255, 255, 0.1);
-  --ring: oklch(0.852 0.199 91.936 / 0.4);
-  --chart-1: oklch(0.852 0.199 91.936);
-  --chart-2: oklch(0.89 0.13 91.936);
-  --chart-3: oklch(0.93 0.07 91.936);
-  --chart-4: rgba(255, 255, 255, 0.4);
-  --chart-5: rgba(255, 255, 255, 0.2);
-  --sidebar: rgba(0, 0, 0, 0.4);
-  --sidebar-foreground: oklch(0.985 0 0);
-  --sidebar-primary: oklch(0.852 0.199 91.936);
-  --sidebar-primary-foreground: #fff;
-  --sidebar-accent: rgba(255, 255, 255, 0.1);
-  --sidebar-accent-foreground: oklch(0.985 0 0);
-  --sidebar-border: rgba(255, 255, 255, 0.1);
-  --sidebar-ring: oklch(0.852 0.199 91.936 / 0.4);
+  /*
+   * The reading column gets a little more veil than the rest of the page, so
+   * headings and captions that sit outside a card stay legible over the
+   * brightest parts of the photo. On a wide screen the margins keep the
+   * lighter scrim, and the background stays as bright as it was.
+   */
+  --aero-column-veil: rgba(0, 0, 0, 0.35);
 }
 
 /* ── Background treatment ─────────────────────────────────────── */
@@ -95,7 +79,7 @@ body::before {
   content: "";
   position: fixed;
   inset: 0;
-  background: rgba(0, 0, 0, 0.25);
+  background: rgba(0, 0, 0, 0.4);
   z-index: 0;
   pointer-events: none;
 }
@@ -107,69 +91,8 @@ body > #root {
 
 /* ── Utility classes ──────────────────────────────────────────── */
 
-@utility glass {
-  backdrop-filter: blur(var(--aero-blur));
-  -webkit-backdrop-filter: blur(var(--aero-blur));
-  background: var(--aero-glass-bg);
-  border: 1px solid var(--aero-glass-border);
-}
-
-@utility glass-card {
-  backdrop-filter: blur(var(--aero-blur));
-  -webkit-backdrop-filter: blur(var(--aero-blur));
-  background: var(--aero-glass-bg);
-  border: 1px solid var(--aero-glass-border);
-  box-shadow: var(--aero-glass-shadow), var(--aero-glass-inset);
-  position: relative;
-  overflow: hidden;
-}
-
-@utility glass-heavy {
-  backdrop-filter: blur(var(--aero-blur));
-  -webkit-backdrop-filter: blur(var(--aero-blur));
-  background: rgba(0, 0, 0, 0.55);
-  border: 1px solid rgba(255, 255, 255, 0.1);
-}
-
-@utility aero-glow {
-  text-shadow:
-    0 0 8px var(--aero-primary-glow),
-    0 0 2px var(--aero-primary);
-}
-
-@utility aero-pill {
-  border-radius: 999px;
-  border: 1px solid var(--aero-glass-border);
-  background: transparent;
-}
-
-/* ── Glass card gradient overlay ──────────────────────────────── */
-
-.glass-card::before {
-  content: "";
-  position: absolute;
-  top: 0;
-  left: 0;
-  right: 0;
-  height: 50%;
-  background: linear-gradient(to bottom, rgba(255, 255, 255, 0.1), transparent);
-  border-radius: inherit;
-  pointer-events: none;
-  z-index: 1;
-}
-
-/* ── Hover lift (pointer devices only) ────────────────────────── */
-
-@media (hover: hover) {
-  .aero-lift {
-    transition: transform 0.2s, box-shadow 0.2s;
-  }
-  .aero-lift:hover {
-    transform: translateY(-2px);
-    box-shadow:
-      0 12px 40px var(--aero-primary-glow),
-      var(--aero-glass-inset);
-  }
+@utility app-column {
+  background: var(--aero-column-veil);
 }
 
 /* ── shadcn data-slot overrides ───────────────────────────────── */
@@ -199,21 +122,8 @@ body > #root {
   --tw-ring-shadow: none;
 }
 
-[data-slot="sheet-overlay"] {
-  background: rgba(0, 0, 0, 0.4);
-  backdrop-filter: blur(8px);
-  -webkit-backdrop-filter: blur(8px);
-}
-
-[data-slot="sheet-content"] {
-  background: rgba(20, 20, 30, 0.85);
-  backdrop-filter: blur(var(--aero-blur));
-  -webkit-backdrop-filter: blur(var(--aero-blur));
-  border-color: rgba(255, 255, 255, 0.15);
-}
-
 [data-slot="input"] {
-  background: rgba(255, 255, 255, 0.08);
+  background: rgba(255, 255, 255, 0.12);
   border-color: var(--aero-glass-border);
 }
 
@@ -246,7 +156,11 @@ body > #root {
   left: 0;
   right: 0;
   height: 50%;
-  background: linear-gradient(to bottom, rgba(255, 255, 255, 0.25), transparent);
+  background: linear-gradient(
+    to bottom,
+    rgba(255, 255, 255, 0.25),
+    transparent
+  );
   border-radius: inherit;
   pointer-events: none;
 }
@@ -262,7 +176,7 @@ body > #root {
 
 /* Destructive button — glassmorphic red */
 [data-slot="button"][data-variant="destructive"] {
-  background: rgba(200, 60, 60, 0.65);
+  background: rgba(190, 55, 55, 0.8);
   backdrop-filter: blur(4px);
   -webkit-backdrop-filter: blur(4px);
   border: 1px solid rgba(220, 80, 80, 0.3);
@@ -286,72 +200,3 @@ body > #root {
   backdrop-filter: blur(8px);
   -webkit-backdrop-filter: blur(8px);
 }
-
-/* Sonner toast */
-[data-sonner-toaster] [data-sonner-toast] {
-  background: rgba(20, 20, 30, 0.85);
-  backdrop-filter: blur(var(--aero-blur));
-  -webkit-backdrop-filter: blur(var(--aero-blur));
-  border-color: rgba(255, 255, 255, 0.15);
-  color: oklch(0.985 0 0);
-}
-
-/* Chart label readability */
-[data-slot="chart"] .recharts-cartesian-axis-tick text {
-  fill: rgba(255, 255, 255, 0.85) !important;
-}
-
-/* Tooltip — default shadcn uses bg-foreground which is white in this theme */
-[data-slot="tooltip-content"] {
-  background: var(--popover);
-  color: var(--popover-foreground);
-  backdrop-filter: blur(var(--aero-blur));
-  -webkit-backdrop-filter: blur(var(--aero-blur));
-  border: 1px solid rgba(255, 255, 255, 0.15);
-}
-
-[data-slot="tooltip-content"] .lucide,
-[data-slot="tooltip-content"] [data-slot="tooltip-arrow"] {
-  color: var(--popover-foreground);
-}
-
-/* Context menu */
-[data-slot="context-menu-content"] {
-  background: var(--popover);
-  backdrop-filter: blur(var(--aero-blur));
-  -webkit-backdrop-filter: blur(var(--aero-blur));
-  border-color: rgba(255, 255, 255, 0.15);
-}
-
-/* Star glow for filled amber stars */
-.aero-star-filled {
-  filter: drop-shadow(0 0 4px var(--aero-primary-glow)) drop-shadow(0 0 1px var(--aero-primary));
-}
-
-/* ── Keyframe animations ────────────────────────────────────── */
-
-@media (prefers-reduced-motion: no-preference) {
-  @keyframes aero-page-in {
-    from { opacity: 0; transform: translateY(8px); }
-    to { opacity: 1; transform: translateY(0); }
-  }
-  .aero-page-in {
-    animation: aero-page-in 0.25s ease-out both;
-  }
-
-  @keyframes aero-star-pop {
-    0% { transform: scale(1); }
-    40% { transform: scale(1.35); }
-    100% { transform: scale(1); }
-  }
-  .aero-star-pop {
-    animation: aero-star-pop 0.3s cubic-bezier(0.34, 1.56, 0.64, 1) both;
-  }
-
-  .aero-poster-hover {
-    transition: transform 0.2s ease-out;
-  }
-  .aero-poster-hover:hover {
-    transform: scale(1.04);
-  }
-}
diff --git a/spa/src/api/client.ts b/spa/src/api/client.ts
index 4ca5d75..3342196 100644
--- a/spa/src/api/client.ts
+++ b/spa/src/api/client.ts
@@ -1,9 +1,11 @@
 import axios, { AxiosError } from "axios"
+import type { InternalAxiosRequestConfig } from "axios"
 import type { z } from "zod/v4"
 import {
   ActivityResponse,
-  ApiErrorResponse,
-  AuthTokenResponse,
+  ErrorResponse,
+  RefreshedResponse,
+  SignedInResponse,
   BulkActionResponse,
   CalendarDayResponse,
   EntryResponse,
@@ -20,13 +22,23 @@ import {
   CycleViewResponse,
   PreferencesResponse,
   ApiTokenResponse,
+  EntryPageResponse,
   MintedApiTokenResponse,
+  ServerInfoResponse,
   CorrelationRowResponse,
   DimensionPayload,
 } from "./schema"
+import { serverUrl } from "./server-url"
+import {
+  accessToken,
+  forgetSession,
+  refreshToken as storedRefreshToken,
+  rememberSession,
+} from "./session"
 import type {
   ChangePasswordRequest,
   CreateActivityRequest,
+  CreateEntriesRequest,
   CreateEntryRequest,
   DateSpanParams,
   MetricPayload,
@@ -35,6 +47,7 @@ import type {
   DateRangeParams,
   ListEntriesParams,
   LoginRequest,
+  MintApiTokenRequest,
   RegisterRequest,
   RenameActivityRequest,
   ReplaceActivityRequest,
@@ -45,21 +58,30 @@ import type {
 } from "./schema"
 
 const api = axios.create({
-  baseURL: import.meta.env.VITE_API_URL ?? "",
+  baseURL: serverUrl(),
 })
 
 api.interceptors.request.use((config) => {
-  const token = localStorage.getItem("accessToken")
+  const token = accessToken()
   if (token) {
     config.headers.Authorization = `Bearer ${token}`
   }
   return config
 })
 
+/**
+ * A request that has already been retried once after a refresh. Without this
+ * mark, a token that refreshes cleanly but still fails authorisation would
+ * refresh and retry forever.
+ */
+type RetriableConfig = InternalAxiosRequestConfig & {
+  retriedAfterRefresh?: true
+}
+
 let refreshPromise: Promise<boolean> | null = null
 
 async function tryRefreshToken(): Promise<boolean> {
-  const refreshToken = localStorage.getItem("refreshToken")
+  const refreshToken = storedRefreshToken()
   if (!refreshToken) return false
 
   try {
@@ -67,18 +89,25 @@ async function tryRefreshToken(): Promise<boolean> {
       `${api.defaults.baseURL}/api/v1/auth/refresh`,
       { refreshToken }
     )
-    const parsed = AuthTokenResponse.parse(data)
-    localStorage.setItem("accessToken", parsed.accessToken)
-    localStorage.setItem("refreshToken", parsed.refreshToken)
+    rememberSession(RefreshedResponse.parse(data))
     return true
   } catch {
     return false
   }
 }
 
+function abandonSession(): void {
+  forgetSession()
+  window.location.href = "/login"
+}
+
 api.interceptors.response.use(undefined, async (error: AxiosError) => {
-  const original = error.config
+  const original = error.config as RetriableConfig | undefined
   if (error.response?.status !== 401 || !original) throw error
+  if (original.retriedAfterRefresh) {
+    abandonSession()
+    throw error
+  }
 
   if (!refreshPromise) {
     refreshPromise = tryRefreshToken().finally(() => {
@@ -88,12 +117,11 @@ api.interceptors.response.use(undefined, async (error: AxiosError) => {
 
   const refreshed = await refreshPromise
   if (!refreshed) {
-    localStorage.removeItem("accessToken")
-    localStorage.removeItem("refreshToken")
-    window.location.href = "/login"
-    return Promise.reject(error)
+    abandonSession()
+    throw error
   }
 
+  original.retriedAfterRefresh = true
   return api(original)
 })
 
@@ -110,7 +138,7 @@ class ApiError extends Error {
 
 function handleError(err: unknown): never {
   if (err instanceof AxiosError && err.response) {
-    const parsed = ApiErrorResponse.safeParse(err.response.data)
+    const parsed = ErrorResponse.safeParse(err.response.data)
     throw new ApiError(
       err.response.status,
       parsed.success ? parsed.data.error.code : "UNKNOWN",
@@ -168,13 +196,13 @@ async function uploadForm<T>(
 
 export const auth = {
   login: (body: LoginRequest) =>
-    request("post", "/api/v1/auth/login", AuthTokenResponse, body),
+    request("post", "/api/v1/auth/login", SignedInResponse, body),
 
   register: (body: RegisterRequest) =>
     request("post", "/api/v1/users/register", UserResponse, body),
 
   refresh: (refreshToken: string) =>
-    request("post", "/api/v1/auth/refresh", AuthTokenResponse, {
+    request("post", "/api/v1/auth/refresh", RefreshedResponse, {
       refreshToken,
     }),
 
@@ -222,11 +250,15 @@ export const cycle = {
 
 // ── API tokens ──────────────────────────────────────────────────
 
+export const server = {
+  info: () => request("get", "/api/v1/server", ServerInfoResponse),
+}
+
 export const tokens = {
   list: () => request("get", "/api/v1/tokens", ApiTokenResponse.array()),
 
-  mint: (name: string) =>
-    request("post", "/api/v1/tokens", MintedApiTokenResponse, { name }),
+  mint: (body: MintApiTokenRequest) =>
+    request("post", "/api/v1/tokens", MintedApiTokenResponse, body),
 
   revoke: (id: string) => requestVoid("delete", `/api/v1/tokens/${id}`),
 }
@@ -267,7 +299,10 @@ export const metrics = {
 
 export const entries = {
   list: (params?: ListEntriesParams) =>
-    request("get", "/api/v1/entries", EntryResponse.array(), undefined, params),
+    request("get", "/api/v1/entries", EntryPageResponse, undefined, params),
+
+  createMany: (body: CreateEntriesRequest) =>
+    request("post", "/api/v1/entries/bulk", EntryResponse.array(), body),
 
   get: (id: string) => request("get", `/api/v1/entries/${id}`, EntryResponse),
 
@@ -313,20 +348,6 @@ export const entries = {
       undefined,
       params
     ),
-
-  filterByMood: (mood: number) =>
-    request(
-      "get",
-      `/api/v1/entries/filter/mood/${mood}`,
-      EntryResponse.array()
-    ),
-
-  filterByActivity: (activityId: string) =>
-    request(
-      "get",
-      `/api/v1/entries/filter/activity/${activityId}`,
-      EntryResponse.array()
-    ),
 }
 
 // ── Activities ──────────────────────────────────────────────────
diff --git a/spa/src/api/schema.ts b/spa/src/api/schema.ts
index 80ffc13..92c3d9d 100644
--- a/spa/src/api/schema.ts
+++ b/spa/src/api/schema.ts
@@ -81,18 +81,20 @@ export const CalendarDayResponse = z.object({
 })
 export type CalendarDayResponse = z.infer<typeof CalendarDayResponse>
 
-export const MoodFrequency = z.object({
+export const MoodFrequencyResponse = z.object({
   mood: Mood,
   moodLabel: z.string(),
   count: z.number(),
 })
-export type MoodFrequency = z.infer<typeof MoodFrequency>
+export type MoodFrequencyResponse = z.infer<typeof MoodFrequencyResponse>
 
 export const MoodStatsResponse = z.object({
   average: z.number().nullable(),
-  frequency: z.array(MoodFrequency),
+  frequency: z.array(MoodFrequencyResponse),
   currentStreak: z.number(),
   totalEntries: z.number(),
+  firstLoggedOn: z.string().nullable(),
+  lastLoggedOn: z.string().nullable(),
 })
 export type MoodStatsResponse = z.infer<typeof MoodStatsResponse>
 
@@ -143,21 +145,25 @@ export const MediaIdResponse = z.object({
 })
 export type MediaIdResponse = z.infer<typeof MediaIdResponse>
 
-export const AuthTokenResponse = z.object({
+export const RefreshedResponse = z.object({
   accessToken: z.string(),
   refreshToken: z.string(),
   expiresAt: datetime,
-  user: UserResponse.optional(),
 })
-export type AuthTokenResponse = z.infer<typeof AuthTokenResponse>
+export type RefreshedResponse = z.infer<typeof RefreshedResponse>
 
-export const ApiErrorResponse = z.object({
+export const SignedInResponse = RefreshedResponse.extend({
+  user: UserResponse,
+})
+export type SignedInResponse = z.infer<typeof SignedInResponse>
+
+export const ErrorResponse = z.object({
   error: z.object({
     code: z.string(),
     message: z.string(),
   }),
 })
-export type ApiErrorResponse = z.infer<typeof ApiErrorResponse>
+export type ErrorResponse = z.infer<typeof ErrorResponse>
 
 export const VapidKeyResponse = z.object({
   publicKey: z.string(),
@@ -249,6 +255,9 @@ export type ChangePasswordRequest = z.infer<typeof ChangePasswordRequest>
 export const ListEntriesParams = z.object({
   from: z.string().optional(),
   to: z.string().optional(),
+  mood: z.number().int().optional(),
+  activity: z.string().optional(),
+  updatedSince: z.string().optional(),
   limit: z.number().int().optional(),
   offset: z.number().int().optional(),
 })
@@ -337,10 +346,18 @@ export const CorrelationRowResponse = z.object({
 })
 export type CorrelationRowResponse = z.infer<typeof CorrelationRowResponse>
 
+export const TokenScope = z.enum([
+  "readJournal",
+  "writeJournal",
+  "writeMetrics",
+  "readProfile",
+])
+export type TokenScope = z.infer<typeof TokenScope>
+
 export const ApiTokenResponse = z.object({
   id: uuid,
   name: z.string(),
-  scope: z.string(),
+  scopes: z.array(TokenScope),
   createdAt: datetime,
   lastUsedAt: datetime.nullable(),
 })
@@ -354,6 +371,7 @@ export type MintedApiTokenResponse = z.infer<typeof MintedApiTokenResponse>
 
 export const MintApiTokenRequest = z.object({
   name: z.string(),
+  scopes: z.array(TokenScope),
 })
 export type MintApiTokenRequest = z.infer<typeof MintApiTokenRequest>
 
@@ -395,6 +413,7 @@ export const RestoreOutcomeResponse = z.object({
   activities: z.int(),
   reminders: z.int(),
   media: z.int(),
+  skipped: z.int(),
   unreadable: z.array(z.string()),
 })
 export type RestoreOutcomeResponse = z.infer<typeof RestoreOutcomeResponse>
@@ -405,3 +424,51 @@ export const SubsonicCredential = z.object({
   password: z.string(),
 })
 export type SubsonicCredential = z.infer<typeof SubsonicCredential>
+
+export const CreateEntriesRequest = z.object({
+  entries: z.array(CreateEntryRequest),
+})
+export type CreateEntriesRequest = z.infer<typeof CreateEntriesRequest>
+
+export const EntryPageResponse = z.object({
+  items: z.array(EntryResponse),
+  total: z.int(),
+  limit: z.int(),
+  offset: z.int(),
+  hasMore: z.boolean(),
+})
+export type EntryPageResponse = z.infer<typeof EntryPageResponse>
+
+export const ServerLimitsResponse = z.object({
+  maxBodySize: z.int(),
+  maxContentLength: z.int(),
+  maxPhotos: z.int(),
+  maxVoiceMemos: z.int(),
+  maxActivitiesPerEntry: z.int(),
+  maxEntriesPerPage: z.int(),
+  maxImportDays: z.int(),
+})
+export type ServerLimitsResponse = z.infer<typeof ServerLimitsResponse>
+
+export const MetricKindResponse = z.object({
+  name: z.string(),
+  unit: z.string(),
+  minimum: z.int(),
+  maximum: z.int(),
+})
+export type MetricKindResponse = z.infer<typeof MetricKindResponse>
+
+export const ServerInfoResponse = z.object({
+  version: z.string(),
+  registrationOpen: z.boolean(),
+  pushEnabled: z.boolean(),
+  weatherEnabled: z.boolean(),
+  nowPlayingProvider: z.string().nullable(),
+  accessTokenTtlSeconds: z.int(),
+  limits: ServerLimitsResponse,
+  tokenScopes: z.array(z.object({ name: TokenScope, describes: z.string() })),
+  metricKinds: z.array(MetricKindResponse),
+  moods: z.array(z.object({ value: z.int(), label: z.string() })),
+  weatherConditions: z.array(z.string()),
+})
+export type ServerInfoResponse = z.infer<typeof ServerInfoResponse>
diff --git a/spa/src/api/server-url.ts b/spa/src/api/server-url.ts
new file mode 100644
index 0000000..a61ac4b
--- /dev/null
+++ b/spa/src/api/server-url.ts
@@ -0,0 +1,56 @@
+const CHOSEN_SERVER = "serverUrl"
+
+const BUILT_IN = import.meta.env.VITE_API_URL ?? ""
+
+export function serverUrl(): string {
+  try {
+    return localStorage.getItem(CHOSEN_SERVER) ?? BUILT_IN
+  } catch {
+    return BUILT_IN
+  }
+}
+
+export function isServerChosen(): boolean {
+  try {
+    return localStorage.getItem(CHOSEN_SERVER) !== null
+  } catch {
+    return false
+  }
+}
+
+export function tidyServerUrl(typed: string): string {
+  return typed.trim().replace(/\/+$/, "")
+}
+
+export function looksLikeAServer(typed: string): boolean {
+  const tidied = tidyServerUrl(typed)
+  if (!tidied) return false
+
+  try {
+    const parsed = new URL(tidied)
+
+    return parsed.protocol === "http:" || parsed.protocol === "https:"
+  } catch {
+    return false
+  }
+}
+
+export async function reachable(typed: string): Promise<boolean> {
+  try {
+    const response = await fetch(`${tidyServerUrl(typed)}/api/v1/server`)
+
+    return response.ok
+  } catch {
+    return false
+  }
+}
+
+export function rememberServer(typed: string) {
+  localStorage.setItem(CHOSEN_SERVER, tidyServerUrl(typed))
+  window.location.reload()
+}
+
+export function forgetServer() {
+  localStorage.removeItem(CHOSEN_SERVER)
+  window.location.reload()
+}
diff --git a/spa/src/api/session.ts b/spa/src/api/session.ts
new file mode 100644
index 0000000..b52f2f9
--- /dev/null
+++ b/spa/src/api/session.ts
@@ -0,0 +1,45 @@
+const ACCESS_TOKEN_KEY = "accessToken"
+const REFRESH_TOKEN_KEY = "refreshToken"
+
+export interface SessionTokens {
+  accessToken: string
+  refreshToken: string
+}
+
+function read(key: string): string | null {
+  try {
+    return localStorage.getItem(key)
+  } catch {
+    return null
+  }
+}
+
+export function accessToken(): string | null {
+  return read(ACCESS_TOKEN_KEY)
+}
+
+export function refreshToken(): string | null {
+  return read(REFRESH_TOKEN_KEY)
+}
+
+export function hasSession(): boolean {
+  return accessToken() !== null
+}
+
+export function rememberSession(tokens: SessionTokens): void {
+  try {
+    localStorage.setItem(ACCESS_TOKEN_KEY, tokens.accessToken)
+    localStorage.setItem(REFRESH_TOKEN_KEY, tokens.refreshToken)
+  } catch {
+    // A browser refusing storage leaves the session in memory only.
+  }
+}
+
+export function forgetSession(): void {
+  try {
+    localStorage.removeItem(ACCESS_TOKEN_KEY)
+    localStorage.removeItem(REFRESH_TOKEN_KEY)
+  } catch {
+    // Nothing to forget if storage is unavailable.
+  }
+}
diff --git a/spa/src/components/activity/activity-picker.tsx b/spa/src/components/activity/activity-picker.tsx
index e1cfa50..8a970d4 100644
--- a/spa/src/components/activity/activity-picker.tsx
+++ b/spa/src/components/activity/activity-picker.tsx
@@ -1,5 +1,5 @@
-import { Badge } from "@/components/ui/badge"
 import { cn } from "@/lib/utils"
+import { groupByCategory } from "@/lib/activity-groups"
 import type { ActivityResponse } from "@/api/schema"
 
 interface ActivityPickerProps {
@@ -13,52 +13,39 @@ export function ActivityPicker({
   selected,
   onToggle,
 }: ActivityPickerProps) {
-  const grouped = groupByCategory(activities)
-
   return (
     <div className="flex flex-col gap-3">
-      {grouped.map(({ category, items }) => (
-        <div key={category}>
-          <p className="mb-1.5 text-xs font-medium tracking-wide text-muted-foreground uppercase">
+      {groupByCategory(activities).map(({ category, items }) => (
+        <fieldset key={category}>
+          <legend className="mb-1.5 text-xs font-medium tracking-wide text-muted-foreground uppercase">
             {category}
-          </p>
+          </legend>
           <div className="flex flex-wrap gap-2">
-            {items.map((activity) => (
-              <Badge
-                key={activity.id}
-                variant={selected.includes(activity.id) ? "default" : "outline"}
-                className={cn(
-                  "cursor-pointer transition-colors",
-                  selected.includes(activity.id) && "bg-primary"
-                )}
-                onClick={() => onToggle(activity.id)}
-              >
-                {activity.name}
-              </Badge>
-            ))}
+            {items.map((activity) => {
+              const isSelected = selected.includes(activity.id)
+
+              return (
+                <button
+                  key={activity.id}
+                  type="button"
+                  role="checkbox"
+                  aria-checked={isSelected}
+                  onClick={() => onToggle(activity.id)}
+                  className={cn(
+                    "rounded-full border px-2.5 py-1 text-xs transition-colors",
+                    "focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none",
+                    isSelected
+                      ? "border-primary bg-primary text-primary-foreground"
+                      : "border-border text-muted-foreground hover:text-foreground"
+                  )}
+                >
+                  {activity.name}
+                </button>
+              )
+            })}
           </div>
-        </div>
+        </fieldset>
       ))}
     </div>
   )
 }
-
-function groupByCategory(
-  activities: ActivityResponse[]
-): Array<{ category: string; items: ActivityResponse[] }> {
-  const map = new Map<string, ActivityResponse[]>()
-
-  for (const a of activities) {
-    const cat = a.category ?? "Other"
-    if (!map.has(cat)) map.set(cat, [])
-    map.get(cat)!.push(a)
-  }
-
-  return Array.from(map.entries())
-    .sort(([a], [b]) => {
-      if (a === "Other") return 1
-      if (b === "Other") return -1
-      return a.localeCompare(b)
-    })
-    .map(([category, items]) => ({ category, items }))
-}
diff --git a/spa/src/components/auth/auth-card.tsx b/spa/src/components/auth/auth-card.tsx
new file mode 100644
index 0000000..43766d9
--- /dev/null
+++ b/spa/src/components/auth/auth-card.tsx
@@ -0,0 +1,24 @@
+import type { ReactNode } from "react"
+import { Card, CardContent, CardHeader } from "@/components/ui/card"
+
+interface AuthCardProps {
+  title: string
+  subtitle?: string
+  children: ReactNode
+}
+
+export function AuthCard({ title, subtitle, children }: AuthCardProps) {
+  return (
+    <main className="flex min-h-svh items-center justify-center p-4">
+      <Card className="w-full max-w-sm">
+        <CardHeader className="text-center">
+          <h1 className="text-2xl font-bold">{title}</h1>
+          {subtitle && (
+            <p className="text-sm text-muted-foreground">{subtitle}</p>
+          )}
+        </CardHeader>
+        <CardContent>{children}</CardContent>
+      </Card>
+    </main>
+  )
+}
diff --git a/spa/src/components/auth/form-error.tsx b/spa/src/components/auth/form-error.tsx
new file mode 100644
index 0000000..d28207b
--- /dev/null
+++ b/spa/src/components/auth/form-error.tsx
@@ -0,0 +1,11 @@
+import { messageFor } from "@/lib/api-message"
+
+export function FormError({ error }: { error: unknown }) {
+  if (!error) return null
+
+  return (
+    <p role="alert" className="text-sm text-destructive">
+      {messageFor(error)}
+    </p>
+  )
+}
diff --git a/spa/src/components/auth/password-strength.tsx b/spa/src/components/auth/password-strength.tsx
new file mode 100644
index 0000000..8c1799a
--- /dev/null
+++ b/spa/src/components/auth/password-strength.tsx
@@ -0,0 +1,60 @@
+import { cn } from "@/lib/utils"
+
+/**
+ * The server accepts any password, so this is guidance rather than a rule it
+ * will enforce — but a journal is worth a password that is not "abc".
+ */
+const SHORTEST_SENSIBLE = 10
+
+interface Requirement {
+  describes: string
+  met: (password: string) => boolean
+}
+
+const REQUIREMENTS: Requirement[] = [
+  {
+    describes: `at least ${SHORTEST_SENSIBLE} characters`,
+    met: (password) => password.length >= SHORTEST_SENSIBLE,
+  },
+  {
+    describes: "a letter and a digit, or a long passphrase",
+    met: (password) =>
+      (/\p{L}/u.test(password) && /\d/.test(password)) || password.length >= 20,
+  },
+]
+
+export function isStrongEnough(password: string): boolean {
+  return REQUIREMENTS.every((requirement) => requirement.met(password))
+}
+
+export function PasswordStrength({ password }: { password: string }) {
+  if (!password) {
+    return (
+      <p id="password-strength" className="text-xs text-muted-foreground">
+        Use {SHORTEST_SENSIBLE} characters or more.
+      </p>
+    )
+  }
+
+  return (
+    <ul id="password-strength" className="flex list-none flex-col gap-0.5 p-0">
+      {REQUIREMENTS.map((requirement) => {
+        const met = requirement.met(password)
+
+        return (
+          <li
+            key={requirement.describes}
+            className={cn(
+              "text-xs",
+              met ? "text-muted-foreground" : "text-destructive"
+            )}
+          >
+            <span aria-hidden="true">{met ? "✓" : "•"}</span>{" "}
+            {requirement.describes}
+            <span className="sr-only">{met ? " — met" : " — not yet met"}</span>
+          </li>
+        )
+      })}
+    </ul>
+  )
+}
diff --git a/spa/src/components/dashboard/metrics-card.tsx b/spa/src/components/dashboard/metrics-card.tsx
new file mode 100644
index 0000000..d4bc776
--- /dev/null
+++ b/spa/src/components/dashboard/metrics-card.tsx
@@ -0,0 +1,64 @@
+import { Link } from "@tanstack/react-router"
+import { ChevronRight } from "lucide-react"
+import { Card, CardContent } from "@/components/ui/card"
+import { METRIC_FIELDS } from "@/components/metric/metric-fields"
+import { byKind, useDailyMetrics, useTracksMetrics } from "@/hooks/use-metrics"
+import { today } from "@/lib/day"
+
+const MOST_SHOWN = 3
+
+/** Today's readings, for accounts that record them. */
+export function MetricsCard() {
+  const day = today()
+  const tracks = useTracksMetrics()
+  const { data } = useDailyMetrics(day, day)
+  const recorded = byKind(data)
+
+  if (!tracks) return null
+
+  const shown = METRIC_FIELDS.filter((field) => recorded.has(field.kind)).slice(
+    0,
+    MOST_SHOWN
+  )
+
+  return (
+    <Link to="/metrics" aria-label="Daily metrics">
+      <Card>
+        <CardContent className="flex items-center justify-between gap-3 py-4">
+          {shown.length ? (
+            <div className="flex flex-1 items-center justify-around">
+              {shown.map((field) => {
+                const Icon = field.icon
+                return (
+                  <div
+                    key={field.kind}
+                    className="flex flex-col items-center gap-1"
+                  >
+                    <Icon
+                      className="h-4 w-4 text-muted-foreground"
+                      aria-hidden="true"
+                    />
+                    <span className="text-sm font-semibold tabular-nums">
+                      {recorded.get(field.kind)?.value.toLocaleString()}
+                    </span>
+                    <span className="text-[10px] text-muted-foreground">
+                      {field.label}
+                    </span>
+                  </div>
+                )
+              })}
+            </div>
+          ) : (
+            <span className="text-sm text-muted-foreground">
+              No readings today
+            </span>
+          )}
+          <ChevronRight
+            className="h-4 w-4 shrink-0 text-muted-foreground"
+            aria-hidden="true"
+          />
+        </CardContent>
+      </Card>
+    </Link>
+  )
+}
diff --git a/spa/src/components/dashboard/setup-card.tsx b/spa/src/components/dashboard/setup-card.tsx
new file mode 100644
index 0000000..50db8ce
--- /dev/null
+++ b/spa/src/components/dashboard/setup-card.tsx
@@ -0,0 +1,84 @@
+import { Link } from "@tanstack/react-router"
+import { Bell, ListChecks } from "lucide-react"
+import type { LucideIcon } from "lucide-react"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { useActivities } from "@/hooks/use-activities"
+import { useReminders } from "@/hooks/use-reminders"
+import { usePushNotifications } from "@/hooks/use-push"
+
+/** Past this many entries the account is established, and nudging is nagging. */
+const STILL_NEW_BELOW = 5
+
+interface SetupStep {
+  to: "/activities" | "/reminders"
+  icon: LucideIcon
+  label: string
+  describes: string
+}
+
+/**
+ * The two things that are worth setting up early and are otherwise only
+ * reachable through Settings. Disappears on its own once they are done, or
+ * once the account is no longer new.
+ */
+export function SetupCard({ totalEntries }: { totalEntries: number }) {
+  const { data: activities } = useActivities()
+  const { data: reminders } = useReminders()
+  const push = usePushNotifications()
+
+  if (totalEntries >= STILL_NEW_BELOW) return null
+
+  const steps: SetupStep[] = []
+
+  if (activities?.length === 0) {
+    steps.push({
+      to: "/activities",
+      icon: ListChecks,
+      label: "Add your activities",
+      describes: "What you want to tag entries with",
+    })
+  }
+
+  if (push.isSupported && push.hasVapidKey && reminders?.length === 0) {
+    steps.push({
+      to: "/reminders",
+      icon: Bell,
+      label: "Set a reminder",
+      describes: "A nudge at the time you want to check in",
+    })
+  }
+
+  if (steps.length === 0) return null
+
+  return (
+    <Card>
+      <CardHeader className="pb-2">
+        <CardTitle className="text-sm">Finish setting up</CardTitle>
+      </CardHeader>
+      <CardContent className="flex flex-col gap-1 p-0 pb-2">
+        {steps.map((step) => {
+          const Icon = step.icon
+
+          return (
+            <Link
+              key={step.to}
+              to={step.to}
+              className="flex items-center gap-3 px-6 py-3 transition-colors hover:bg-muted/50"
+            >
+              <Icon
+                className="h-4 w-4 shrink-0 text-muted-foreground"
+                aria-hidden="true"
+              />
+              <span className="flex flex-col">
+                <span className="text-sm">{step.label}</span>
+                <span className="text-xs text-muted-foreground">
+                  {step.describes}
+                </span>
+              </span>
+            </Link>
+          )
+        })}
+      </CardContent>
+    </Card>
+  )
+}
diff --git a/spa/src/components/dashboard/today-card.tsx b/spa/src/components/dashboard/today-card.tsx
new file mode 100644
index 0000000..b392c71
--- /dev/null
+++ b/spa/src/components/dashboard/today-card.tsx
@@ -0,0 +1,39 @@
+import { Link } from "@tanstack/react-router"
+import { isToday } from "date-fns"
+import { buttonLook } from "@/lib/button-style"
+import { Card, CardContent } from "@/components/ui/card"
+import { MoodBadge } from "@/components/mood/mood-badge"
+import type { EntryResponse } from "@/api/schema"
+
+/**
+ * How today has gone, or an invitation to say. The latest entry is only
+ * "today's mood" if it was logged today — showing a mood from last week under
+ * that heading was telling the reader something untrue.
+ */
+export function TodayCard({ latest }: { latest?: EntryResponse }) {
+  const loggedToday = latest && isToday(new Date(latest.loggedAt))
+
+  if (!loggedToday) {
+    return (
+      <Card>
+        <CardContent className="flex flex-col items-center gap-3 py-6">
+          <p className="text-sm text-muted-foreground">
+            Nothing logged today yet
+          </p>
+          <Link to="/add" className={buttonLook()}>
+            How are you feeling?
+          </Link>
+        </CardContent>
+      </Card>
+    )
+  }
+
+  return (
+    <Card>
+      <CardContent className="flex flex-col items-center gap-2 py-6">
+        <p className="text-sm text-muted-foreground">Today</p>
+        <MoodBadge value={latest.mood} showLabel className="text-2xl" />
+      </CardContent>
+    </Card>
+  )
+}
diff --git a/spa/src/components/dev/devtools.tsx b/spa/src/components/dev/devtools.tsx
new file mode 100644
index 0000000..990107c
--- /dev/null
+++ b/spa/src/components/dev/devtools.tsx
@@ -0,0 +1,11 @@
+import { TanStackRouterDevtools } from "@tanstack/react-router-devtools"
+import { ReactQueryDevtools } from "@tanstack/react-query-devtools"
+
+export default function Devtools() {
+  return (
+    <>
+      <ReactQueryDevtools buttonPosition="bottom-left" />
+      <TanStackRouterDevtools position="bottom-right" />
+    </>
+  )
+}
diff --git a/spa/src/components/entry/detail/entry-activities.tsx b/spa/src/components/entry/detail/entry-activities.tsx
new file mode 100644
index 0000000..4204941
--- /dev/null
+++ b/spa/src/components/entry/detail/entry-activities.tsx
@@ -0,0 +1,40 @@
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Badge } from "@/components/ui/badge"
+import { groupNamesById } from "@/lib/activity-groups"
+import type { ActivityResponse } from "@/api/schema"
+
+interface EntryActivitiesProps {
+  activityIds: string[]
+  catalogue: ActivityResponse[]
+}
+
+export function EntryActivities({
+  activityIds,
+  catalogue,
+}: EntryActivitiesProps) {
+  if (!activityIds.length) return null
+
+  return (
+    <Card>
+      <CardHeader className="pb-2">
+        <CardTitle className="text-sm">Activities</CardTitle>
+      </CardHeader>
+      <CardContent className="flex flex-col gap-3">
+        {groupNamesById(activityIds, catalogue).map(({ category, items }) => (
+          <div key={category}>
+            <p className="mb-1.5 text-xs font-medium tracking-wide text-muted-foreground uppercase">
+              {category}
+            </p>
+            <div className="flex flex-wrap gap-2">
+              {items.map((activity) => (
+                <Badge key={activity.id} variant="outline" className="text-xs">
+                  {activity.name}
+                </Badge>
+              ))}
+            </div>
+          </div>
+        ))}
+      </CardContent>
+    </Card>
+  )
+}
diff --git a/spa/src/components/entry/detail/entry-photos.tsx b/spa/src/components/entry/detail/entry-photos.tsx
new file mode 100644
index 0000000..ff0f8b3
--- /dev/null
+++ b/spa/src/components/entry/detail/entry-photos.tsx
@@ -0,0 +1,43 @@
+import { useState } from "react"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { PhotoLightbox } from "@/components/media/photo-lightbox"
+import { media } from "@/api/client"
+
+export function EntryPhotos({ photoIds }: { photoIds: string[] }) {
+  const [openAt, setOpenAt] = useState<number | null>(null)
+  const urls = photoIds.map(media.photoUrl)
+
+  if (!photoIds.length) return null
+
+  return (
+    <Card>
+      <CardHeader className="pb-2">
+        <CardTitle className="text-sm">Photos</CardTitle>
+      </CardHeader>
+      <CardContent className="grid grid-cols-2 gap-2">
+        {urls.map((url, index) => (
+          <button
+            key={photoIds[index]}
+            type="button"
+            aria-label={`Open photo ${index + 1} of ${urls.length}`}
+            onClick={() => setOpenAt(index)}
+            className="aspect-square overflow-hidden rounded-lg focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none"
+          >
+            <img
+              src={url}
+              alt={`Photo ${index + 1}`}
+              loading="lazy"
+              className="h-full w-full object-cover"
+            />
+          </button>
+        ))}
+      </CardContent>
+
+      <PhotoLightbox
+        urls={urls}
+        openAt={openAt}
+        onClose={() => setOpenAt(null)}
+      />
+    </Card>
+  )
+}
diff --git a/spa/src/components/entry/draft-restored-notice.tsx b/spa/src/components/entry/draft-restored-notice.tsx
new file mode 100644
index 0000000..8ae307f
--- /dev/null
+++ b/spa/src/components/entry/draft-restored-notice.tsx
@@ -0,0 +1,19 @@
+import { Button } from "@/components/ui/button"
+
+/**
+ * Says plainly that what is on screen was picked up from an abandoned attempt,
+ * rather than letting it look like a fresh form that mysteriously has content.
+ */
+export function DraftRestoredNotice({ onDiscard }: { onDiscard: () => void }) {
+  return (
+    <div
+      role="status"
+      className="flex items-center justify-between gap-3 rounded-lg border border-primary/40 bg-primary/10 px-3 py-2"
+    >
+      <span className="text-xs">We kept what you started earlier.</span>
+      <Button type="button" variant="ghost" size="sm" onClick={onDiscard}>
+        Start over
+      </Button>
+    </div>
+  )
+}
diff --git a/spa/src/components/entry/entry-details.tsx b/spa/src/components/entry/entry-details.tsx
new file mode 100644
index 0000000..891c6a2
--- /dev/null
+++ b/spa/src/components/entry/entry-details.tsx
@@ -0,0 +1,85 @@
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Label } from "@/components/ui/label"
+import { Textarea } from "@/components/ui/textarea"
+import { PhotoPicker } from "@/components/media/photo-picker"
+import { VoiceMemoPicker } from "@/components/media/voice-memo-picker"
+import { SongField } from "./fields/song-field"
+import { LocationField } from "./fields/location-field"
+import type { DraftControls } from "@/hooks/use-entry-draft"
+
+const NOTE_ROWS = 3
+
+/**
+ * Everything beyond the mood, the moment and the activities. Folded away by
+ * default so the common case — a face and a tap — is not buried under it.
+ */
+export function EntryDetails({ draft, set }: DraftControls) {
+  return (
+    <div className="flex flex-col gap-4">
+      <Card>
+        <CardHeader className="pb-2">
+          <CardTitle className="text-sm">
+            <Label htmlFor="entry-note">Note</Label>
+          </CardTitle>
+        </CardHeader>
+        <CardContent>
+          <Textarea
+            id="entry-note"
+            placeholder="What's on your mind?"
+            value={draft.content}
+            onChange={(event) => set("content", event.target.value)}
+            rows={NOTE_ROWS}
+          />
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader className="pb-2">
+          <CardTitle className="text-sm">Song</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <SongField
+            value={draft.song}
+            onChange={(song) => set("song", song)}
+          />
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader className="pb-2">
+          <CardTitle className="text-sm">Location</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <LocationField
+            value={draft.location}
+            onChange={(location) => set("location", location)}
+          />
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader className="pb-2">
+          <CardTitle className="text-sm">Photos</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <PhotoPicker
+            items={draft.photos}
+            onChange={(photos) => set("photos", photos)}
+          />
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader className="pb-2">
+          <CardTitle className="text-sm">Voice memos</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <VoiceMemoPicker
+            items={draft.voiceMemos}
+            onChange={(voiceMemos) => set("voiceMemos", voiceMemos)}
+          />
+        </CardContent>
+      </Card>
+    </div>
+  )
+}
diff --git a/spa/src/components/entry/entry-filters.tsx b/spa/src/components/entry/entry-filters.tsx
new file mode 100644
index 0000000..b4eceec
--- /dev/null
+++ b/spa/src/components/entry/entry-filters.tsx
@@ -0,0 +1,96 @@
+import { X } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { MOODS } from "@/lib/mood"
+import { cn } from "@/lib/utils"
+import { useActivities } from "@/hooks/use-activities"
+import type { EntryFilters } from "@/hooks/use-entries"
+
+interface EntryFiltersBarProps {
+  filters: EntryFilters
+  onChange: (filters: EntryFilters) => void
+}
+
+export function isNarrowed(filters: EntryFilters): boolean {
+  return Object.values(filters).some((value) => value !== undefined)
+}
+
+export function EntryFiltersBar({ filters, onChange }: EntryFiltersBarProps) {
+  const { data: activities } = useActivities()
+  const inUse = activities?.filter((activity) => !activity.archived) ?? []
+
+  const toggleMood = (mood: number) =>
+    onChange({ ...filters, mood: filters.mood === mood ? undefined : mood })
+
+  const chooseActivity = (activity: string) =>
+    onChange({
+      ...filters,
+      activity: filters.activity === activity ? undefined : activity,
+    })
+
+  return (
+    <div className="flex flex-col gap-3">
+      <fieldset className="flex flex-col gap-1.5">
+        <legend className="text-xs font-medium tracking-wide text-muted-foreground uppercase">
+          Mood
+        </legend>
+        <div className="flex gap-1.5">
+          {MOODS.map((mood) => (
+            <button
+              key={mood.value}
+              type="button"
+              aria-pressed={filters.mood === mood.value}
+              aria-label={mood.label}
+              onClick={() => toggleMood(mood.value)}
+              className={cn(
+                "flex-1 rounded-lg border py-1.5 text-xl transition-all",
+                filters.mood === mood.value
+                  ? "border-primary bg-primary/15"
+                  : "border-transparent opacity-60 hover:opacity-100"
+              )}
+            >
+              <span aria-hidden="true">{mood.emoji}</span>
+            </button>
+          ))}
+        </div>
+      </fieldset>
+
+      {inUse.length > 0 && (
+        <fieldset className="flex flex-col gap-1.5">
+          <legend className="text-xs font-medium tracking-wide text-muted-foreground uppercase">
+            Activity
+          </legend>
+          <div className="flex flex-wrap gap-1.5">
+            {inUse.map((activity) => (
+              <button
+                key={activity.id}
+                type="button"
+                aria-pressed={filters.activity === activity.id}
+                onClick={() => chooseActivity(activity.id)}
+                className={cn(
+                  "rounded-full border px-2.5 py-1 text-xs transition-colors",
+                  filters.activity === activity.id
+                    ? "border-primary bg-primary/15 text-foreground"
+                    : "border-border text-muted-foreground hover:text-foreground"
+                )}
+              >
+                {activity.name}
+              </button>
+            ))}
+          </div>
+        </fieldset>
+      )}
+
+      {isNarrowed(filters) && (
+        <Button
+          variant="ghost"
+          size="sm"
+          className="self-start"
+          onClick={() => onChange({})}
+        >
+          <X className="mr-1 h-3 w-3" aria-hidden="true" />
+          Clear filters
+        </Button>
+      )}
+    </div>
+  )
+}
diff --git a/spa/src/components/entry/entry-form.tsx b/spa/src/components/entry/entry-form.tsx
index fb97f73..5abcd8b 100644
--- a/spa/src/components/entry/entry-form.tsx
+++ b/spa/src/components/entry/entry-form.tsx
@@ -1,307 +1,149 @@
 import { useState } from "react"
+import { Link } from "@tanstack/react-router"
+import { ChevronDown, ChevronUp, WifiOff } from "lucide-react"
 import { Button } from "@/components/ui/button"
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
-import { Textarea } from "@/components/ui/textarea"
-import { Input } from "@/components/ui/input"
+import { Skeleton } from "@/components/ui/skeleton"
 import { MoodPicker } from "@/components/mood/mood-picker"
 import { LoggedAtPicker } from "@/components/entry/logged-at-picker"
 import { ActivityPicker } from "@/components/activity/activity-picker"
-import { PhotoPicker } from "@/components/media/photo-picker"
-import { VoiceMemoPicker } from "@/components/media/voice-memo-picker"
+import { EntryDetails } from "./entry-details"
+import { DraftRestoredNotice } from "./draft-restored-notice"
 import { useActivities } from "@/hooks/use-activities"
-import { useNowPlaying } from "@/hooks/use-providers"
-import { media as mediaApi } from "@/api/client"
-import { toast } from "@/components/ui/toast"
-import type { MoodValue } from "@/lib/mood"
-import type { MediaItem } from "@/lib/media"
-import { getExistingIds, getPendingFiles } from "@/lib/media"
-import { buildDimensions } from "@/lib/dimensions"
+import { useOnline } from "@/hooks/use-online"
+import { hasExtras } from "@/lib/entry-draft"
 import { fromLoggedAt, toLoggedAt } from "@/lib/logged-at"
-import type { DimensionPayload } from "@/api/schema"
-
-export interface EntryFormData {
-  mood: number
-  loggedAt: string
-  dimensions?: DimensionPayload[]
-}
+import type { DraftControls } from "@/hooks/use-entry-draft"
 
 interface EntryFormProps {
+  controls: DraftControls
   title: string
   submitLabel: string
-  isPending: boolean
-  onSubmit: (data: EntryFormData) => void
-  initial?: {
-    mood?: number
-    loggedAt?: string
-    content?: string
-    activities?: string[]
-    photos?: string[]
-    voiceMemos?: string[]
-    location?: { latitude: number; longitude: number } | null
-    song?: { title: string; artist: string } | null
-  }
+  isSaving: boolean
+  onSubmit: () => void
 }
 
 export function EntryForm({
+  controls,
   title,
   submitLabel,
-  isPending,
+  isSaving,
   onSubmit,
-  initial,
 }: EntryFormProps) {
-  const [mood, setMood] = useState<MoodValue | undefined>(
-    initial?.mood as MoodValue | undefined
-  )
-  const [loggedAt, setLoggedAt] = useState<Date>(
-    initial?.loggedAt ? fromLoggedAt(initial.loggedAt) : new Date()
-  )
-  const [content, setContent] = useState(initial?.content ?? "")
-  const [selectedActivities, setSelectedActivities] = useState<string[]>(
-    initial?.activities ?? []
-  )
-  const [photoItems, setPhotoItems] = useState<MediaItem[]>(
-    (initial?.photos ?? []).map((id) => ({ type: "existing" as const, id }))
-  )
-  const [voiceMemoItems, setVoiceMemoItems] = useState<MediaItem[]>(
-    (initial?.voiceMemos ?? []).map((id) => ({ type: "existing" as const, id }))
-  )
-  const [songTitle, setSongTitle] = useState(initial?.song?.title ?? "")
-  const [songArtist, setSongArtist] = useState(initial?.song?.artist ?? "")
-  const [location, setLocation] = useState<{
-    latitude: number
-    longitude: number
-  } | null>(initial?.location ?? null)
-  const [locating, setLocating] = useState(false)
-  const nowPlaying = useNowPlaying()
-
-  const fillFromNowPlaying = () => {
-    nowPlaying.mutate(undefined, {
-      onSuccess: (playing) => {
-        if (playing?.kind !== "song") {
-          toast.add({ title: "Nothing is playing right now", type: "info" })
-          return
-        }
-        setSongTitle(playing.title)
-        setSongArtist(playing.artist)
-      },
-      onError: () =>
-        toast.add({
-          title: "Could not reach your music server",
-          type: "error",
-        }),
-    })
-  }
-  const [uploading, setUploading] = useState(false)
-
-  const captureLocation = () => {
-    if (!("geolocation" in navigator)) {
-      toast.add({
-        title: "Location is unavailable on this device",
-        type: "error",
-      })
-      return
-    }
-    setLocating(true)
-    navigator.geolocation.getCurrentPosition(
-      (position) => {
-        setLocation({
-          latitude: position.coords.latitude,
-          longitude: position.coords.longitude,
-        })
-        setLocating(false)
-      },
-      () => {
-        toast.add({ title: "Could not read your location", type: "error" })
-        setLocating(false)
-      }
-    )
-  }
+  const { draft, isLoading, wasRestored, set, toggleActivity, discard } =
+    controls
+  const [detailsOpen, setDetailsOpen] = useState(() => hasExtras(draft))
   const { data: activities } = useActivities()
+  const online = useOnline()
 
-  const toggleActivity = (id: string) => {
-    setSelectedActivities((prev) =>
-      prev.includes(id) ? prev.filter((a) => a !== id) : [...prev, id]
+  const showingDetails = detailsOpen || hasExtras(draft)
+  const inUse = activities?.filter((activity) => !activity.archived) ?? []
+
+  if (isLoading) {
+    return (
+      <div className="flex flex-col gap-6">
+        <Skeleton className="h-8 w-48 self-center" />
+        <Skeleton className="h-24" />
+        <Skeleton className="h-32" />
+      </div>
     )
   }
 
-  const handleSubmit = async () => {
-    if (!mood) return
-
-    setUploading(true)
-    try {
-      const photoIds = [...getExistingIds(photoItems)]
-      for (const file of getPendingFiles(photoItems)) {
-        const result = await mediaApi.uploadPhoto(file)
-        photoIds.push(result.id)
-      }
-
-      const voiceMemoIds = [...getExistingIds(voiceMemoItems)]
-      for (const file of getPendingFiles(voiceMemoItems)) {
-        const result = await mediaApi.uploadVoiceMemo(file)
-        voiceMemoIds.push(result.id)
-      }
-
-      onSubmit({
-        mood,
-        loggedAt: toLoggedAt(loggedAt),
-        dimensions: buildDimensions({
-          content,
-          activityIds: selectedActivities,
-          photoIds,
-          voiceMemoIds,
-          location,
-          song: { title: songTitle, artist: songArtist },
-        }),
-      })
-    } catch {
-      toast.add({ title: "Failed to upload media", type: "error" })
-    } finally {
-      setUploading(false)
-    }
-  }
-
-  const busy = isPending || uploading
-
   return (
-    <div className="flex flex-col gap-6">
+    <form
+      className="flex flex-col gap-6"
+      onSubmit={(event) => {
+        event.preventDefault()
+        onSubmit()
+      }}
+    >
       <h1 className="text-center text-xl font-bold">{title}</h1>
 
-      <MoodPicker value={mood} onChange={setMood} size="lg" />
+      {wasRestored && <DraftRestoredNotice onDiscard={discard} />}
+
+      <MoodPicker
+        value={draft.mood ?? undefined}
+        onChange={(mood) => set("mood", mood)}
+        size="lg"
+      />
 
       <Card>
         <CardHeader className="pb-2">
           <CardTitle className="text-sm">Logged</CardTitle>
         </CardHeader>
         <CardContent>
-          <LoggedAtPicker value={loggedAt} onChange={setLoggedAt} />
+          <LoggedAtPicker
+            value={fromLoggedAt(draft.loggedAt)}
+            onChange={(moment) => set("loggedAt", toLoggedAt(moment))}
+          />
         </CardContent>
       </Card>
 
-      {activities?.length ? (
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm">Activities</CardTitle>
-          </CardHeader>
-          <CardContent>
+      <Card>
+        <CardHeader className="pb-2">
+          <CardTitle className="text-sm">Activities</CardTitle>
+        </CardHeader>
+        <CardContent>
+          {inUse.length > 0 ? (
             <ActivityPicker
-              activities={activities}
-              selected={selectedActivities}
+              activities={inUse}
+              selected={draft.activityIds}
               onToggle={toggleActivity}
             />
-          </CardContent>
-        </Card>
-      ) : null}
-
-      <Card>
-        <CardHeader className="pb-2">
-          <CardTitle className="text-sm">Note</CardTitle>
-        </CardHeader>
-        <CardContent>
-          <Textarea
-            placeholder="What's on your mind?"
-            value={content}
-            onChange={(e) => setContent(e.target.value)}
-            rows={3}
-          />
-        </CardContent>
-      </Card>
-
-      <Card>
-        <CardHeader className="pb-2">
-          <CardTitle className="text-sm">Song</CardTitle>
-        </CardHeader>
-        <CardContent className="space-y-2">
-          <Input
-            placeholder="Title"
-            value={songTitle}
-            onChange={(e) => setSongTitle(e.target.value)}
-          />
-          <Input
-            placeholder="Artist"
-            value={songArtist}
-            onChange={(e) => setSongArtist(e.target.value)}
-          />
-          <Button
-            type="button"
-            variant="outline"
-            size="sm"
-            onClick={fillFromNowPlaying}
-            disabled={nowPlaying.isPending}
-          >
-            {nowPlaying.isPending ? "Checking…" : "What's playing?"}
-          </Button>
-        </CardContent>
-      </Card>
-
-      <Card>
-        <CardHeader className="pb-2">
-          <CardTitle className="text-sm">Location</CardTitle>
-        </CardHeader>
-        <CardContent className="flex items-center gap-3">
-          <Button
-            type="button"
-            variant="outline"
-            size="sm"
-            onClick={captureLocation}
-            disabled={locating}
-          >
-            {locating
-              ? "Locating…"
-              : location
-                ? "Update location"
-                : "Add location"}
-          </Button>
-          {location && (
-            <span className="text-xs text-muted-foreground">
-              {location.latitude.toFixed(4)}, {location.longitude.toFixed(4)}
-            </span>
-          )}
-          {location && (
-            <Button
-              type="button"
-              variant="ghost"
-              size="sm"
-              onClick={() => setLocation(null)}
-            >
-              Remove
-            </Button>
+          ) : (
+            <p className="text-sm text-muted-foreground">
+              No activities yet.{" "}
+              <Link to="/activities" className="text-primary underline">
+                Add some
+              </Link>{" "}
+              to tag what you were doing.
+            </p>
           )}
         </CardContent>
       </Card>
 
-      <Card>
-        <CardHeader className="pb-2">
-          <CardTitle className="text-sm">Photos</CardTitle>
-        </CardHeader>
-        <CardContent>
-          <PhotoPicker items={photoItems} onChange={setPhotoItems} />
-        </CardContent>
-      </Card>
+      {showingDetails ? (
+        <EntryDetails {...controls} />
+      ) : (
+        <Button
+          type="button"
+          variant="outline"
+          aria-expanded={false}
+          onClick={() => setDetailsOpen(true)}
+        >
+          <ChevronDown className="mr-2 h-4 w-4" aria-hidden="true" />
+          Add a note, photo, or more
+        </Button>
+      )}
 
-      <Card>
-        <CardHeader className="pb-2">
-          <CardTitle className="text-sm">Voice memos</CardTitle>
-        </CardHeader>
-        <CardContent>
-          <VoiceMemoPicker
-            items={voiceMemoItems}
-            onChange={setVoiceMemoItems}
-          />
-        </CardContent>
-      </Card>
+      {showingDetails && !hasExtras(draft) && (
+        <Button
+          type="button"
+          variant="ghost"
+          size="sm"
+          aria-expanded={true}
+          onClick={() => setDetailsOpen(false)}
+        >
+          <ChevronUp className="mr-2 h-4 w-4" aria-hidden="true" />
+          Hide extras
+        </Button>
+      )}
+
+      {!online && (
+        <p className="flex items-center justify-center gap-2 text-xs text-muted-foreground">
+          <WifiOff className="h-3 w-3" aria-hidden="true" />
+          Offline — this will send when you are back
+        </p>
+      )}
 
       <Button
+        type="submit"
         size="lg"
-        onClick={handleSubmit}
-        disabled={!mood || busy}
+        disabled={draft.mood === null || isSaving}
         className="w-full"
       >
-        {uploading
-          ? "Uploading media..."
-          : isPending
-            ? "Saving..."
-            : submitLabel}
+        {isSaving ? "Saving…" : submitLabel}
       </Button>
-    </div>
+    </form>
   )
 }
diff --git a/spa/src/components/entry/entry-list.tsx b/spa/src/components/entry/entry-list.tsx
index 983ef05..20ce042 100644
--- a/spa/src/components/entry/entry-list.tsx
+++ b/spa/src/components/entry/entry-list.tsx
@@ -1,55 +1,50 @@
-import { format, isToday, isYesterday } from "date-fns"
+import { describeDay } from "@/lib/day-label"
+import { formatDate, parseDate } from "@/lib/day"
 import type { EntryResponse } from "@/api/schema"
 import { EntryCard } from "./entry-card"
 
 interface EntryListProps {
   entries: EntryResponse[]
-  limit?: number
 }
 
-export function EntryList({ entries, limit }: EntryListProps) {
-  const sliced = limit ? entries.slice(0, limit) : entries
-  const grouped = groupByDay(sliced)
-
+export function EntryList({ entries }: EntryListProps) {
   return (
     <div className="flex flex-col gap-4">
-      {grouped.map(({ label, entries: onThatDay }) => (
-        <div key={label} className="flex flex-col gap-2">
+      {groupByDay(entries).map(({ day, entries: onThatDay }) => (
+        <section key={day} className="flex flex-col gap-2">
           <h3 className="text-xs font-medium tracking-wide text-muted-foreground uppercase">
-            {label}
+            {describeDay(parseDate(day))}
           </h3>
           {onThatDay.map((entry) => (
             <EntryCard key={entry.id} entry={entry} />
           ))}
-        </div>
+        </section>
       ))}
     </div>
   )
 }
 
-function groupByDay(
+interface DayGroup {
+  day: string
   entries: EntryResponse[]
-): Array<{ label: string; entries: EntryResponse[] }> {
+}
+
+function groupByDay(entries: EntryResponse[]): DayGroup[] {
   const groups = new Map<string, EntryResponse[]>()
 
   for (const entry of entries) {
-    const date = new Date(entry.loggedAt)
-    const key = format(date, "yyyy-MM-dd")
+    const day = formatDate(new Date(entry.loggedAt))
+    const existing = groups.get(day)
 
-    if (!groups.has(key)) {
-      groups.set(key, [])
+    if (existing) {
+      existing.push(entry)
+    } else {
+      groups.set(day, [entry])
     }
-    groups.get(key)!.push(entry)
   }
 
-  return Array.from(groups.entries()).map(([key, onThatDay]) => ({
-    label: formatDayLabel(new Date(key)),
+  return Array.from(groups.entries()).map(([day, onThatDay]) => ({
+    day,
     entries: onThatDay,
   }))
 }
-
-function formatDayLabel(date: Date): string {
-  if (isToday(date)) return "Today"
-  if (isYesterday(date)) return "Yesterday"
-  return format(date, "EEEE, MMMM d, yyyy")
-}
diff --git a/spa/src/components/entry/entry-missing.tsx b/spa/src/components/entry/entry-missing.tsx
new file mode 100644
index 0000000..d0a3168
--- /dev/null
+++ b/spa/src/components/entry/entry-missing.tsx
@@ -0,0 +1,27 @@
+import { Link } from "@tanstack/react-router"
+import { buttonLook } from "@/lib/button-style"
+import {
+  Empty,
+  EmptyContent,
+  EmptyDescription,
+  EmptyHeader,
+  EmptyTitle,
+} from "@/components/ui/empty"
+
+export function EntryMissing() {
+  return (
+    <Empty className="py-12">
+      <EmptyHeader>
+        <EmptyTitle>Entry not found</EmptyTitle>
+        <EmptyDescription>
+          It may have been deleted, or the link may be wrong.
+        </EmptyDescription>
+      </EmptyHeader>
+      <EmptyContent>
+        <Link to="/diary" className={buttonLook({ variant: "outline" })}>
+          Back to the diary
+        </Link>
+      </EmptyContent>
+    </Empty>
+  )
+}
diff --git a/spa/src/components/entry/fields/location-field.tsx b/spa/src/components/entry/fields/location-field.tsx
new file mode 100644
index 0000000..cd69d7a
--- /dev/null
+++ b/spa/src/components/entry/fields/location-field.tsx
@@ -0,0 +1,71 @@
+import { useState } from "react"
+import { Button } from "@/components/ui/button"
+import { toast } from "@/components/ui/toast"
+import type { Coordinates } from "@/lib/entry-draft"
+
+interface LocationFieldProps {
+  value: Coordinates | null
+  onChange: (location: Coordinates | null) => void
+}
+
+const COORDINATE_PRECISION = 4
+
+export function LocationField({ value, onChange }: LocationFieldProps) {
+  const [locating, setLocating] = useState(false)
+
+  const capture = () => {
+    if (!("geolocation" in navigator)) {
+      toast.add({
+        title: "Location is unavailable on this device",
+        type: "error",
+      })
+      return
+    }
+
+    setLocating(true)
+    navigator.geolocation.getCurrentPosition(
+      (position) => {
+        onChange({
+          latitude: position.coords.latitude,
+          longitude: position.coords.longitude,
+        })
+        setLocating(false)
+      },
+      () => {
+        toast.add({ title: "Could not read your location", type: "error" })
+        setLocating(false)
+      }
+    )
+  }
+
+  return (
+    <div className="flex flex-wrap items-center gap-3">
+      <Button
+        type="button"
+        variant="outline"
+        size="sm"
+        onClick={capture}
+        disabled={locating}
+      >
+        {locating ? "Locating…" : value ? "Update location" : "Add location"}
+      </Button>
+
+      {value && (
+        <>
+          <span className="text-xs text-muted-foreground tabular-nums">
+            {value.latitude.toFixed(COORDINATE_PRECISION)},{" "}
+            {value.longitude.toFixed(COORDINATE_PRECISION)}
+          </span>
+          <Button
+            type="button"
+            variant="ghost"
+            size="sm"
+            onClick={() => onChange(null)}
+          >
+            Remove
+          </Button>
+        </>
+      )}
+    </div>
+  )
+}
diff --git a/spa/src/components/entry/fields/song-field.tsx b/spa/src/components/entry/fields/song-field.tsx
new file mode 100644
index 0000000..5eadf70
--- /dev/null
+++ b/spa/src/components/entry/fields/song-field.tsx
@@ -0,0 +1,65 @@
+import { Button } from "@/components/ui/button"
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import { toast } from "@/components/ui/toast"
+import { useNowPlaying } from "@/hooks/use-providers"
+import type { SongNote } from "@/lib/entry-draft"
+
+interface SongFieldProps {
+  value: SongNote
+  onChange: (song: SongNote) => void
+}
+
+export function SongField({ value, onChange }: SongFieldProps) {
+  const nowPlaying = useNowPlaying()
+
+  const fillFromNowPlaying = () => {
+    nowPlaying.mutate(undefined, {
+      onSuccess: (playing) => {
+        if (playing?.kind !== "song") {
+          toast.add({ title: "Nothing is playing right now", type: "info" })
+          return
+        }
+        onChange({ title: playing.title, artist: playing.artist })
+      },
+      onError: () =>
+        toast.add({
+          title: "Could not reach your music server",
+          type: "error",
+        }),
+    })
+  }
+
+  return (
+    <div className="flex flex-col gap-2">
+      <Label htmlFor="song-title" className="sr-only">
+        Song title
+      </Label>
+      <Input
+        id="song-title"
+        placeholder="Title"
+        value={value.title}
+        onChange={(event) => onChange({ ...value, title: event.target.value })}
+      />
+      <Label htmlFor="song-artist" className="sr-only">
+        Artist
+      </Label>
+      <Input
+        id="song-artist"
+        placeholder="Artist"
+        value={value.artist}
+        onChange={(event) => onChange({ ...value, artist: event.target.value })}
+      />
+      <Button
+        type="button"
+        variant="outline"
+        size="sm"
+        className="self-start"
+        onClick={fillFromNowPlaying}
+        disabled={nowPlaying.isPending}
+      >
+        {nowPlaying.isPending ? "Checking…" : "What's playing?"}
+      </Button>
+    </div>
+  )
+}
diff --git a/spa/src/components/entry/log-sheet.tsx b/spa/src/components/entry/log-sheet.tsx
new file mode 100644
index 0000000..a76f8be
--- /dev/null
+++ b/spa/src/components/entry/log-sheet.tsx
@@ -0,0 +1,47 @@
+import {
+  Drawer,
+  DrawerContent,
+  DrawerDescription,
+  DrawerHeader,
+  DrawerTitle,
+} from "@/components/ui/drawer"
+import { EntryForm } from "./entry-form"
+import { useNewEntryForm } from "@/hooks/use-new-entry-form"
+
+interface LogSheetProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+}
+
+/**
+ * Logging a mood from wherever you are. The same form the page shows, in front
+ * of what you were already looking at, because the common case is one tap.
+ */
+export function LogSheet({ open, onOpenChange }: LogSheetProps) {
+  const { controls, submit, isSaving } = useNewEntryForm(() =>
+    onOpenChange(false)
+  )
+
+  return (
+    <Drawer open={open} onOpenChange={onOpenChange} showSwipeHandle>
+      <DrawerContent className="mx-auto max-h-[85svh] w-full max-w-md">
+        <DrawerHeader className="sr-only">
+          <DrawerTitle>Log a mood</DrawerTitle>
+          <DrawerDescription>
+            Pick how you feel, and add as much or as little else as you want.
+          </DrawerDescription>
+        </DrawerHeader>
+
+        <div className="overflow-y-auto px-4 pt-2 pb-6 pb-safe">
+          <EntryForm
+            controls={controls}
+            title="How are you feeling?"
+            submitLabel="Save entry"
+            isSaving={isSaving}
+            onSubmit={submit}
+          />
+        </div>
+      </DrawerContent>
+    </Drawer>
+  )
+}
diff --git a/spa/src/components/entry/pending-entries.tsx b/spa/src/components/entry/pending-entries.tsx
new file mode 100644
index 0000000..b87c00e
--- /dev/null
+++ b/spa/src/components/entry/pending-entries.tsx
@@ -0,0 +1,103 @@
+import { format } from "date-fns"
+import { AlertTriangle, Clock } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent } from "@/components/ui/card"
+import { MoodBadge } from "@/components/mood/mood-badge"
+import {
+  useDiscardQueued,
+  useQueuedEntries,
+  useRetryQueued,
+} from "@/hooks/use-outbox"
+import { isStuck } from "@/lib/outbox-sync"
+import { contentPreview } from "@/lib/entry-preview"
+import type { QueuedEntry } from "@/lib/store/outbox"
+
+/**
+ * Entries written on this device that the server has not taken yet. They are
+ * shown with the journal so that logging offline still looks like it worked.
+ */
+export function PendingEntries() {
+  const { data: queued = [] } = useQueuedEntries()
+
+  if (!queued.length) return null
+
+  return (
+    <section className="flex flex-col gap-2">
+      <h2 className="text-xs font-medium tracking-wide text-muted-foreground uppercase">
+        Not sent yet
+      </h2>
+      {queued.map((entry) => (
+        <PendingEntryCard key={entry.id} queued={entry} />
+      ))}
+    </section>
+  )
+}
+
+function PendingEntryCard({ queued }: { queued: QueuedEntry }) {
+  const retry = useRetryQueued()
+  const discard = useDiscardQueued()
+  const stuck = isStuck(queued)
+  const note = contentPreview(queued.draft.content)
+
+  return (
+    <Card className="border-dashed">
+      <CardContent className="flex items-start gap-3 p-4">
+        {queued.draft.mood !== null && <MoodBadge value={queued.draft.mood} />}
+
+        <div className="min-w-0 flex-1">
+          <div className="flex items-center justify-between gap-2">
+            <span className="flex items-center gap-1 text-xs text-muted-foreground">
+              {stuck ? (
+                <AlertTriangle
+                  className="h-3 w-3 text-destructive"
+                  aria-hidden="true"
+                />
+              ) : (
+                <Clock className="h-3 w-3" aria-hidden="true" />
+              )}
+              {stuck ? "The server would not take this" : "Waiting to send"}
+            </span>
+            <span className="text-xs text-muted-foreground">
+              {format(new Date(queued.draft.loggedAt), "MMM d, h:mm a")}
+            </span>
+          </div>
+
+          {note && (
+            <p className="mt-1 line-clamp-2 text-sm text-muted-foreground">
+              {note}
+            </p>
+          )}
+
+          {stuck && (
+            <>
+              {queued.lastError && (
+                <p className="mt-1 text-xs text-destructive">
+                  {queued.lastError}
+                </p>
+              )}
+              <div className="mt-2 flex gap-2">
+                <Button
+                  size="sm"
+                  variant="outline"
+                  disabled={retry.isPending}
+                  onClick={() => retry.mutate(queued)}
+                >
+                  {retry.isPending ? "Retrying…" : "Try again"}
+                </Button>
+                <Button
+                  size="sm"
+                  variant="ghost"
+                  className="text-destructive"
+                  disabled={discard.isPending}
+                  onClick={() => discard.mutate(queued.id)}
+                >
+                  Discard
+                </Button>
+              </div>
+            </>
+          )}
+        </div>
+      </CardContent>
+    </Card>
+  )
+}
diff --git a/spa/src/components/layout/app-shell.tsx b/spa/src/components/layout/app-shell.tsx
index 52dc905..ce02bd8 100644
--- a/spa/src/components/layout/app-shell.tsx
+++ b/spa/src/components/layout/app-shell.tsx
@@ -7,8 +7,8 @@ interface AppShellProps {
 
 export function AppShell({ children }: AppShellProps) {
   return (
-    <div className="mx-auto min-h-svh max-w-md bg-background">
-      <main className="pt-safe px-4 pb-20">{children}</main>
+    <div className="mx-auto min-h-svh max-w-md app-column">
+      <main className="px-4 pt-safe pb-nav">{children}</main>
       <BottomNav />
     </div>
   )
diff --git a/spa/src/components/layout/bottom-nav.tsx b/spa/src/components/layout/bottom-nav.tsx
index 7aa1ca2..19b81db 100644
--- a/spa/src/components/layout/bottom-nav.tsx
+++ b/spa/src/components/layout/bottom-nav.tsx
@@ -1,61 +1,116 @@
+import { Suspense, lazy, useState } from "react"
 import { Link, useRouterState } from "@tanstack/react-router"
 import { Home, Calendar, BarChart3, Settings, Plus } from "lucide-react"
 import { cn } from "@/lib/utils"
 
+/**
+ * The form behind the button is the heaviest thing in the app — a date picker,
+ * a drawer and every media control. None of it is needed until someone taps.
+ */
+const LogSheet = lazy(() =>
+  import("@/components/entry/log-sheet").then((module) => ({
+    default: module.LogSheet,
+  }))
+)
+
 type NavItem = {
   to: string
   icon: typeof Home
   label: string
-  primary?: boolean
+  /**
+   * The routes this tab stands for. A tab stays lit while you are anywhere
+   * beneath it — reading an entry belongs to Home, managing activities to
+   * Settings — so no screen in the app is left with nothing selected.
+   */
+  owns: string[]
 }
 
 const NAV_ITEMS: NavItem[] = [
-  { to: "/", icon: Home, label: "Home" },
-  { to: "/calendar", icon: Calendar, label: "Calendar" },
-  { to: "/add", icon: Plus, label: "Add", primary: true },
-  { to: "/stats", icon: BarChart3, label: "Stats" },
-  { to: "/settings", icon: Settings, label: "Settings" },
+  {
+    to: "/",
+    icon: Home,
+    label: "Home",
+    owns: ["/", "/diary", "/entry", "/edit"],
+  },
+  { to: "/calendar", icon: Calendar, label: "Calendar", owns: ["/calendar"] },
+  {
+    to: "/stats",
+    icon: BarChart3,
+    label: "Stats",
+    owns: ["/stats", "/metrics"],
+  },
+  {
+    to: "/settings",
+    icon: Settings,
+    label: "Settings",
+    owns: ["/settings", "/activities", "/reminders", "/import", "/export"],
+  },
 ]
 
+function owns(item: NavItem, pathname: string): boolean {
+  return item.owns.some(
+    (route) =>
+      pathname === route || (route !== "/" && pathname.startsWith(`${route}/`))
+  )
+}
+
 export function BottomNav() {
   const { location } = useRouterState()
+  const [logging, setLogging] = useState(false)
+  const [before, after] = [NAV_ITEMS.slice(0, 2), NAV_ITEMS.slice(2)]
 
   return (
-    <nav className="safe-area-pb fixed right-0 bottom-0 left-0 z-50 border-t bg-background/95 backdrop-blur supports-[backdrop-filter]:bg-background/60">
-      <div className="mx-auto flex max-w-md items-center justify-around px-2 py-1">
-        {NAV_ITEMS.map((item) => {
-          const isActive = location.pathname === item.to
-          const Icon = item.icon
+    <>
+      {logging && (
+        <Suspense fallback={null}>
+          <LogSheet open={logging} onOpenChange={setLogging} />
+        </Suspense>
+      )}
+      <nav
+        aria-label="Primary"
+        className="fixed right-0 bottom-0 left-0 z-50 border-t bg-background/95 pb-safe backdrop-blur supports-[backdrop-filter]:bg-background/60"
+      >
+        <div className="mx-auto flex max-w-md items-center justify-around px-2 py-1">
+          {before.map((item) => (
+            <NavTab key={item.to} item={item} pathname={location.pathname} />
+          ))}
 
-          if (item.primary) {
-            return (
-              <Link
-                key={item.to}
-                to={item.to}
-                className="-mt-5 flex h-14 w-14 items-center justify-center rounded-full bg-primary text-primary-foreground shadow-lg"
-              >
-                <Icon className="h-6 w-6" />
-              </Link>
-            )
-          }
+          <button
+            type="button"
+            aria-label="Log a mood"
+            aria-haspopup="dialog"
+            onClick={() => setLogging(true)}
+            className="-mt-5 flex h-14 w-14 items-center justify-center rounded-full bg-primary text-primary-foreground shadow-lg"
+          >
+            <Plus className="h-6 w-6" aria-hidden="true" />
+          </button>
 
-          return (
-            <Link
-              key={item.to}
-              to={item.to}
-              className={cn(
-                "flex flex-col items-center gap-0.5 px-3 py-2 text-xs transition-colors",
-                isActive
-                  ? "text-primary"
-                  : "text-muted-foreground hover:text-foreground"
-              )}
-            >
-              <Icon className="h-5 w-5" />
-              <span>{item.label}</span>
-            </Link>
-          )
-        })}
-      </div>
-    </nav>
+          {after.map((item) => (
+            <NavTab key={item.to} item={item} pathname={location.pathname} />
+          ))}
+        </div>
+      </nav>
+    </>
+  )
+}
+
+function NavTab({ item, pathname }: { item: NavItem; pathname: string }) {
+  const isActive = owns(item, pathname)
+  const Icon = item.icon
+
+  return (
+    <Link
+      to={item.to}
+      aria-current={isActive ? "page" : undefined}
+      className={cn(
+        "flex flex-col items-center gap-0.5 px-3 py-2 text-xs transition-colors",
+        isActive
+          ? "text-primary"
+          : "text-muted-foreground hover:text-foreground"
+      )}
+    >
+      <Icon className="h-5 w-5" aria-hidden="true" />
+      <span>{item.label}</span>
+    </Link>
   )
 }
diff --git a/spa/src/components/layout/route-error.tsx b/spa/src/components/layout/route-error.tsx
new file mode 100644
index 0000000..0efaa08
--- /dev/null
+++ b/spa/src/components/layout/route-error.tsx
@@ -0,0 +1,67 @@
+import { useEffect } from "react"
+import { useRouter } from "@tanstack/react-router"
+import { RotateCw } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import {
+  Empty,
+  EmptyContent,
+  EmptyDescription,
+  EmptyHeader,
+  EmptyTitle,
+} from "@/components/ui/empty"
+import {
+  forgetMissingChunkReload,
+  isMissingChunk,
+  reloadForMissingChunk,
+} from "@/lib/service-worker"
+
+/**
+ * What a screen shows when it fails, instead of taking the whole app down with
+ * it. A chunk that went missing under a deploy heals itself with one reload;
+ * anything else is offered a retry.
+ */
+export function RouteError({ error }: { error: unknown }) {
+  const router = useRouter()
+  const staleBuild = isMissingChunk(error)
+
+  useEffect(() => {
+    if (staleBuild) reloadForMissingChunk()
+    else forgetMissingChunkReload()
+  }, [staleBuild])
+
+  if (staleBuild) {
+    return (
+      <Empty className="py-16">
+        <EmptyHeader>
+          <EmptyTitle>Updating…</EmptyTitle>
+          <EmptyDescription>
+            A newer version is available. Picking it up now.
+          </EmptyDescription>
+        </EmptyHeader>
+        <EmptyContent>
+          <Button variant="outline" onClick={() => window.location.reload()}>
+            <RotateCw className="mr-2 h-4 w-4" aria-hidden="true" />
+            Reload
+          </Button>
+        </EmptyContent>
+      </Empty>
+    )
+  }
+
+  return (
+    <Empty className="py-16">
+      <EmptyHeader>
+        <EmptyTitle>This screen did not load</EmptyTitle>
+        <EmptyDescription>
+          {error instanceof Error ? error.message : "Something went wrong."}
+        </EmptyDescription>
+      </EmptyHeader>
+      <EmptyContent>
+        <Button variant="outline" onClick={() => router.invalidate()}>
+          <RotateCw className="mr-2 h-4 w-4" aria-hidden="true" />
+          Try again
+        </Button>
+      </EmptyContent>
+    </Empty>
+  )
+}
diff --git a/spa/src/components/media/audio-player.tsx b/spa/src/components/media/audio-player.tsx
index c85fb39..d8ce1ca 100644
--- a/spa/src/components/media/audio-player.tsx
+++ b/spa/src/components/media/audio-player.tsx
@@ -1,14 +1,20 @@
-import { useRef, useState, useEffect, useCallback } from "react"
+import { useCallback, useEffect, useRef, useState } from "react"
 import { Pause, Play, X } from "lucide-react"
 import { Button } from "@/components/ui/button"
 import { Slider } from "@/components/ui/slider"
+import { formatDuration } from "@/lib/duration"
 
 interface AudioPlayerProps {
   src: string
+  label?: string
   onRemove?: () => void
 }
 
-export function AudioPlayer({ src, onRemove }: AudioPlayerProps) {
+export function AudioPlayer({
+  src,
+  label = "Voice memo",
+  onRemove,
+}: AudioPlayerProps) {
   const audioRef = useRef<HTMLAudioElement>(null)
   const [playing, setPlaying] = useState(false)
   const [duration, setDuration] = useState(0)
@@ -21,35 +27,42 @@ export function AudioPlayer({ src, onRemove }: AudioPlayerProps) {
     const onLoaded = () => setDuration(audio.duration)
     const onTime = () => setCurrentTime(audio.currentTime)
     const onEnded = () => setPlaying(false)
+    const onPlay = () => setPlaying(true)
+    const onPause = () => setPlaying(false)
 
     audio.addEventListener("loadedmetadata", onLoaded)
     audio.addEventListener("timeupdate", onTime)
     audio.addEventListener("ended", onEnded)
+    audio.addEventListener("play", onPlay)
+    audio.addEventListener("pause", onPause)
 
     return () => {
       audio.removeEventListener("loadedmetadata", onLoaded)
       audio.removeEventListener("timeupdate", onTime)
       audio.removeEventListener("ended", onEnded)
+      audio.removeEventListener("play", onPlay)
+      audio.removeEventListener("pause", onPause)
     }
   }, [])
 
   const toggle = useCallback(() => {
     const audio = audioRef.current
     if (!audio) return
-    if (playing) {
-      audio.pause()
+
+    if (audio.paused) {
+      audio.play().catch(() => setPlaying(false))
     } else {
-      audio.play()
+      audio.pause()
     }
-    setPlaying(!playing)
-  }, [playing])
+  }, [])
 
   const seek = useCallback((value: number | readonly number[]) => {
     const audio = audioRef.current
     if (!audio) return
-    const v = Array.isArray(value) ? value[0] : value
-    audio.currentTime = v
-    setCurrentTime(v)
+
+    const moment = Array.isArray(value) ? value[0] : (value as number)
+    audio.currentTime = moment
+    setCurrentTime(moment)
   }, [])
 
   return (
@@ -60,10 +73,15 @@ export function AudioPlayer({ src, onRemove }: AudioPlayerProps) {
         type="button"
         variant="ghost"
         size="icon"
+        aria-label={`${playing ? "Pause" : "Play"} ${label}`}
         className="h-8 w-8 shrink-0"
         onClick={toggle}
       >
-        {playing ? <Pause className="h-4 w-4" /> : <Play className="h-4 w-4" />}
+        {playing ? (
+          <Pause className="h-4 w-4" aria-hidden="true" />
+        ) : (
+          <Play className="h-4 w-4" aria-hidden="true" />
+        )}
       </Button>
 
       <Slider
@@ -71,11 +89,12 @@ export function AudioPlayer({ src, onRemove }: AudioPlayerProps) {
         max={duration || 1}
         step={0.1}
         onValueChange={seek}
+        aria-label={`Seek within ${label}`}
         className="flex-1"
       />
 
       <span className="shrink-0 text-xs text-muted-foreground tabular-nums">
-        {fmt(currentTime)}/{fmt(duration)}
+        {formatDuration(currentTime)}/{formatDuration(duration)}
       </span>
 
       {onRemove && (
@@ -83,19 +102,13 @@ export function AudioPlayer({ src, onRemove }: AudioPlayerProps) {
           type="button"
           variant="ghost"
           size="icon"
+          aria-label={`Remove ${label}`}
           className="h-6 w-6 shrink-0 text-destructive"
           onClick={onRemove}
         >
-          <X className="h-3 w-3" />
+          <X className="h-3 w-3" aria-hidden="true" />
         </Button>
       )}
     </div>
   )
 }
-
-function fmt(seconds: number): string {
-  if (!isFinite(seconds)) return "0:00"
-  const m = Math.floor(seconds / 60)
-  const s = Math.floor(seconds % 60)
-  return `${m}:${s.toString().padStart(2, "0")}`
-}
diff --git a/spa/src/components/media/media-thumbnail.tsx b/spa/src/components/media/media-thumbnail.tsx
index 70bd1bb..d88747c 100644
--- a/spa/src/components/media/media-thumbnail.tsx
+++ b/spa/src/components/media/media-thumbnail.tsx
@@ -2,19 +2,25 @@ import { X } from "lucide-react"
 
 interface MediaThumbnailProps {
   src: string
+  alt: string
   onRemove: () => void
 }
 
-export function MediaThumbnail({ src, onRemove }: MediaThumbnailProps) {
+export function MediaThumbnail({ src, alt, onRemove }: MediaThumbnailProps) {
   return (
     <div className="relative h-20 w-20">
-      <img src={src} alt="" className="h-full w-full rounded-lg object-cover" />
+      <img
+        src={src}
+        alt={alt}
+        className="h-full w-full rounded-lg object-cover"
+      />
       <button
         type="button"
+        aria-label={`Remove ${alt}`}
         onClick={onRemove}
         className="text-destructive-foreground absolute -top-1 -right-1 rounded-full bg-destructive p-0.5"
       >
-        <X className="h-3 w-3" />
+        <X className="h-3 w-3" aria-hidden="true" />
       </button>
     </div>
   )
diff --git a/spa/src/components/media/photo-lightbox.tsx b/spa/src/components/media/photo-lightbox.tsx
new file mode 100644
index 0000000..24e46da
--- /dev/null
+++ b/spa/src/components/media/photo-lightbox.tsx
@@ -0,0 +1,91 @@
+import { useEffect, useState } from "react"
+import { ChevronLeft, ChevronRight } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog"
+
+interface PhotoLightboxProps {
+  urls: string[]
+  /** Which photo to show, or null when the lightbox is closed. */
+  openAt: number | null
+  onClose: () => void
+}
+
+export function PhotoLightbox({ urls, openAt, onClose }: PhotoLightboxProps) {
+  const [index, setIndex] = useState(openAt ?? 0)
+
+  useEffect(() => {
+    if (openAt !== null) setIndex(openAt)
+  }, [openAt])
+
+  const show = (next: number) =>
+    setIndex((next + urls.length) % Math.max(urls.length, 1))
+
+  useEffect(() => {
+    if (openAt === null) return
+
+    const onKey = (event: KeyboardEvent) => {
+      if (event.key === "ArrowLeft") show(index - 1)
+      if (event.key === "ArrowRight") show(index + 1)
+    }
+
+    window.addEventListener("keydown", onKey)
+    return () => window.removeEventListener("keydown", onKey)
+  })
+
+  const many = urls.length > 1
+
+  return (
+    <Dialog open={openAt !== null} onOpenChange={(open) => !open && onClose()}>
+      <DialogContent className="max-w-[95vw] sm:max-w-2xl">
+        <DialogHeader className="sr-only">
+          <DialogTitle>
+            Photo {index + 1} of {urls.length}
+          </DialogTitle>
+          <DialogDescription>A photo attached to this entry.</DialogDescription>
+        </DialogHeader>
+
+        <div className="flex items-center gap-2">
+          {many && (
+            <Button
+              variant="ghost"
+              size="icon"
+              aria-label="Previous photo"
+              onClick={() => show(index - 1)}
+            >
+              <ChevronLeft className="h-5 w-5" aria-hidden="true" />
+            </Button>
+          )}
+
+          <img
+            src={urls[index]}
+            alt={`Photo ${index + 1} of ${urls.length}`}
+            className="max-h-[75svh] w-full rounded-lg object-contain"
+          />
+
+          {many && (
+            <Button
+              variant="ghost"
+              size="icon"
+              aria-label="Next photo"
+              onClick={() => show(index + 1)}
+            >
+              <ChevronRight className="h-5 w-5" aria-hidden="true" />
+            </Button>
+          )}
+        </div>
+
+        {many && (
+          <p className="text-center text-xs text-muted-foreground">
+            {index + 1} of {urls.length}
+          </p>
+        )}
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/spa/src/components/media/photo-picker.tsx b/spa/src/components/media/photo-picker.tsx
index 1004555..51516db 100644
--- a/spa/src/components/media/photo-picker.tsx
+++ b/spa/src/components/media/photo-picker.tsx
@@ -3,8 +3,9 @@ import { ImagePlus } from "lucide-react"
 import { Button } from "@/components/ui/button"
 import { MediaThumbnail } from "./media-thumbnail"
 import { media } from "@/api/client"
+import { usePreviewUrls } from "@/hooks/use-preview-urls"
+import { keyOf, newPendingItem } from "@/lib/media"
 import type { MediaItem } from "@/lib/media"
-import { createPendingItem } from "@/lib/media"
 
 interface PhotoPickerProps {
   items: MediaItem[]
@@ -13,40 +14,43 @@ interface PhotoPickerProps {
 
 export function PhotoPicker({ items, onChange }: PhotoPickerProps) {
   const inputRef = useRef<HTMLInputElement>(null)
+  const previews = usePreviewUrls(items)
 
-  const handleFile = (e: React.ChangeEvent<HTMLInputElement>) => {
-    const file = e.target.files?.[0]
-    if (!file) return
-    onChange([...items, createPendingItem(file)])
-    e.target.value = ""
+  const handleFile = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const chosen = Array.from(event.target.files ?? [])
+    if (chosen.length) onChange([...items, ...chosen.map(newPendingItem)])
+    event.target.value = ""
   }
 
-  const remove = (index: number) => {
-    onChange(items.filter((_, i) => i !== index))
+  const removeAt = (index: number) => {
+    onChange(items.filter((_, position) => position !== index))
   }
 
   return (
     <div className="flex flex-col gap-3">
       {items.length > 0 && (
-        <div className="flex flex-wrap gap-2">
-          {items.map((item, i) => (
-            <MediaThumbnail
-              key={i}
-              src={
-                item.type === "existing"
-                  ? media.photoUrl(item.id)
-                  : item.preview
-              }
-              onRemove={() => remove(i)}
-            />
+        <ul className="flex list-none flex-wrap gap-2 p-0">
+          {items.map((item, index) => (
+            <li key={keyOf(item)}>
+              <MediaThumbnail
+                src={
+                  item.kind === "existing"
+                    ? media.photoUrl(item.id)
+                    : (previews.get(item.localId) ?? "")
+                }
+                alt={`Photo ${index + 1}`}
+                onRemove={() => removeAt(index)}
+              />
+            </li>
           ))}
-        </div>
+        </ul>
       )}
 
       <input
         ref={inputRef}
         type="file"
         accept="image/*"
+        multiple
         onChange={handleFile}
         className="hidden"
       />
@@ -57,7 +61,7 @@ export function PhotoPicker({ items, onChange }: PhotoPickerProps) {
         size="sm"
         onClick={() => inputRef.current?.click()}
       >
-        <ImagePlus className="mr-2 h-4 w-4" />
+        <ImagePlus className="mr-2 h-4 w-4" aria-hidden="true" />
         Add photo
       </Button>
     </div>
diff --git a/spa/src/components/media/voice-memo-picker.tsx b/spa/src/components/media/voice-memo-picker.tsx
index 06c60be..db48b0e 100644
--- a/spa/src/components/media/voice-memo-picker.tsx
+++ b/spa/src/components/media/voice-memo-picker.tsx
@@ -3,9 +3,11 @@ import { FileAudio, Mic, Square } from "lucide-react"
 import { Button } from "@/components/ui/button"
 import { AudioPlayer } from "./audio-player"
 import { media } from "@/api/client"
-import { useVoiceRecorder, formatDuration } from "@/hooks/use-voice-recorder"
+import { usePreviewUrls } from "@/hooks/use-preview-urls"
+import { useVoiceRecorder } from "@/hooks/use-voice-recorder"
+import { formatDuration } from "@/lib/duration"
+import { keyOf, newPendingItem } from "@/lib/media"
 import type { MediaItem } from "@/lib/media"
-import { createPendingItem } from "@/lib/media"
 
 interface VoiceMemoPickerProps {
   items: MediaItem[]
@@ -14,40 +16,42 @@ interface VoiceMemoPickerProps {
 
 export function VoiceMemoPicker({ items, onChange }: VoiceMemoPickerProps) {
   const fileRef = useRef<HTMLInputElement>(null)
+  const previews = usePreviewUrls(items)
 
-  const addFile = (file: File) => {
-    onChange([...items, createPendingItem(file)])
+  const add = (file: File) => onChange([...items, newPendingItem(file)])
+
+  const { recording, duration, start, stop } = useVoiceRecorder(add)
+
+  const handleFile = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const file = event.target.files?.[0]
+    if (file) add(file)
+    event.target.value = ""
   }
 
-  const { recording, duration, start, stop } = useVoiceRecorder(addFile)
-
-  const handleFile = (e: React.ChangeEvent<HTMLInputElement>) => {
-    const file = e.target.files?.[0]
-    if (!file) return
-    addFile(file)
-    e.target.value = ""
-  }
-
-  const remove = (index: number) => {
-    onChange(items.filter((_, i) => i !== index))
+  const removeAt = (index: number) => {
+    onChange(items.filter((_, position) => position !== index))
   }
 
   return (
     <div className="flex flex-col gap-3">
-      {items.map((item, i) => (
+      {items.map((item, index) => (
         <AudioPlayer
-          key={i}
+          key={keyOf(item)}
           src={
-            item.type === "existing"
+            item.kind === "existing"
               ? media.voiceMemoUrl(item.id)
-              : item.preview
+              : (previews.get(item.localId) ?? "")
           }
-          onRemove={() => remove(i)}
+          label={`Voice memo ${index + 1}`}
+          onRemove={() => removeAt(index)}
         />
       ))}
 
       {recording && (
-        <div className="flex items-center gap-3 rounded-lg border border-destructive/50 bg-destructive/10 px-4 py-3">
+        <div
+          role="status"
+          className="flex items-center gap-3 rounded-lg border border-destructive/50 bg-destructive/10 px-4 py-3"
+        >
           <span className="h-2.5 w-2.5 animate-pulse rounded-full bg-destructive" />
           <span className="text-sm font-medium">Recording</span>
           <span className="ml-auto font-mono text-sm">
@@ -73,7 +77,7 @@ export function VoiceMemoPicker({ items, onChange }: VoiceMemoPickerProps) {
             className="flex-1"
             onClick={stop}
           >
-            <Square className="mr-2 h-4 w-4" />
+            <Square className="mr-2 h-4 w-4" aria-hidden="true" />
             Stop
           </Button>
         ) : (
@@ -84,7 +88,7 @@ export function VoiceMemoPicker({ items, onChange }: VoiceMemoPickerProps) {
             className="flex-1"
             onClick={start}
           >
-            <Mic className="mr-2 h-4 w-4" />
+            <Mic className="mr-2 h-4 w-4" aria-hidden="true" />
             Record
           </Button>
         )}
@@ -96,7 +100,7 @@ export function VoiceMemoPicker({ items, onChange }: VoiceMemoPickerProps) {
           onClick={() => fileRef.current?.click()}
           disabled={recording}
         >
-          <FileAudio className="mr-2 h-4 w-4" />
+          <FileAudio className="mr-2 h-4 w-4" aria-hidden="true" />
           Upload
         </Button>
       </div>
diff --git a/spa/src/components/metric/day-stepper.tsx b/spa/src/components/metric/day-stepper.tsx
new file mode 100644
index 0000000..7438432
--- /dev/null
+++ b/spa/src/components/metric/day-stepper.tsx
@@ -0,0 +1,52 @@
+import { addDays, isToday, subDays } from "date-fns"
+import { ChevronLeft, ChevronRight } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Input } from "@/components/ui/input"
+import { formatDate, parseDate, today } from "@/lib/day"
+import { describeDay } from "@/lib/day-label"
+
+interface DayStepperProps {
+  value: string
+  onChange: (date: string) => void
+}
+
+/** Yesterday is one tap away, which is when most readings actually get typed. */
+export function DayStepper({ value, onChange }: DayStepperProps) {
+  const day = parseDate(value)
+  const atToday = isToday(day)
+
+  return (
+    <div className="flex items-center gap-2">
+      <Button
+        variant="ghost"
+        size="icon"
+        aria-label="Previous day"
+        onClick={() => onChange(formatDate(subDays(day, 1)))}
+      >
+        <ChevronLeft className="h-5 w-5" aria-hidden="true" />
+      </Button>
+
+      <div className="flex flex-1 flex-col items-center gap-1">
+        <span className="text-sm font-medium">{describeDay(day)}</span>
+        <Input
+          type="date"
+          aria-label="Day"
+          className="h-8 text-center text-xs"
+          value={value}
+          max={today()}
+          onChange={(event) => onChange(event.target.value)}
+        />
+      </div>
+
+      <Button
+        variant="ghost"
+        size="icon"
+        aria-label="Next day"
+        disabled={atToday}
+        onClick={() => onChange(formatDate(addDays(day, 1)))}
+      >
+        <ChevronRight className="h-5 w-5" aria-hidden="true" />
+      </Button>
+    </div>
+  )
+}
diff --git a/spa/src/components/metric/metrics-editor.tsx b/spa/src/components/metric/metrics-editor.tsx
new file mode 100644
index 0000000..3cf6b2a
--- /dev/null
+++ b/spa/src/components/metric/metrics-editor.tsx
@@ -0,0 +1,114 @@
+import { useState } from "react"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent } from "@/components/ui/card"
+import { METRIC_FIELDS } from "./metric-fields"
+import type { MetricField } from "./metric-fields"
+import { MetricRow } from "./metric-row"
+import { byKind, useSetDailyMetrics } from "@/hooks/use-metrics"
+import { messageFor } from "@/lib/api-message"
+import type { DailyMetricResponse, MetricPayload } from "@/api/schema"
+
+type Drafts = Record<string, string>
+
+function storedText(
+  stored: Map<string, DailyMetricResponse>,
+  field: MetricField
+): string {
+  const reading = stored.get(field.kind)
+  return reading ? String(reading.value) : ""
+}
+
+function saveLabel(changes: number, cleared: number): string {
+  if (changes === 0) return "Nothing to save"
+
+  const plural = changes === 1 ? "" : "s"
+  if (cleared === 0) return `Save ${changes} change${plural}`
+  if (cleared === changes) {
+    return `Clear ${cleared} reading${cleared === 1 ? "" : "s"}`
+  }
+
+  return `Save ${changes} change${plural}, ${cleared} cleared`
+}
+
+function isOutOfRange(field: MetricField, draft: string): boolean {
+  if (draft === "") return false
+
+  const count = Number(draft)
+  return !Number.isInteger(count) || count < field.min || count > field.max
+}
+
+interface MetricsEditorProps {
+  date: string
+  stored: DailyMetricResponse[]
+}
+
+/**
+ * One day's readings. Mounted fresh per day — the drafts are seeded from what
+ * is stored, so there is no second copy of the day's state to keep in step.
+ */
+export function MetricsEditor({ date, stored }: MetricsEditorProps) {
+  const recorded = byKind(stored)
+  const [drafts, setDrafts] = useState<Drafts>(() =>
+    Object.fromEntries(
+      METRIC_FIELDS.map((field) => [field.kind, storedText(recorded, field)])
+    )
+  )
+  const save = useSetDailyMetrics()
+
+  const edited = METRIC_FIELDS.filter(
+    (field) => (drafts[field.kind] ?? "") !== storedText(recorded, field)
+  )
+  const invalid = edited.filter((field) =>
+    isOutOfRange(field, drafts[field.kind] ?? "")
+  )
+
+  const changes: MetricPayload[] = edited
+    .filter((field) => !invalid.includes(field))
+    .map((field) => ({
+      kind: field.kind,
+      value: drafts[field.kind] === "" ? null : Number(drafts[field.kind]),
+    }))
+
+  const cleared = changes.filter((change) => change.value === null).length
+
+  return (
+    <div className="flex flex-col gap-4">
+      <Card>
+        <CardContent className="flex flex-col gap-4 py-4">
+          {METRIC_FIELDS.map((field) => (
+            <MetricRow
+              key={field.kind}
+              field={field}
+              stored={recorded.get(field.kind)}
+              draft={drafts[field.kind] ?? ""}
+              onChange={(draft) =>
+                setDrafts((current) => ({ ...current, [field.kind]: draft }))
+              }
+            />
+          ))}
+        </CardContent>
+      </Card>
+
+      {invalid.length > 0 && (
+        <p role="alert" className="text-xs text-destructive">
+          {invalid.map((field) => field.label).join(", ")}:{" "}
+          {invalid.length === 1 ? "value is" : "values are"} outside the allowed
+          range.
+        </p>
+      )}
+
+      <Button
+        disabled={changes.length === 0 || save.isPending}
+        onClick={() => save.mutate({ date, values: changes })}
+      >
+        {save.isPending ? "Saving…" : saveLabel(changes.length, cleared)}
+      </Button>
+
+      {save.isError && (
+        <p role="alert" className="text-xs text-destructive">
+          {messageFor(save.error)}
+        </p>
+      )}
+    </div>
+  )
+}
diff --git a/spa/src/components/mood/mood-dot.tsx b/spa/src/components/mood/mood-dot.tsx
index 6795a23..878fe92 100644
--- a/spa/src/components/mood/mood-dot.tsx
+++ b/spa/src/components/mood/mood-dot.tsx
@@ -4,23 +4,24 @@ import { cn } from "@/lib/utils"
 interface MoodDotProps {
   value: number
   size?: "sm" | "md"
+  /**
+   * Whether the dot needs to name itself. False where the surrounding control
+   * already says which mood this is, so it is not read out twice.
+   */
+  labelled?: boolean
 }
 
-const BG_COLORS: Record<number, string> = {
-  1: "bg-red-500",
-  2: "bg-orange-500",
-  3: "bg-yellow-500",
-  4: "bg-lime-500",
-  5: "bg-green-500",
-}
+const SIZES = { sm: "h-2 w-2", md: "h-3 w-3" } as const
 
-export function MoodDot({ value, size = "sm" }: MoodDotProps) {
-  const sizes = { sm: "h-2 w-2", md: "h-3 w-3" }
+export function MoodDot({ value, size = "sm", labelled = true }: MoodDotProps) {
+  const mood = getMood(value)
 
   return (
     <span
-      className={cn("inline-block rounded-full", sizes[size], BG_COLORS[value])}
-      title={getMood(value).label}
+      role={labelled ? "img" : undefined}
+      aria-label={labelled ? mood.label : undefined}
+      aria-hidden={labelled ? undefined : true}
+      className={cn("inline-block rounded-full", SIZES[size], mood.background)}
     />
   )
 }
diff --git a/spa/src/components/mood/mood-picker.tsx b/spa/src/components/mood/mood-picker.tsx
index 4416807..dfdb1c9 100644
--- a/spa/src/components/mood/mood-picker.tsx
+++ b/spa/src/components/mood/mood-picker.tsx
@@ -1,3 +1,4 @@
+import { useRef } from "react"
 import { MOODS } from "@/lib/mood"
 import type { MoodValue } from "@/lib/mood"
 import { cn } from "@/lib/utils"
@@ -8,32 +9,79 @@ interface MoodPickerProps {
   size?: "sm" | "md" | "lg"
 }
 
+const SIZES = {
+  sm: "text-2xl p-2",
+  md: "text-4xl p-3",
+  lg: "text-5xl p-4",
+} as const
+
+/**
+ * A radio group, because that is what choosing one of five is. Arrow keys move
+ * between the faces and a single tab stop enters the group, so the picker is
+ * one control rather than five loose buttons.
+ */
 export function MoodPicker({ value, onChange, size = "md" }: MoodPickerProps) {
-  const sizes = {
-    sm: "text-2xl p-2",
-    md: "text-4xl p-3",
-    lg: "text-5xl p-4",
+  const groupRef = useRef<HTMLDivElement>(null)
+
+  const focusAt = (index: number) => {
+    const options =
+      groupRef.current?.querySelectorAll<HTMLButtonElement>("[role='radio']")
+    options?.[(index + MOODS.length) % MOODS.length]?.focus()
   }
 
+  const handleKey = (event: React.KeyboardEvent, index: number) => {
+    const step =
+      event.key === "ArrowRight" || event.key === "ArrowDown"
+        ? 1
+        : event.key === "ArrowLeft" || event.key === "ArrowUp"
+          ? -1
+          : 0
+
+    if (step === 0) return
+
+    event.preventDefault()
+    const next = (index + step + MOODS.length) % MOODS.length
+    onChange(MOODS[next].value)
+    focusAt(next)
+  }
+
+  const focusedIndex = value
+    ? MOODS.findIndex((mood) => mood.value === value)
+    : 0
+
   return (
-    <div className="flex items-center justify-center gap-2">
-      {MOODS.map((mood) => (
-        <button
-          key={mood.value}
-          type="button"
-          onClick={() => onChange(mood.value)}
-          className={cn(
-            "rounded-xl transition-all duration-200",
-            sizes[size],
-            value === mood.value
-              ? "scale-110 ring-2 ring-primary"
-              : "opacity-50 hover:scale-105 hover:opacity-100"
-          )}
-          aria-label={mood.label}
-        >
-          {mood.emoji}
-        </button>
-      ))}
+    <div
+      ref={groupRef}
+      role="radiogroup"
+      aria-label="How are you feeling?"
+      className="flex items-center justify-center gap-2"
+    >
+      {MOODS.map((mood, index) => {
+        const isSelected = value === mood.value
+
+        return (
+          <button
+            key={mood.value}
+            type="button"
+            role="radio"
+            aria-checked={isSelected}
+            aria-label={mood.label}
+            tabIndex={index === focusedIndex ? 0 : -1}
+            onClick={() => onChange(mood.value)}
+            onKeyDown={(event) => handleKey(event, index)}
+            className={cn(
+              "rounded-xl transition-all duration-200",
+              "focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none",
+              SIZES[size],
+              isSelected
+                ? "scale-110 ring-2 ring-primary"
+                : "opacity-60 hover:scale-105 hover:opacity-100"
+            )}
+          >
+            <span aria-hidden="true">{mood.emoji}</span>
+          </button>
+        )
+      })}
     </div>
   )
 }
diff --git a/spa/src/components/offline/connection-banner.tsx b/spa/src/components/offline/connection-banner.tsx
new file mode 100644
index 0000000..be28b72
--- /dev/null
+++ b/spa/src/components/offline/connection-banner.tsx
@@ -0,0 +1,62 @@
+import { CloudUpload, WifiOff } from "lucide-react"
+import { useOnline } from "@/hooks/use-online"
+import { useQueuedEntries } from "@/hooks/use-outbox"
+import { isStuck } from "@/lib/outbox-sync"
+
+/**
+ * Says where unsent work stands. Silent when there is nothing to say — a
+ * permanent banner would be noise on every screen.
+ */
+export function ConnectionBanner() {
+  const online = useOnline()
+  const { data: queued = [] } = useQueuedEntries()
+
+  const stuck = queued.filter(isStuck).length
+  const waiting = queued.length - stuck
+
+  if (online && queued.length === 0) return null
+
+  return (
+    <div
+      role="status"
+      className="flex items-center gap-2 rounded-lg border border-border bg-muted/60 px-3 py-2 text-xs"
+    >
+      {online ? (
+        <CloudUpload className="h-3.5 w-3.5 shrink-0" aria-hidden="true" />
+      ) : (
+        <WifiOff className="h-3.5 w-3.5 shrink-0" aria-hidden="true" />
+      )}
+      <span>{summarise({ online, waiting, stuck })}</span>
+    </div>
+  )
+}
+
+function plural(count: number): string {
+  return count === 1 ? "entry" : "entries"
+}
+
+function summarise({
+  online,
+  waiting,
+  stuck,
+}: {
+  online: boolean
+  waiting: number
+  stuck: number
+}): string {
+  if (!online) {
+    return waiting + stuck > 0
+      ? `Offline. ${waiting + stuck} ${plural(waiting + stuck)} waiting to send.`
+      : "Offline. Anything you log is kept here and sent when you are back."
+  }
+
+  if (stuck > 0 && waiting > 0) {
+    return `Sending ${waiting} ${plural(waiting)}. ${stuck} could not be sent.`
+  }
+
+  if (stuck > 0) {
+    return `${stuck} ${plural(stuck)} could not be sent — review below.`
+  }
+
+  return `Sending ${waiting} ${plural(waiting)}…`
+}
diff --git a/spa/src/components/settings/api-tokens-card.tsx b/spa/src/components/settings/api-tokens-card.tsx
index 57dc715..d15c6a1 100644
--- a/spa/src/components/settings/api-tokens-card.tsx
+++ b/spa/src/components/settings/api-tokens-card.tsx
@@ -1,101 +1,175 @@
 import { useState } from "react"
 import { formatDistanceToNow } from "date-fns"
 import { Trash2 } from "lucide-react"
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert"
+import { Badge } from "@/components/ui/badge"
 import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Checkbox } from "@/components/ui/checkbox"
+import { CollapsibleCard } from "@/components/settings/collapsible-card"
+import {
+  Field,
+  FieldContent,
+  FieldDescription,
+  FieldGroup,
+  FieldLabel,
+  FieldLegend,
+  FieldSet,
+} from "@/components/ui/field"
 import { Input } from "@/components/ui/input"
-import { Label } from "@/components/ui/label"
 import { toast } from "@/components/ui/toast"
 import {
   useApiTokens,
   useMintApiToken,
   useRevokeApiToken,
 } from "@/hooks/use-api-tokens"
-import type { ApiTokenResponse } from "@/api/schema"
+import type { ApiTokenResponse, TokenScope } from "@/api/schema"
 
 const NAME_RULE = /^[a-z0-9-]+$/
 
+const GRANTS: Array<{
+  scope: TokenScope
+  title: string
+  describes: string
+}> = [
+  {
+    scope: "readJournal",
+    title: "Read the journal",
+    describes:
+      "Entries, activities, the calendar, statistics, correlations, cycle records and daily metrics.",
+  },
+  {
+    scope: "writeJournal",
+    title: "Write to the journal",
+    describes:
+      "Create, change and delete entries, activities, cycle records, reminders and media.",
+  },
+  {
+    scope: "writeMetrics",
+    title: "Write daily metrics",
+    describes:
+      "For an importer. Its writes are attributed to the token's own name.",
+  },
+  {
+    scope: "readProfile",
+    title: "Read the profile",
+    describes: "The account's name, timezone, preferences and connections.",
+  },
+]
+
 export function ApiTokensCard() {
   const { data: existing } = useApiTokens()
   const mint = useMintApiToken()
   const revoke = useRevokeApiToken()
 
   const [name, setName] = useState("")
+  const [granted, setGranted] = useState<TokenScope[]>(["writeMetrics"])
   const [justMinted, setJustMinted] = useState<string | null>(null)
 
   const normalised = name.trim().toLowerCase()
-  const canMint = normalised.length > 0 && NAME_RULE.test(normalised)
+  const namedWell = normalised.length > 0 && NAME_RULE.test(normalised)
+  const canMint = namedWell && granted.length > 0
+
+  const toggle = (scope: TokenScope, wanted: boolean) =>
+    setGranted((held) =>
+      wanted ? [...held, scope] : held.filter((one) => one !== scope)
+    )
 
   const submit = () => {
-    mint.mutate(normalised, {
-      onSuccess: (minted) => {
-        setJustMinted(minted.secret)
-        setName("")
-      },
-      onError: (error) =>
-        toast.add({
-          title: error instanceof Error ? error.message : "Could not mint",
-          type: "error",
-        }),
-    })
+    mint.mutate(
+      { name: normalised, scopes: granted },
+      {
+        onSuccess: (minted) => {
+          setJustMinted(minted.secret)
+          setName("")
+          setGranted(["writeMetrics"])
+        },
+        onError: (error) =>
+          toast.add({
+            title: error instanceof Error ? error.message : "Could not mint",
+            type: "error",
+          }),
+      }
+    )
   }
 
   return (
-    <Card>
-      <CardHeader className="pb-2">
-        <CardTitle className="text-sm">Importer tokens</CardTitle>
-      </CardHeader>
-      <CardContent className="flex flex-col gap-3">
-        <p className="text-xs text-muted-foreground">
-          For automations that send daily metrics — a Shortcut, Tasker, a cron
-          script. A token can only write metrics: it cannot read your entries or
-          touch your account. Tokens do not expire, so revoke any you stop
-          using.
-        </p>
-
+    <CollapsibleCard
+      title="Access tokens"
+      description="For automations and other clients — a widget, a Shortcut, a cron script."
+      summary={
+        existing?.length ? (
+          <Badge variant="secondary">{existing.length}</Badge>
+        ) : undefined
+      }
+    >
+      <FieldGroup>
         {justMinted && (
-          <div className="flex flex-col gap-1.5 rounded-md border border-dashed p-3">
-            <Label className="text-xs">
-              Copy this now — it is not shown again
-            </Label>
-            <code className="text-xs break-all">{justMinted}</code>
-            <Button
-              variant="outline"
-              size="sm"
-              onClick={() => setJustMinted(null)}
-            >
-              Done
-            </Button>
-          </div>
+          <Alert>
+            <AlertTitle>Copy this now — it is not shown again</AlertTitle>
+            <AlertDescription>
+              <code className="break-all">{justMinted}</code>
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => setJustMinted(null)}
+              >
+                Done
+              </Button>
+            </AlertDescription>
+          </Alert>
         )}
 
-        <div className="flex flex-col gap-1.5">
-          <Label className="text-xs">
-            Name — becomes the source recorded on its data
-          </Label>
-          <div className="flex gap-2">
-            <Input
-              placeholder="iphone-shortcuts"
-              value={name}
-              onChange={(event) => setName(event.target.value)}
-            />
-            <Button
-              size="sm"
-              disabled={!canMint || mint.isPending}
-              onClick={submit}
-            >
-              {mint.isPending ? "Minting…" : "Mint"}
-            </Button>
-          </div>
-          {normalised.length > 0 && !canMint && (
-            <span className="text-xs text-destructive">
-              Lowercase letters, digits and hyphens only.
-            </span>
+        <Field data-invalid={normalised.length > 0 && !namedWell}>
+          <FieldLabel htmlFor="token-name">Name</FieldLabel>
+          <Input
+            id="token-name"
+            placeholder="plasma-widget"
+            value={name}
+            aria-invalid={normalised.length > 0 && !namedWell}
+            onChange={(event) => setName(event.target.value)}
+          />
+          <FieldDescription>
+            Becomes the source recorded on any metrics it writes. Lowercase
+            letters, digits and hyphens.
+          </FieldDescription>
+        </Field>
+
+        <FieldSet>
+          <FieldLegend variant="label">What it may do</FieldLegend>
+          <FieldGroup className="gap-3">
+            {GRANTS.map((grant) => (
+              <Field key={grant.scope} orientation="horizontal">
+                <Checkbox
+                  id={`scope-${grant.scope}`}
+                  checked={granted.includes(grant.scope)}
+                  onCheckedChange={(wanted) =>
+                    toggle(grant.scope, wanted === true)
+                  }
+                />
+                <FieldContent>
+                  <FieldLabel htmlFor={`scope-${grant.scope}`}>
+                    {grant.title}
+                  </FieldLabel>
+                  <FieldDescription>{grant.describes}</FieldDescription>
+                </FieldContent>
+              </Field>
+            ))}
+          </FieldGroup>
+        </FieldSet>
+
+        <Field orientation="horizontal">
+          <Button disabled={!canMint || mint.isPending} onClick={submit}>
+            {mint.isPending ? "Minting…" : "Mint token"}
+          </Button>
+          {granted.length === 0 && (
+            <FieldDescription>
+              Tick at least one thing for it to do.
+            </FieldDescription>
           )}
-        </div>
+        </Field>
 
         {existing?.length ? (
-          <div className="flex flex-col gap-2">
+          <FieldGroup className="gap-3">
             {existing.map((token) => (
               <TokenRow
                 key={token.id}
@@ -103,12 +177,12 @@ export function ApiTokensCard() {
                 onRevoke={() => revoke.mutate(token.id)}
               />
             ))}
-          </div>
+          </FieldGroup>
         ) : (
-          <span className="text-xs text-muted-foreground">No tokens yet.</span>
+          <FieldDescription>No tokens yet.</FieldDescription>
         )}
-      </CardContent>
-    </Card>
+      </FieldGroup>
+    </CollapsibleCard>
   )
 }
 
@@ -124,14 +198,33 @@ function TokenRow({
     : "never used"
 
   return (
-    <div className="flex items-center justify-between gap-2">
-      <div className="flex min-w-0 flex-col">
-        <span className="truncate text-xs font-medium">{token.name}</span>
-        <span className="text-[10px] text-muted-foreground">{lastUsed}</span>
-      </div>
+    <Field orientation="horizontal">
+      <FieldContent>
+        <FieldTitleRow name={token.name} scopes={token.scopes} />
+        <FieldDescription>{lastUsed}</FieldDescription>
+      </FieldContent>
       <Button variant="ghost" size="icon" onClick={onRevoke}>
-        <Trash2 className="h-4 w-4 text-destructive" />
+        <Trash2 className="text-destructive" />
       </Button>
+    </Field>
+  )
+}
+
+function FieldTitleRow({
+  name,
+  scopes,
+}: {
+  name: string
+  scopes: TokenScope[]
+}) {
+  return (
+    <div className="flex flex-wrap items-center gap-1.5">
+      <span className="truncate text-xs font-medium">{name}</span>
+      {scopes.map((scope) => (
+        <Badge key={scope} variant="secondary">
+          {scope}
+        </Badge>
+      ))}
     </div>
   )
 }
diff --git a/spa/src/components/settings/collapsible-card.tsx b/spa/src/components/settings/collapsible-card.tsx
new file mode 100644
index 0000000..bf5fc3b
--- /dev/null
+++ b/spa/src/components/settings/collapsible-card.tsx
@@ -0,0 +1,50 @@
+import type { ReactNode } from "react"
+import { ChevronDown } from "lucide-react"
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from "@/components/ui/card"
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from "@/components/ui/collapsible"
+
+export function CollapsibleCard({
+  title,
+  description,
+  summary,
+  defaultOpen = false,
+  children,
+}: {
+  title: string
+  description?: string
+  summary?: ReactNode
+  defaultOpen?: boolean
+  children: ReactNode
+}) {
+  return (
+    <Card>
+      <Collapsible defaultOpen={defaultOpen}>
+        <CardHeader>
+          <CollapsibleTrigger className="group flex w-full cursor-pointer items-center justify-between gap-3 text-left">
+            <div className="flex min-w-0 flex-col gap-1">
+              <CardTitle className="text-sm">{title}</CardTitle>
+              {description && <CardDescription>{description}</CardDescription>}
+            </div>
+            <div className="flex shrink-0 items-center gap-2">
+              {summary}
+              <ChevronDown className="size-4 text-muted-foreground transition-transform duration-200 group-data-[panel-open]:rotate-180" />
+            </div>
+          </CollapsibleTrigger>
+        </CardHeader>
+        <CollapsibleContent className="h-[var(--collapsible-panel-height)] overflow-hidden transition-[height] duration-200 data-[ending-style]:h-0 data-[starting-style]:h-0">
+          <CardContent>{children}</CardContent>
+        </CollapsibleContent>
+      </Collapsible>
+    </Card>
+  )
+}
diff --git a/spa/src/components/settings/server-card.tsx b/spa/src/components/settings/server-card.tsx
new file mode 100644
index 0000000..f7c858f
--- /dev/null
+++ b/spa/src/components/settings/server-card.tsx
@@ -0,0 +1,24 @@
+import { Badge } from "@/components/ui/badge"
+import { CollapsibleCard } from "@/components/settings/collapsible-card"
+import { ServerPicker } from "@/components/settings/server-picker"
+import { isServerChosen, serverUrl } from "@/api/server-url"
+import { useServerInfo } from "@/hooks/use-server"
+
+export function ServerCard() {
+  const { data: info } = useServerInfo()
+  const elsewhere = isServerChosen()
+
+  return (
+    <CollapsibleCard
+      title="Server"
+      description="This app talks to whichever k-mood server you point it at."
+      summary={
+        <Badge variant={elsewhere ? "secondary" : "outline"}>
+          {elsewhere ? serverUrl() : "this site"}
+        </Badge>
+      }
+    >
+      <ServerPicker version={info?.version} />
+    </CollapsibleCard>
+  )
+}
diff --git a/spa/src/components/settings/server-picker.tsx b/spa/src/components/settings/server-picker.tsx
new file mode 100644
index 0000000..cac1b0e
--- /dev/null
+++ b/spa/src/components/settings/server-picker.tsx
@@ -0,0 +1,94 @@
+import { useState } from "react"
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert"
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import {
+  Field,
+  FieldDescription,
+  FieldGroup,
+  FieldLabel,
+} from "@/components/ui/field"
+import { Input } from "@/components/ui/input"
+import { Spinner } from "@/components/ui/spinner"
+import {
+  forgetServer,
+  isServerChosen,
+  looksLikeAServer,
+  reachable,
+  rememberServer,
+  serverUrl,
+} from "@/api/server-url"
+
+type Checking = "idle" | "asking" | "unreachable"
+
+export function ServerPicker({ version }: { version?: string }) {
+  const current = serverUrl()
+  const chosen = isServerChosen()
+
+  const [typed, setTyped] = useState(current)
+  const [checking, setChecking] = useState<Checking>("idle")
+
+  const tidy = typed.trim()
+  const usable = looksLikeAServer(tidy) && tidy !== current
+
+  const connect = async () => {
+    setChecking("asking")
+
+    if (await reachable(tidy)) {
+      rememberServer(tidy)
+      return
+    }
+
+    setChecking("unreachable")
+  }
+
+  return (
+    <FieldGroup>
+      <Field orientation="horizontal">
+        <FieldLabel>Connected to</FieldLabel>
+        <Badge variant="secondary">{current || "this site"}</Badge>
+        {version && <Badge variant="outline">v{version}</Badge>}
+      </Field>
+
+      <Field>
+        <FieldLabel htmlFor="server-url">Address</FieldLabel>
+        <Input
+          id="server-url"
+          placeholder="https://k-mood.example.com"
+          value={typed}
+          aria-invalid={tidy.length > 0 && !looksLikeAServer(tidy)}
+          onChange={(event) => {
+            setTyped(event.target.value)
+            setChecking("idle")
+          }}
+        />
+        <FieldDescription>
+          The server must allow this site as a CORS origin, which whoever runs
+          it sets in its configuration.
+        </FieldDescription>
+      </Field>
+
+      {checking === "unreachable" && (
+        <Alert variant="destructive">
+          <AlertTitle>No k-mood server answered</AlertTitle>
+          <AlertDescription>
+            Nothing responded at that address, or it refused this site as an
+            origin. The address was not saved.
+          </AlertDescription>
+        </Alert>
+      )}
+
+      <Field orientation="horizontal">
+        <Button disabled={!usable || checking === "asking"} onClick={connect}>
+          {checking === "asking" && <Spinner data-icon="inline-start" />}
+          Connect
+        </Button>
+        {chosen && (
+          <Button variant="outline" onClick={forgetServer}>
+            Use this site again
+          </Button>
+        )}
+      </Field>
+    </FieldGroup>
+  )
+}
diff --git a/spa/src/components/settings/subsonic-card.tsx b/spa/src/components/settings/subsonic-card.tsx
index d4cc579..5d7075e 100644
--- a/spa/src/components/settings/subsonic-card.tsx
+++ b/spa/src/components/settings/subsonic-card.tsx
@@ -1,8 +1,15 @@
 import { useState } from "react"
+import { Badge } from "@/components/ui/badge"
 import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import {
+  Field,
+  FieldDescription,
+  FieldGroup,
+  FieldLabel,
+} from "@/components/ui/field"
 import { Input } from "@/components/ui/input"
 import { toast } from "@/components/ui/toast"
+import { CollapsibleCard } from "@/components/settings/collapsible-card"
 import {
   useConnectProvider,
   useDisconnectProvider,
@@ -37,58 +44,74 @@ export function SubsonicCard() {
   }
 
   return (
-    <Card>
-      <CardHeader className="pb-2">
-        <CardTitle className="text-sm">Music</CardTitle>
-      </CardHeader>
-      <CardContent className="space-y-3">
-        {connected ? (
-          <div className="flex items-center justify-between gap-3">
-            <p className="text-sm text-muted-foreground">
+    <CollapsibleCard
+      title="Music"
+      description="Connect your own Subsonic server to fill in what you were listening to."
+      summary={
+        <Badge variant={connected ? "secondary" : "outline"}>
+          {connected ? "connected" : "not connected"}
+        </Badge>
+      }
+    >
+      {connected ? (
+        <FieldGroup>
+          <Field orientation="horizontal">
+            <FieldDescription>
               Subsonic is connected. Your password is stored encrypted and is
               never shown again.
-            </p>
+            </FieldDescription>
             <Button
               variant="outline"
-              size="sm"
               onClick={() => disconnect.mutate()}
               disabled={disconnect.isPending}
             >
               Disconnect
             </Button>
-          </div>
-        ) : (
-          <>
-            <p className="text-xs text-muted-foreground">
-              Connect your own Subsonic server to fill in what you were
-              listening to.
-            </p>
+          </Field>
+        </FieldGroup>
+      ) : (
+        <FieldGroup>
+          <Field>
+            <FieldLabel htmlFor="subsonic-url">Address</FieldLabel>
             <Input
+              id="subsonic-url"
               placeholder="https://music.example.com"
               value={url}
               onChange={(e) => setUrl(e.target.value)}
             />
+          </Field>
+          <Field>
+            <FieldLabel htmlFor="subsonic-username">Username</FieldLabel>
             <Input
-              placeholder="Username"
+              id="subsonic-username"
               value={username}
               onChange={(e) => setUsername(e.target.value)}
+              autoComplete="off"
             />
+          </Field>
+          <Field>
+            <FieldLabel htmlFor="subsonic-password">Password</FieldLabel>
             <Input
+              id="subsonic-password"
               type="password"
-              placeholder="Password"
               value={password}
               onChange={(e) => setPassword(e.target.value)}
+              autoComplete="off"
             />
+            <FieldDescription>
+              Stored encrypted, and never shown again once saved.
+            </FieldDescription>
+          </Field>
+          <Field orientation="horizontal">
             <Button
-              size="sm"
               onClick={submit}
               disabled={connect.isPending || !url || !username || !password}
             >
               {connect.isPending ? "Connecting…" : "Connect"}
             </Button>
-          </>
-        )}
-      </CardContent>
-    </Card>
+          </Field>
+        </FieldGroup>
+      )}
+    </CollapsibleCard>
   )
 }
diff --git a/spa/src/components/stats/heatmap-section.tsx b/spa/src/components/stats/heatmap-section.tsx
new file mode 100644
index 0000000..851dc87
--- /dev/null
+++ b/spa/src/components/stats/heatmap-section.tsx
@@ -0,0 +1,50 @@
+import { useState } from "react"
+import { ChevronLeft, ChevronRight } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Skeleton } from "@/components/ui/skeleton"
+import { MoodHeatmap } from "./mood-heatmap"
+import { useYearCalendar } from "@/hooks/use-year-calendar"
+import { useDateBounds } from "@/hooks/use-date-bounds"
+
+export function HeatmapSection() {
+  const thisYear = new Date().getFullYear()
+  const [year, setYear] = useState(thisYear)
+  const { data: days, isLoading } = useYearCalendar(year)
+  const { data: bounds } = useDateBounds()
+
+  const earliestYear = bounds?.oldest.getFullYear() ?? thisYear
+
+  return (
+    <section className="flex flex-col gap-4">
+      <div className="flex items-center justify-between">
+        <Button
+          variant="ghost"
+          size="icon"
+          aria-label={`Show ${year - 1}`}
+          onClick={() => setYear((current) => current - 1)}
+          disabled={year <= earliestYear}
+        >
+          <ChevronLeft className="h-5 w-5" aria-hidden="true" />
+        </Button>
+        <span className="text-sm font-medium" aria-live="polite">
+          {year}
+        </span>
+        <Button
+          variant="ghost"
+          size="icon"
+          aria-label={`Show ${year + 1}`}
+          onClick={() => setYear((current) => current + 1)}
+          disabled={year >= thisYear}
+        >
+          <ChevronRight className="h-5 w-5" aria-hidden="true" />
+        </Button>
+      </div>
+
+      {isLoading ? (
+        <Skeleton className="h-32" />
+      ) : days ? (
+        <MoodHeatmap year={year} days={days} />
+      ) : null}
+    </section>
+  )
+}
diff --git a/spa/src/components/stats/mood-distribution.tsx b/spa/src/components/stats/mood-distribution.tsx
index b43bf39..b4d83d5 100644
--- a/spa/src/components/stats/mood-distribution.tsx
+++ b/spa/src/components/stats/mood-distribution.tsx
@@ -1,27 +1,21 @@
 import { Cell, Pie, PieChart, ResponsiveContainer } from "recharts"
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
 import { getMood } from "@/lib/mood"
-import type { MoodFrequency } from "@/api/schema"
+import type { MoodFrequencyResponse } from "@/api/schema"
 
 interface MoodDistributionProps {
-  frequency: MoodFrequency[]
-}
-
-const COLORS: Record<number, string> = {
-  1: "#ef4444",
-  2: "#f97316",
-  3: "#eab308",
-  4: "#84cc16",
-  5: "#22c55e",
+  frequency: MoodFrequencyResponse[]
 }
 
 export function MoodDistribution({ frequency }: MoodDistributionProps) {
   if (!frequency.length) return null
 
-  const data = frequency.map((f) => ({
-    name: getMood(f.mood).emoji + " " + f.moodLabel,
-    value: f.count,
-    mood: f.mood,
+  const data = frequency.map((entry) => ({
+    label: entry.moodLabel,
+    emoji: getMood(entry.mood).emoji,
+    swatch: getMood(entry.mood).swatch,
+    value: entry.count,
+    mood: entry.mood,
   }))
 
   const total = data.reduce((sum, d) => sum + d.value, 0)
@@ -33,37 +27,41 @@ export function MoodDistribution({ frequency }: MoodDistributionProps) {
       </CardHeader>
       <CardContent>
         <div className="flex items-center gap-4">
-          <ResponsiveContainer width={120} height={120}>
-            <PieChart>
-              <Pie
-                data={data}
-                dataKey="value"
-                cx="50%"
-                cy="50%"
-                innerRadius={30}
-                outerRadius={55}
-                strokeWidth={2}
-              >
-                {data.map((d) => (
-                  <Cell key={d.mood} fill={COLORS[d.mood]} />
-                ))}
-              </Pie>
-            </PieChart>
-          </ResponsiveContainer>
-          <div className="flex flex-col gap-1.5">
-            {data.map((d) => (
-              <div key={d.mood} className="flex items-center gap-2 text-sm">
-                <span
-                  className="h-2.5 w-2.5 shrink-0 rounded-full"
-                  style={{ backgroundColor: COLORS[d.mood] }}
-                />
-                <span className="text-foreground">{d.name}</span>
-                <span className="text-foreground/70">
-                  {d.value} ({Math.round((d.value / total) * 100)}%)
-                </span>
-              </div>
-            ))}
+          <div aria-hidden="true">
+            <ResponsiveContainer width={120} height={120}>
+              <PieChart>
+                <Pie
+                  data={data}
+                  dataKey="value"
+                  cx="50%"
+                  cy="50%"
+                  innerRadius={30}
+                  outerRadius={55}
+                  strokeWidth={2}
+                >
+                  {data.map((slice) => (
+                    <Cell key={slice.mood} fill={slice.swatch} />
+                  ))}
+                </Pie>
+              </PieChart>
+            </ResponsiveContainer>
           </div>
+          <ul className="flex list-none flex-col gap-1.5 p-0">
+            {data.map((slice) => (
+              <li key={slice.mood} className="flex items-center gap-2 text-sm">
+                <span
+                  aria-hidden="true"
+                  className="h-2.5 w-2.5 shrink-0 rounded-full"
+                  style={{ backgroundColor: slice.swatch }}
+                />
+                <span aria-hidden="true">{slice.emoji}</span>
+                <span className="text-foreground">{slice.label}</span>
+                <span className="text-foreground/70">
+                  {slice.value} ({Math.round((slice.value / total) * 100)}%)
+                </span>
+              </li>
+            ))}
+          </ul>
         </div>
       </CardContent>
     </Card>
diff --git a/spa/src/components/stats/mood-heatmap.tsx b/spa/src/components/stats/mood-heatmap.tsx
index 8ad7137..d97a7d7 100644
--- a/spa/src/components/stats/mood-heatmap.tsx
+++ b/spa/src/components/stats/mood-heatmap.tsx
@@ -9,7 +9,9 @@ import {
 } from "date-fns"
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
 import { cn } from "@/lib/utils"
-import { getMood } from "@/lib/mood"
+import { getMood, nearestMood } from "@/lib/mood"
+import { rowOfWeek, weekStartsOn } from "@/lib/week"
+import { formatDate } from "@/lib/day"
 import type { CalendarDayResponse } from "@/api/schema"
 
 interface MoodHeatmapProps {
@@ -17,14 +19,6 @@ interface MoodHeatmapProps {
   days: CalendarDayResponse[]
 }
 
-const MOOD_BG: Record<number, string> = {
-  1: "bg-red-500",
-  2: "bg-orange-400",
-  3: "bg-yellow-400",
-  4: "bg-lime-400",
-  5: "bg-green-500",
-}
-
 const MONTH_LABELS = [
   "Jan",
   "Feb",
@@ -52,7 +46,7 @@ export function MoodHeatmap({ year, days }: MoodHeatmapProps) {
   }
 
   const allDays = eachDayOfInterval({ start: yearStart, end: yearEnd })
-  const weekStart = startOfWeek(yearStart)
+  const weekStart = startOfWeek(yearStart, { weekStartsOn: weekStartsOn() })
   const totalWeeks = differenceInWeeks(yearEnd, weekStart) + 1
 
   const grid: (Date | null)[][] = Array.from({ length: 7 }, () =>
@@ -61,7 +55,7 @@ export function MoodHeatmap({ year, days }: MoodHeatmapProps) {
 
   for (const day of allDays) {
     const weekIndex = differenceInWeeks(day, weekStart)
-    const dayIndex = getDay(day)
+    const dayIndex = rowOfWeek(getDay(day))
     grid[dayIndex][weekIndex] = day
   }
 
@@ -71,9 +65,10 @@ export function MoodHeatmap({ year, days }: MoodHeatmapProps) {
         <CardTitle className="text-sm">Mood heatmap — {year}</CardTitle>
       </CardHeader>
       <CardContent className="overflow-x-auto">
-        <div className="flex min-w-[640px] gap-0.5">
+        <p className="sr-only">{summarise(year, moodMap)}</p>
+        <div aria-hidden="true" className="flex min-w-[640px] gap-0.5">
           <div className="flex flex-col gap-0.5 pr-1 text-[9px] text-muted-foreground">
-            {["", "Mon", "", "Wed", "", "Fri", ""].map((label, i) => (
+            {rowLabels().map((label, i) => (
               <div key={i} className="h-[11px] leading-[11px]">
                 {label}
               </div>
@@ -105,7 +100,7 @@ export function MoodHeatmap({ year, days }: MoodHeatmapProps) {
                     return <div key={weekIdx} className="h-[11px] w-[11px]" />
                   }
 
-                  const dateStr = format(day, "yyyy-MM-dd")
+                  const dateStr = formatDate(day)
                   const mood = moodMap.get(dateStr)
 
                   return (
@@ -113,7 +108,7 @@ export function MoodHeatmap({ year, days }: MoodHeatmapProps) {
                       key={weekIdx}
                       className={cn(
                         "h-[11px] w-[11px] rounded-[2px]",
-                        mood ? MOOD_BG[mood] : "bg-muted/30"
+                        mood ? getMood(mood).background : "bg-muted/30"
                       )}
                       title={
                         mood
@@ -134,7 +129,10 @@ export function MoodHeatmap({ year, days }: MoodHeatmapProps) {
           {[1, 2, 3, 4, 5].map((m) => (
             <div
               key={m}
-              className={cn("h-[11px] w-[11px] rounded-[2px]", MOOD_BG[m])}
+              className={cn(
+                "h-[11px] w-[11px] rounded-[2px]",
+                getMood(m).background
+              )}
               title={getMood(m).label}
             />
           ))}
@@ -144,3 +142,29 @@ export function MoodHeatmap({ year, days }: MoodHeatmapProps) {
     </Card>
   )
 }
+
+/**
+ * The grid is 365 coloured squares — as tab stops it would be unusable, and
+ * read out one by one it would be meaningless. This says the same thing in a
+ * sentence; the calendar is where a screen reader goes for a given day.
+ */
+function summarise(year: number, moods: Map<string, number>): string {
+  const logged = moods.size
+
+  if (logged === 0) return `Mood heatmap for ${year}. Nothing logged.`
+
+  const total = Array.from(moods.values()).reduce((sum, mood) => sum + mood, 0)
+  const average = nearestMood(total / logged)
+
+  return `Mood heatmap for ${year}. ${logged} ${
+    logged === 1 ? "day" : "days"
+  } logged, mostly ${average.label.toLowerCase()}.`
+}
+
+/** Every other row is named, starting from whichever day the week starts on. */
+function rowLabels(): string[] {
+  const short = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+  const start = weekStartsOn()
+
+  return short.map((_, row) => (row % 2 === 1 ? short[(row + start) % 7] : ""))
+}
diff --git a/spa/src/components/stats/mood-summary.tsx b/spa/src/components/stats/mood-summary.tsx
new file mode 100644
index 0000000..0d03a37
--- /dev/null
+++ b/spa/src/components/stats/mood-summary.tsx
@@ -0,0 +1,43 @@
+import { StatCard } from "./stat-card"
+import { nearestMood } from "@/lib/mood"
+import type { MoodStatsResponse } from "@/api/schema"
+
+const NO_VALUE = "—"
+
+/**
+ * Average, streak and total, shown the same way wherever they appear — the
+ * dashboard and the statistics page were drifting into two different readings
+ * of the same three numbers.
+ */
+export function MoodSummary({ stats }: { stats: MoodStatsResponse }) {
+  const mood = stats.average === null ? null : nearestMood(stats.average)
+
+  return (
+    <div className="grid grid-cols-3 gap-3">
+      <StatCard
+        label="Average"
+        value={
+          mood ? (
+            <span className="inline-flex items-baseline gap-1">
+              <span aria-hidden="true">{mood.emoji}</span>
+              <span>{stats.average?.toFixed(1)}</span>
+            </span>
+          ) : (
+            NO_VALUE
+          )
+        }
+        valueLabel={
+          mood
+            ? `Average mood ${stats.average?.toFixed(1)} out of 5, ${mood.label}`
+            : "No average yet"
+        }
+      />
+      <StatCard
+        label="Streak"
+        value={`${stats.currentStreak}d`}
+        valueLabel={`${stats.currentStreak} day streak`}
+      />
+      <StatCard label="Entries" value={stats.totalEntries} />
+    </div>
+  )
+}
diff --git a/spa/src/components/stats/mood-trend-chart.tsx b/spa/src/components/stats/mood-trend-chart.tsx
index 0f1af6b..1e09c1d 100644
--- a/spa/src/components/stats/mood-trend-chart.tsx
+++ b/spa/src/components/stats/mood-trend-chart.tsx
@@ -1,4 +1,4 @@
-import { format, startOfWeek, startOfMonth } from "date-fns"
+import { useMemo } from "react"
 import {
   Area,
   AreaChart,
@@ -9,24 +9,35 @@ import {
   YAxis,
 } from "recharts"
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
-import { getMoodEmoji } from "@/lib/mood"
+import { BEST_MOOD, MIDDLE_MOOD, WORST_MOOD, getMoodEmoji } from "@/lib/mood"
+import { aggregateTrend, bucketFor } from "@/lib/trend-buckets"
+import type { TrendBar } from "@/lib/trend-buckets"
+import type { TrendPoint } from "@/hooks/use-trend"
+import type { Period } from "@/lib/period"
+
+const GRADIENT_ID = "moodTrendGradient"
+const MAX_POINTS_WITH_DOTS = 60
+const AXIS_PADDING = 0.5
 
 interface MoodTrendChartProps {
-  entries: Array<{ loggedAt: string; mood: number }>
-  period?: "week" | "month" | "year" | "all"
+  points: TrendPoint[]
+  period: Period
   title?: string
 }
 
 export function MoodTrendChart({
-  entries,
-  period = "month",
+  points,
+  period,
   title = "Mood over time",
 }: MoodTrendChartProps) {
-  const data = aggregate(entries, period)
+  const bars = useMemo(
+    () => aggregateTrend(points, bucketFor(period, points.length)),
+    [points, period]
+  )
 
-  if (data.length === 0) return null
+  if (bars.length === 0) return null
 
-  const showDots = data.length <= 60
+  const showDots = bars.length <= MAX_POINTS_WITH_DOTS
 
   return (
     <Card>
@@ -36,79 +47,71 @@ export function MoodTrendChart({
       <CardContent>
         <ResponsiveContainer width="100%" height={220}>
           <AreaChart
-            data={data}
+            data={bars}
             margin={{ top: 5, right: 5, bottom: 0, left: -10 }}
           >
             <defs>
-              <linearGradient id="moodGradient" x1="0" y1="0" x2="0" y2="1">
-                <stop offset="0%" stopColor="#22c55e" stopOpacity={0.4} />
-                <stop offset="50%" stopColor="#eab308" stopOpacity={0.2} />
-                <stop offset="100%" stopColor="#ef4444" stopOpacity={0.05} />
+              <linearGradient id={GRADIENT_ID} x1="0" y1="0" x2="0" y2="1">
+                <stop
+                  offset="0%"
+                  stopColor={BEST_MOOD.swatch}
+                  stopOpacity={0.4}
+                />
+                <stop
+                  offset="50%"
+                  stopColor={MIDDLE_MOOD.swatch}
+                  stopOpacity={0.2}
+                />
+                <stop
+                  offset="100%"
+                  stopColor={WORST_MOOD.swatch}
+                  stopOpacity={0.05}
+                />
               </linearGradient>
             </defs>
             <CartesianGrid
               strokeDasharray="3 3"
-              stroke="hsl(var(--border))"
+              stroke="var(--border)"
               vertical={false}
             />
             <XAxis
               dataKey="label"
-              tick={{ fontSize: 11, fill: "white" }}
+              tick={{ fontSize: 11, fill: "var(--foreground)" }}
               tickLine={false}
               axisLine={false}
               interval="preserveStartEnd"
               minTickGap={50}
             />
             <YAxis
-              domain={[0.5, 5.5]}
+              domain={[
+                WORST_MOOD.value - AXIS_PADDING,
+                BEST_MOOD.value + AXIS_PADDING,
+              ]}
               ticks={[1, 2, 3, 4, 5]}
               tick={{ fontSize: 14 }}
-              tickFormatter={(v) => getMoodEmoji(v)}
+              tickFormatter={getMoodEmoji}
               tickLine={false}
               axisLine={false}
               width={32}
             />
-            <Tooltip
-              content={(props) => {
-                const { active, payload } = props as {
-                  active?: boolean
-                  payload?: ReadonlyArray<{ payload: DataPoint }>
-                }
-
-                if (!active || !payload?.length) return null
-
-                const d = payload[0].payload
-                const mood = Math.round(d.avg)
-                return (
-                  <div className="rounded-lg border bg-background px-3 py-2 text-sm shadow-md">
-                    <p className="font-medium">{d.tooltip}</p>
-                    <p>
-                      {getMoodEmoji(mood)} {d.avg.toFixed(1)} avg
-                      <span className="ml-1 text-muted-foreground">
-                        ({d.count} {d.count === 1 ? "entry" : "entries"})
-                      </span>
-                    </p>
-                  </div>
-                )
-              }}
-            />
+            <Tooltip content={<TrendTooltip />} />
             <Area
               type="natural"
-              dataKey="avg"
-              stroke="#22c55e"
-              fill="url(#moodGradient)"
+              dataKey="average"
+              stroke={BEST_MOOD.swatch}
+              fill={`url(#${GRADIENT_ID})`}
               strokeWidth={2}
               dot={
                 showDots
                   ? {
                       r: 2.5,
-                      fill: "hsl(var(--background))",
-                      stroke: "#22c55e",
+                      fill: "var(--popover)",
+                      stroke: BEST_MOOD.swatch,
                       strokeWidth: 1.5,
                     }
                   : false
               }
-              activeDot={{ r: 4, fill: "#22c55e" }}
+              activeDot={{ r: 4, fill: BEST_MOOD.swatch }}
             />
           </AreaChart>
         </ResponsiveContainer>
@@ -117,67 +120,25 @@ export function MoodTrendChart({
   )
 }
 
-interface DataPoint {
-  label: string
-  tooltip: string
-  avg: number
-  count: number
-}
-
-function aggregate(
-  entries: Array<{ loggedAt: string; mood: number }>,
-  period: string
-): DataPoint[] {
-  if (period === "year" || period === "all") {
-    return entries.length > 365
-      ? aggregateBy(entries, "month")
-      : aggregateBy(entries, "week")
-  }
-  return aggregateBy(entries, "day")
-}
-
-function aggregateBy(
-  entries: Array<{ loggedAt: string; mood: number }>,
-  bucket: "day" | "week" | "month"
-): DataPoint[] {
-  const groups = new Map<
-    string,
-    { moods: number[]; label: string; tooltip: string }
-  >()
-
-  for (const e of entries) {
-    const d = new Date(e.loggedAt)
-    let key: string
-    let label: string
-    let tooltip: string
-
-    if (bucket === "month") {
-      key = format(startOfMonth(d), "yyyy-MM")
-      label = format(d, "MMM yyyy")
-      tooltip = format(d, "MMMM yyyy")
-    } else if (bucket === "week") {
-      const week = startOfWeek(d)
-      key = format(week, "yyyy-MM-dd")
-      label = format(week, "MMM d")
-      tooltip = `Week of ${format(week, "MMM d, yyyy")}`
-    } else {
-      key = format(d, "yyyy-MM-dd")
-      label = format(d, "MMM d")
-      tooltip = format(d, "EEE, MMM d")
-    }
-
-    if (!groups.has(key)) {
-      groups.set(key, { moods: [], label, tooltip })
-    }
-    groups.get(key)!.moods.push(e.mood)
+function TrendTooltip(props: unknown) {
+  const { active, payload } = props as {
+    active?: boolean
+    payload?: ReadonlyArray<{ payload: TrendBar }>
   }
 
-  return Array.from(groups.entries())
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([_, { moods, label, tooltip }]) => ({
-      label,
-      tooltip,
-      avg: moods.reduce((s, m) => s + m, 0) / moods.length,
-      count: moods.length,
-    }))
+  if (!active || !payload?.length) return null
+
+  const bar = payload[0].payload
+
+  return (
+    <div className="rounded-lg border bg-popover px-3 py-2 text-sm text-popover-foreground shadow-md">
+      <p className="font-medium">{bar.tooltip}</p>
+      <p>
+        {getMoodEmoji(Math.round(bar.average))} {bar.average.toFixed(1)} avg
+        <span className="ml-1 text-muted-foreground">
+          ({bar.entryCount} {bar.entryCount === 1 ? "entry" : "entries"})
+        </span>
+      </p>
+    </div>
+  )
 }
diff --git a/spa/src/components/stats/stat-card.tsx b/spa/src/components/stats/stat-card.tsx
index 5d37e40..3438ee9 100644
--- a/spa/src/components/stats/stat-card.tsx
+++ b/spa/src/components/stats/stat-card.tsx
@@ -1,18 +1,26 @@
-import { Card, CardContent } from "@/components/ui/card"
 import type { ReactNode } from "react"
+import { Card, CardContent } from "@/components/ui/card"
 
 interface StatCardProps {
   label: string
-  value: string | number
+  value: ReactNode
+  /** Read instead of `value` by assistive technology, when the value is a glyph. */
+  valueLabel?: string
   icon?: ReactNode
 }
 
-export function StatCard({ label, value, icon }: StatCardProps) {
+export function StatCard({ label, value, valueLabel, icon }: StatCardProps) {
   return (
     <Card>
       <CardContent className="flex flex-col items-center gap-1 py-4">
         {icon && <span className="text-muted-foreground">{icon}</span>}
-        <span className="text-2xl font-bold">{value}</span>
+        <span
+          className="text-2xl font-bold"
+          aria-label={valueLabel}
+          role={valueLabel ? "img" : undefined}
+        >
+          {value}
+        </span>
         <span className="text-xs text-muted-foreground">{label}</span>
       </CardContent>
     </Card>
diff --git a/spa/src/components/ui/accordion.tsx b/spa/src/components/ui/accordion.tsx
deleted file mode 100644
index a9eafcf..0000000
--- a/spa/src/components/ui/accordion.tsx
+++ /dev/null
@@ -1,78 +0,0 @@
-import { Accordion as AccordionPrimitive } from "@base-ui/react/accordion"
-
-import { cn } from "@/lib/utils"
-import { ChevronDownIcon, ChevronUpIcon } from "lucide-react"
-
-function Accordion({ className, ...props }: AccordionPrimitive.Root.Props) {
-  return (
-    <AccordionPrimitive.Root
-      data-slot="accordion"
-      className={cn("flex w-full flex-col", className)}
-      {...props}
-    />
-  )
-}
-
-function AccordionItem({ className, ...props }: AccordionPrimitive.Item.Props) {
-  return (
-    <AccordionPrimitive.Item
-      data-slot="accordion-item"
-      className={cn("not-last:border-b", className)}
-      {...props}
-    />
-  )
-}
-
-function AccordionTrigger({
-  className,
-  children,
-  ...props
-}: AccordionPrimitive.Trigger.Props) {
-  return (
-    <AccordionPrimitive.Header className="flex">
-      <AccordionPrimitive.Trigger
-        data-slot="accordion-trigger"
-        className={cn(
-          "group/accordion-trigger relative flex flex-1 items-start justify-between rounded-lg border border-transparent py-2.5 text-left text-sm font-medium transition-all outline-none hover:underline focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:after:border-ring aria-disabled:pointer-events-none aria-disabled:opacity-50 **:data-[slot=accordion-trigger-icon]:ml-auto **:data-[slot=accordion-trigger-icon]:size-4 **:data-[slot=accordion-trigger-icon]:text-muted-foreground",
-          className
-        )}
-        {...props}
-      >
-        {children}
-        <ChevronDownIcon
-          data-slot="accordion-trigger-icon"
-          className="pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden"
-        />
-        <ChevronUpIcon
-          data-slot="accordion-trigger-icon"
-          className="pointer-events-none hidden shrink-0 group-aria-expanded/accordion-trigger:inline"
-        />
-      </AccordionPrimitive.Trigger>
-    </AccordionPrimitive.Header>
-  )
-}
-
-function AccordionContent({
-  className,
-  children,
-  ...props
-}: AccordionPrimitive.Panel.Props) {
-  return (
-    <AccordionPrimitive.Panel
-      data-slot="accordion-content"
-      className="overflow-hidden text-sm data-open:animate-accordion-down data-closed:animate-accordion-up"
-      {...props}
-    >
-      <div
-        className={cn(
-          "h-(--accordion-panel-height) pt-0 pb-2.5 data-ending-style:h-0 data-starting-style:h-0 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4",
-          className
-        )}
-      >
-        {children}
-      </div>
-    </AccordionPrimitive.Panel>
-  )
-}
-
-export { Accordion, AccordionItem, AccordionTrigger, AccordionContent }
diff --git a/spa/src/components/ui/aspect-ratio.tsx b/spa/src/components/ui/aspect-ratio.tsx
deleted file mode 100644
index 4c0ebaa..0000000
--- a/spa/src/components/ui/aspect-ratio.tsx
+++ /dev/null
@@ -1,22 +0,0 @@
-import { cn } from "@/lib/utils"
-
-function AspectRatio({
-  ratio,
-  className,
-  ...props
-}: React.ComponentProps<"div"> & { ratio: number }) {
-  return (
-    <div
-      data-slot="aspect-ratio"
-      style={
-        {
-          "--ratio": ratio,
-        } as React.CSSProperties
-      }
-      className={cn("relative aspect-(--ratio)", className)}
-      {...props}
-    />
-  )
-}
-
-export { AspectRatio }
diff --git a/spa/src/components/ui/attachment.tsx b/spa/src/components/ui/attachment.tsx
deleted file mode 100644
index 730e7b5..0000000
--- a/spa/src/components/ui/attachment.tsx
+++ /dev/null
@@ -1,208 +0,0 @@
-import * as React from "react"
-import { mergeProps } from "@base-ui/react/merge-props"
-import { useRender } from "@base-ui/react/use-render"
-import { cva } from "class-variance-authority"
-import type { VariantProps } from "class-variance-authority"
-
-import { cn } from "@/lib/utils"
-import { Button } from "@/components/ui/button"
-
-const attachmentVariants = cva(
-  "group/attachment relative flex w-fit max-w-full min-w-0 shrink-0 flex-wrap rounded-xl border bg-card text-card-foreground transition-colors focus-within:ring-1 focus-within:ring-ring/50 has-[>a,>button]:hover:bg-muted/50 data-[state=error]:border-destructive/30 data-[state=idle]:border-dashed",
-  {
-    variants: {
-      size: {
-        default:
-          "gap-2 text-sm has-data-[slot=attachment-content]:px-2.5 has-data-[slot=attachment-content]:py-2 has-data-[slot=attachment-media]:p-2",
-        sm: "gap-2.5 text-xs has-data-[slot=attachment-content]:px-2 has-data-[slot=attachment-content]:py-1.5 has-data-[slot=attachment-media]:p-1.5",
-        xs: "gap-1.5 rounded-lg text-xs has-data-[slot=attachment-content]:px-1.5 has-data-[slot=attachment-content]:py-1 has-data-[slot=attachment-media]:p-1",
-      },
-      orientation: {
-        horizontal: "min-w-40 items-center",
-        vertical: "w-24 flex-col has-data-[slot=attachment-content]:w-30",
-      },
-    },
-  }
-)
-
-function Attachment({
-  className,
-  state = "done",
-  size = "default",
-  orientation = "horizontal",
-  ...props
-}: React.ComponentProps<"div"> &
-  VariantProps<typeof attachmentVariants> & {
-    state?: "idle" | "uploading" | "processing" | "error" | "done"
-  }) {
-  return (
-    <div
-      data-slot="attachment"
-      data-state={state}
-      data-size={size}
-      data-orientation={orientation}
-      className={cn(attachmentVariants({ size, orientation }), className)}
-      {...props}
-    />
-  )
-}
-
-const attachmentMediaVariants = cva(
-  "relative flex aspect-square w-10 shrink-0 items-center justify-center overflow-hidden rounded-lg bg-muted text-foreground group-data-[orientation=vertical]/attachment:w-full group-data-[size=sm]/attachment:w-8 group-data-[size=xs]/attachment:w-7 group-data-[size=xs]/attachment:rounded-md group-data-[state=error]/attachment:bg-destructive/10 group-data-[state=error]/attachment:text-destructive group-data-[orientation=vertical]/attachment:*:data-[slot=spinner]:size-6! [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 group-data-[orientation=vertical]/attachment:[&_svg:not([class*='size-'])]:size-6 group-data-[size=xs]/attachment:[&_svg:not([class*='size-'])]:size-3.5",
-  {
-    variants: {
-      variant: {
-        icon: "",
-        image:
-          "opacity-60 group-data-[state=done]/attachment:opacity-100 group-data-[state=idle]/attachment:opacity-100 *:[img]:aspect-square *:[img]:w-full *:[img]:object-cover",
-      },
-    },
-    defaultVariants: {
-      variant: "icon",
-    },
-  }
-)
-
-function AttachmentMedia({
-  className,
-  variant = "icon",
-  ...props
-}: React.ComponentProps<"div"> & VariantProps<typeof attachmentMediaVariants>) {
-  return (
-    <div
-      data-slot="attachment-media"
-      data-variant={variant}
-      className={cn(attachmentMediaVariants({ variant }), className)}
-      {...props}
-    />
-  )
-}
-
-function AttachmentContent({
-  className,
-  ...props
-}: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="attachment-content"
-      className={cn(
-        "max-w-full min-w-0 flex-1 leading-tight group-data-[orientation=vertical]/attachment:px-1",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function AttachmentTitle({
-  className,
-  ...props
-}: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="attachment-title"
-      className={cn(
-        "block max-w-full min-w-0 truncate font-medium group-data-[state=processing]/attachment:shimmer group-data-[state=uploading]/attachment:shimmer",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function AttachmentDescription({
-  className,
-  ...props
-}: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="attachment-description"
-      className={cn(
-        "mt-0.5 block min-w-0 truncate text-xs text-muted-foreground group-data-[state=error]/attachment:text-destructive/80",
-        "max-w-full",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function AttachmentActions({
-  className,
-  ...props
-}: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="attachment-actions"
-      className={cn(
-        "relative z-20 flex shrink-0 items-center group-data-[orientation=vertical]/attachment:absolute group-data-[orientation=vertical]/attachment:top-3 group-data-[orientation=vertical]/attachment:right-3 group-data-[orientation=vertical]/attachment:gap-1",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function AttachmentAction({
-  className,
-  variant,
-  size = "icon-xs",
-  ...props
-}: React.ComponentProps<typeof Button>) {
-  return (
-    <Button
-      data-slot="attachment-action"
-      variant={variant ?? "ghost"}
-      size={size}
-      className={cn(className)}
-      {...props}
-    />
-  )
-}
-
-function AttachmentTrigger({
-  className,
-  render,
-  type,
-  ...props
-}: useRender.ComponentProps<"button">) {
-  return useRender({
-    defaultTagName: "button",
-    props: mergeProps<"button">(
-      {
-        type: render ? type : (type ?? "button"),
-        className: cn("absolute inset-0 z-10 outline-none", className),
-      },
-      props
-    ),
-    render,
-    state: {
-      slot: "attachment-trigger",
-    },
-  })
-}
-
-function AttachmentGroup({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="attachment-group"
-      className={cn(
-        "flex min-w-0 scroll-fade-x snap-x snap-mandatory scroll-px-1 scrollbar-none gap-3 overflow-x-auto overscroll-x-contain py-1 *:data-[slot=attachment]:flex-none *:data-[slot=attachment]:snap-start",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export {
-  Attachment,
-  AttachmentGroup,
-  AttachmentMedia,
-  AttachmentContent,
-  AttachmentTitle,
-  AttachmentDescription,
-  AttachmentActions,
-  AttachmentAction,
-  AttachmentTrigger,
-}
diff --git a/spa/src/components/ui/avatar.tsx b/spa/src/components/ui/avatar.tsx
deleted file mode 100644
index e92a2f4..0000000
--- a/spa/src/components/ui/avatar.tsx
+++ /dev/null
@@ -1,107 +0,0 @@
-import * as React from "react"
-import { Avatar as AvatarPrimitive } from "@base-ui/react/avatar"
-
-import { cn } from "@/lib/utils"
-
-function Avatar({
-  className,
-  size = "default",
-  ...props
-}: AvatarPrimitive.Root.Props & {
-  size?: "default" | "sm" | "lg"
-}) {
-  return (
-    <AvatarPrimitive.Root
-      data-slot="avatar"
-      data-size={size}
-      className={cn(
-        "group/avatar relative flex size-8 shrink-0 rounded-full select-none after:absolute after:inset-0 after:rounded-full after:border after:border-border after:mix-blend-darken data-[size=lg]:size-10 data-[size=sm]:size-6 dark:after:mix-blend-lighten",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function AvatarImage({ className, ...props }: AvatarPrimitive.Image.Props) {
-  return (
-    <AvatarPrimitive.Image
-      data-slot="avatar-image"
-      className={cn(
-        "aspect-square size-full rounded-full object-cover",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function AvatarFallback({
-  className,
-  ...props
-}: AvatarPrimitive.Fallback.Props) {
-  return (
-    <AvatarPrimitive.Fallback
-      data-slot="avatar-fallback"
-      className={cn(
-        "flex size-full items-center justify-center rounded-full bg-muted text-sm text-muted-foreground group-data-[size=sm]/avatar:text-xs",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function AvatarBadge({ className, ...props }: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="avatar-badge"
-      className={cn(
-        "absolute right-0 bottom-0 z-10 inline-flex items-center justify-center rounded-full bg-primary text-primary-foreground bg-blend-color ring-2 ring-background select-none",
-        "group-data-[size=sm]/avatar:size-2 group-data-[size=sm]/avatar:[&>svg]:hidden",
-        "group-data-[size=default]/avatar:size-2.5 group-data-[size=default]/avatar:[&>svg]:size-2",
-        "group-data-[size=lg]/avatar:size-3 group-data-[size=lg]/avatar:[&>svg]:size-2",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function AvatarGroup({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="avatar-group"
-      className={cn(
-        "group/avatar-group flex -space-x-2 *:data-[slot=avatar]:ring-2 *:data-[slot=avatar]:ring-background",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function AvatarGroupCount({
-  className,
-  ...props
-}: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="avatar-group-count"
-      className={cn(
-        "relative flex size-8 shrink-0 items-center justify-center rounded-full bg-muted text-sm text-muted-foreground ring-2 ring-background group-has-data-[size=lg]/avatar-group:size-10 group-has-data-[size=sm]/avatar-group:size-6 [&>svg]:size-4 group-has-data-[size=lg]/avatar-group:[&>svg]:size-5 group-has-data-[size=sm]/avatar-group:[&>svg]:size-3",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export {
-  Avatar,
-  AvatarImage,
-  AvatarFallback,
-  AvatarGroup,
-  AvatarGroupCount,
-  AvatarBadge,
-}
diff --git a/spa/src/components/ui/breadcrumb.tsx b/spa/src/components/ui/breadcrumb.tsx
deleted file mode 100644
index 30dbfc3..0000000
--- a/spa/src/components/ui/breadcrumb.tsx
+++ /dev/null
@@ -1,122 +0,0 @@
-import * as React from "react"
-import { mergeProps } from "@base-ui/react/merge-props"
-import { useRender } from "@base-ui/react/use-render"
-
-import { cn } from "@/lib/utils"
-import { ChevronRightIcon, MoreHorizontalIcon } from "lucide-react"
-
-function Breadcrumb({ className, ...props }: React.ComponentProps<"nav">) {
-  return (
-    <nav
-      aria-label="breadcrumb"
-      data-slot="breadcrumb"
-      className={cn(className)}
-      {...props}
-    />
-  )
-}
-
-function BreadcrumbList({ className, ...props }: React.ComponentProps<"ol">) {
-  return (
-    <ol
-      data-slot="breadcrumb-list"
-      className={cn(
-        "flex flex-wrap items-center gap-1.5 text-sm wrap-break-word text-muted-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function BreadcrumbItem({ className, ...props }: React.ComponentProps<"li">) {
-  return (
-    <li
-      data-slot="breadcrumb-item"
-      className={cn("inline-flex items-center gap-1", className)}
-      {...props}
-    />
-  )
-}
-
-function BreadcrumbLink({
-  className,
-  render,
-  ...props
-}: useRender.ComponentProps<"a">) {
-  return useRender({
-    defaultTagName: "a",
-    props: mergeProps<"a">(
-      {
-        className: cn("transition-colors hover:text-foreground", className),
-      },
-      props
-    ),
-    render,
-    state: {
-      slot: "breadcrumb-link",
-    },
-  })
-}
-
-function BreadcrumbPage({ className, ...props }: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="breadcrumb-page"
-      role="link"
-      aria-disabled="true"
-      aria-current="page"
-      className={cn("font-normal text-foreground", className)}
-      {...props}
-    />
-  )
-}
-
-function BreadcrumbSeparator({
-  children,
-  className,
-  ...props
-}: React.ComponentProps<"li">) {
-  return (
-    <li
-      data-slot="breadcrumb-separator"
-      role="presentation"
-      aria-hidden="true"
-      className={cn("[&>svg]:size-3.5", className)}
-      {...props}
-    >
-      {children ?? <ChevronRightIcon />}
-    </li>
-  )
-}
-
-function BreadcrumbEllipsis({
-  className,
-  ...props
-}: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="breadcrumb-ellipsis"
-      role="presentation"
-      aria-hidden="true"
-      className={cn(
-        "flex size-5 items-center justify-center [&>svg]:size-4",
-        className
-      )}
-      {...props}
-    >
-      <MoreHorizontalIcon />
-      <span className="sr-only">More</span>
-    </span>
-  )
-}
-
-export {
-  Breadcrumb,
-  BreadcrumbList,
-  BreadcrumbItem,
-  BreadcrumbLink,
-  BreadcrumbPage,
-  BreadcrumbSeparator,
-  BreadcrumbEllipsis,
-}
diff --git a/spa/src/components/ui/bubble.tsx b/spa/src/components/ui/bubble.tsx
deleted file mode 100644
index e3fb647..0000000
--- a/spa/src/components/ui/bubble.tsx
+++ /dev/null
@@ -1,129 +0,0 @@
-import * as React from "react"
-import { mergeProps } from "@base-ui/react/merge-props"
-import { useRender } from "@base-ui/react/use-render"
-import { cva } from "class-variance-authority"
-import type { VariantProps } from "class-variance-authority"
-
-import { cn } from "@/lib/utils"
-
-function BubbleGroup({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="bubble-group"
-      className={cn("flex min-w-0 flex-col gap-2", className)}
-      {...props}
-    />
-  )
-}
-
-const bubbleVariants = cva(
-  "group/bubble relative flex w-fit max-w-[80%] min-w-0 flex-col gap-1 group-data-[align=end]/message:self-end data-[align=end]:self-end data-[variant=ghost]:max-w-full",
-  {
-    variants: {
-      variant: {
-        default:
-          "*:data-[slot=bubble-content]:bg-primary *:data-[slot=bubble-content]:text-primary-foreground [&>[data-slot=bubble-content]:is(button,a):hover]:bg-primary/80",
-        secondary:
-          "*:data-[slot=bubble-content]:bg-secondary *:data-[slot=bubble-content]:text-secondary-foreground [&>[data-slot=bubble-content]:is(button,a):hover]:bg-[color-mix(in_oklch,var(--secondary),var(--foreground)_5%)]",
-        muted:
-          "*:data-[slot=bubble-content]:bg-muted [&>[data-slot=bubble-content]:is(button,a):hover]:bg-[color-mix(in_oklch,var(--muted),var(--foreground)_5%)]",
-        tinted:
-          "*:data-[slot=bubble-content]:bg-[oklch(from_var(--primary)_0.93_calc(c*0.4)_h)] *:data-[slot=bubble-content]:text-foreground dark:*:data-[slot=bubble-content]:bg-[oklch(from_var(--primary)_0.3_calc(c*0.4)_h)] [&>[data-slot=bubble-content]:is(button,a):hover]:bg-[oklch(from_var(--primary)_0.88_calc(c*0.5)_h)] dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-[oklch(from_var(--primary)_0.35_calc(c*0.5)_h)]",
-        outline:
-          "*:data-[slot=bubble-content]:border-border *:data-[slot=bubble-content]:bg-background [&>[data-slot=bubble-content]:is(button,a):hover]:bg-muted [&>[data-slot=bubble-content]:is(button,a):hover]:text-foreground dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-input/30",
-        ghost:
-          "border-none *:data-[slot=bubble-content]:rounded-none *:data-[slot=bubble-content]:bg-transparent *:data-[slot=bubble-content]:p-0 [&>[data-slot=bubble-content]:is(button,a):hover]:bg-muted [&>[data-slot=bubble-content]:is(button,a):hover]:text-foreground dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-muted/50",
-        destructive:
-          "*:data-[slot=bubble-content]:bg-destructive/10 *:data-[slot=bubble-content]:text-destructive dark:*:data-[slot=bubble-content]:bg-destructive/20 [&>[data-slot=bubble-content]:is(button,a):hover]:bg-destructive/20 dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-destructive/30",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-    },
-  }
-)
-
-function Bubble({
-  variant = "default",
-  align = "start",
-  className,
-  ...props
-}: React.ComponentProps<"div"> &
-  VariantProps<typeof bubbleVariants> & {
-    align?: "start" | "end"
-  }) {
-  return (
-    <div
-      data-slot="bubble"
-      data-variant={variant}
-      data-align={align}
-      className={cn(bubbleVariants({ variant }), className)}
-      {...props}
-    />
-  )
-}
-
-function BubbleContent({
-  className,
-  render,
-  ...props
-}: useRender.ComponentProps<"div">) {
-  return useRender({
-    defaultTagName: "div",
-    props: mergeProps<"div">(
-      {
-        className: cn(
-          "w-fit max-w-full min-w-0 overflow-hidden rounded-xl border border-transparent px-3 py-2 text-sm leading-relaxed wrap-break-word group-data-[align=end]/bubble:self-end [button]:text-left [button,a]:transition-colors [button,a]:outline-none [button,a]:focus-visible:border-ring [button,a]:focus-visible:ring-3 [button,a]:focus-visible:ring-ring/50",
-          className
-        ),
-      },
-      props
-    ),
-    render,
-    state: {
-      slot: "bubble-content",
-    },
-  })
-}
-
-const bubbleReactionsVariants = cva(
-  "absolute z-10 flex w-fit shrink-0 items-center justify-center gap-1 rounded-full bg-muted px-1.5 py-0.5 text-sm ring-3 ring-card has-[button]:p-0",
-  {
-    variants: {
-      side: {
-        top: "top-0 -translate-y-3/4",
-        bottom: "bottom-0 translate-y-3/4",
-      },
-      align: {
-        start: "left-3",
-        end: "right-3",
-      },
-    },
-    defaultVariants: {
-      side: "bottom",
-      align: "end",
-    },
-  }
-)
-
-function BubbleReactions({
-  side = "bottom",
-  align = "end",
-  className,
-  ...props
-}: React.ComponentProps<"div"> & {
-  align?: "start" | "end"
-  side?: "top" | "bottom"
-}) {
-  return (
-    <div
-      data-slot="bubble-reactions"
-      data-align={align}
-      data-side={side}
-      className={cn(bubbleReactionsVariants({ side, align }), className)}
-      {...props}
-    />
-  )
-}
-
-export { BubbleGroup, Bubble, BubbleContent, BubbleReactions }
diff --git a/spa/src/components/ui/button-group.tsx b/spa/src/components/ui/button-group.tsx
deleted file mode 100644
index c113298..0000000
--- a/spa/src/components/ui/button-group.tsx
+++ /dev/null
@@ -1,88 +0,0 @@
-import { mergeProps } from "@base-ui/react/merge-props"
-import { useRender } from "@base-ui/react/use-render"
-import { cva } from "class-variance-authority"
-import type { VariantProps } from "class-variance-authority"
-
-import { cn } from "@/lib/utils"
-import { Separator } from "@/components/ui/separator"
-
-const buttonGroupVariants = cva(
-  "flex w-fit items-stretch *:focus-visible:relative *:focus-visible:z-10 has-[>[data-slot=button-group]]:gap-2 has-[select[aria-hidden=true]:last-child]:[&>[data-slot=select-trigger]:last-of-type]:rounded-r-lg [&>[data-slot=select-trigger]:not([class*='w-'])]:w-fit [&>input]:flex-1",
-  {
-    variants: {
-      orientation: {
-        horizontal:
-          "*:data-slot:rounded-r-none [&>[data-slot]:not(:has(~[data-slot]))]:rounded-r-lg! [&>[data-slot]~[data-slot]]:rounded-l-none [&>[data-slot]~[data-slot]]:border-l-0",
-        vertical:
-          "flex-col *:data-slot:rounded-b-none [&>[data-slot]:not(:has(~[data-slot]))]:rounded-b-lg! [&>[data-slot]~[data-slot]]:rounded-t-none [&>[data-slot]~[data-slot]]:border-t-0",
-      },
-    },
-    defaultVariants: {
-      orientation: "horizontal",
-    },
-  }
-)
-
-function ButtonGroup({
-  className,
-  orientation,
-  ...props
-}: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>) {
-  return (
-    <div
-      role="group"
-      data-slot="button-group"
-      data-orientation={orientation}
-      className={cn(buttonGroupVariants({ orientation }), className)}
-      {...props}
-    />
-  )
-}
-
-function ButtonGroupText({
-  className,
-  render,
-  ...props
-}: useRender.ComponentProps<"div">) {
-  return useRender({
-    defaultTagName: "div",
-    props: mergeProps<"div">(
-      {
-        className: cn(
-          "flex items-center gap-2 rounded-lg border bg-muted px-2.5 text-sm font-medium [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
-          className
-        ),
-      },
-      props
-    ),
-    render,
-    state: {
-      slot: "button-group-text",
-    },
-  })
-}
-
-function ButtonGroupSeparator({
-  className,
-  orientation = "vertical",
-  ...props
-}: React.ComponentProps<typeof Separator>) {
-  return (
-    <Separator
-      data-slot="button-group-separator"
-      orientation={orientation}
-      className={cn(
-        "relative self-stretch bg-input data-horizontal:mx-px data-horizontal:w-auto data-vertical:my-px data-vertical:h-auto",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export {
-  ButtonGroup,
-  ButtonGroupSeparator,
-  ButtonGroupText,
-  buttonGroupVariants,
-}
diff --git a/spa/src/components/ui/carousel.tsx b/spa/src/components/ui/carousel.tsx
deleted file mode 100644
index bede571..0000000
--- a/spa/src/components/ui/carousel.tsx
+++ /dev/null
@@ -1,239 +0,0 @@
-import * as React from "react"
-import useEmblaCarousel from "embla-carousel-react"
-import type { UseEmblaCarouselType } from "embla-carousel-react"
-
-import { cn } from "@/lib/utils"
-import { Button } from "@/components/ui/button"
-import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react"
-
-type CarouselApi = UseEmblaCarouselType[1]
-type UseCarouselParameters = Parameters<typeof useEmblaCarousel>
-type CarouselOptions = UseCarouselParameters[0]
-type CarouselPlugin = UseCarouselParameters[1]
-
-type CarouselProps = {
-  opts?: CarouselOptions
-  plugins?: CarouselPlugin
-  orientation?: "horizontal" | "vertical"
-  setApi?: (api: CarouselApi) => void
-}
-
-type CarouselContextProps = {
-  carouselRef: ReturnType<typeof useEmblaCarousel>[0]
-  api: ReturnType<typeof useEmblaCarousel>[1]
-  scrollPrev: () => void
-  scrollNext: () => void
-  canScrollPrev: boolean
-  canScrollNext: boolean
-} & CarouselProps
-
-const CarouselContext = React.createContext<CarouselContextProps | null>(null)
-
-function useCarousel() {
-  const context = React.useContext(CarouselContext)
-
-  if (!context) {
-    throw new Error("useCarousel must be used within a <Carousel />")
-  }
-
-  return context
-}
-
-function Carousel({
-  orientation = "horizontal",
-  opts,
-  setApi,
-  plugins,
-  className,
-  children,
-  ...props
-}: React.ComponentProps<"div"> & CarouselProps) {
-  const [carouselRef, api] = useEmblaCarousel(
-    {
-      ...opts,
-      axis: orientation === "horizontal" ? "x" : "y",
-    },
-    plugins
-  )
-  const [canScrollPrev, setCanScrollPrev] = React.useState(false)
-  const [canScrollNext, setCanScrollNext] = React.useState(false)
-
-  const onSelect = React.useCallback((api: CarouselApi) => {
-    if (!api) return
-    setCanScrollPrev(api.canScrollPrev())
-    setCanScrollNext(api.canScrollNext())
-  }, [])
-
-  const scrollPrev = React.useCallback(() => {
-    api?.scrollPrev()
-  }, [api])
-
-  const scrollNext = React.useCallback(() => {
-    api?.scrollNext()
-  }, [api])
-
-  const handleKeyDown = React.useCallback(
-    (event: React.KeyboardEvent<HTMLDivElement>) => {
-      if (event.key === "ArrowLeft") {
-        event.preventDefault()
-        scrollPrev()
-      } else if (event.key === "ArrowRight") {
-        event.preventDefault()
-        scrollNext()
-      }
-    },
-    [scrollPrev, scrollNext]
-  )
-
-  React.useEffect(() => {
-    if (!api || !setApi) return
-    setApi(api)
-  }, [api, setApi])
-
-  React.useEffect(() => {
-    if (!api) return
-    onSelect(api)
-    api.on("reInit", onSelect)
-    api.on("select", onSelect)
-
-    return () => {
-      api?.off("select", onSelect)
-    }
-  }, [api, onSelect])
-
-  return (
-    <CarouselContext.Provider
-      value={{
-        carouselRef,
-        api: api,
-        opts,
-        orientation:
-          orientation || (opts?.axis === "y" ? "vertical" : "horizontal"),
-        scrollPrev,
-        scrollNext,
-        canScrollPrev,
-        canScrollNext,
-      }}
-    >
-      <div
-        onKeyDownCapture={handleKeyDown}
-        className={cn("relative", className)}
-        role="region"
-        aria-roledescription="carousel"
-        data-slot="carousel"
-        {...props}
-      >
-        {children}
-      </div>
-    </CarouselContext.Provider>
-  )
-}
-
-function CarouselContent({ className, ...props }: React.ComponentProps<"div">) {
-  const { carouselRef, orientation } = useCarousel()
-
-  return (
-    <div
-      ref={carouselRef}
-      className="overflow-hidden"
-      data-slot="carousel-content"
-    >
-      <div
-        className={cn(
-          "flex",
-          orientation === "horizontal" ? "-ml-4" : "-mt-4 flex-col",
-          className
-        )}
-        {...props}
-      />
-    </div>
-  )
-}
-
-function CarouselItem({ className, ...props }: React.ComponentProps<"div">) {
-  const { orientation } = useCarousel()
-
-  return (
-    <div
-      role="group"
-      aria-roledescription="slide"
-      data-slot="carousel-item"
-      className={cn(
-        "min-w-0 shrink-0 grow-0 basis-full",
-        orientation === "horizontal" ? "pl-4" : "pt-4",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function CarouselPrevious({
-  className,
-  variant = "outline",
-  size = "icon-sm",
-  ...props
-}: React.ComponentProps<typeof Button>) {
-  const { orientation, scrollPrev, canScrollPrev } = useCarousel()
-
-  return (
-    <Button
-      data-slot="carousel-previous"
-      variant={variant}
-      size={size}
-      className={cn(
-        "absolute touch-manipulation rounded-full",
-        orientation === "horizontal"
-          ? "inset-y-0 -left-12 my-auto"
-          : "-top-12 left-1/2 -translate-x-1/2 rotate-90",
-        className
-      )}
-      disabled={!canScrollPrev}
-      onClick={scrollPrev}
-      {...props}
-    >
-      <ChevronLeftIcon />
-      <span className="sr-only">Previous slide</span>
-    </Button>
-  )
-}
-
-function CarouselNext({
-  className,
-  variant = "outline",
-  size = "icon-sm",
-  ...props
-}: React.ComponentProps<typeof Button>) {
-  const { orientation, scrollNext, canScrollNext } = useCarousel()
-
-  return (
-    <Button
-      data-slot="carousel-next"
-      variant={variant}
-      size={size}
-      className={cn(
-        "absolute touch-manipulation rounded-full",
-        orientation === "horizontal"
-          ? "inset-y-0 -right-12 my-auto"
-          : "-bottom-12 left-1/2 -translate-x-1/2 rotate-90",
-        className
-      )}
-      disabled={!canScrollNext}
-      onClick={scrollNext}
-      {...props}
-    >
-      <ChevronRightIcon />
-      <span className="sr-only">Next slide</span>
-    </Button>
-  )
-}
-
-export {
-  type CarouselApi,
-  Carousel,
-  CarouselContent,
-  CarouselItem,
-  CarouselPrevious,
-  CarouselNext,
-  useCarousel,
-}
diff --git a/spa/src/components/ui/chart.tsx b/spa/src/components/ui/chart.tsx
deleted file mode 100644
index 852481a..0000000
--- a/spa/src/components/ui/chart.tsx
+++ /dev/null
@@ -1,369 +0,0 @@
-import * as React from "react"
-import * as RechartsPrimitive from "recharts"
-import type { TooltipValueType } from "recharts"
-
-import { cn } from "@/lib/utils"
-
-// Format: { THEME_NAME: CSS_SELECTOR }
-const THEMES = { light: "", dark: ".dark" } as const
-
-const INITIAL_DIMENSION = { width: 320, height: 200 } as const
-type TooltipNameType = number | string
-
-export type ChartConfig = Record<
-  string,
-  {
-    label?: React.ReactNode
-    icon?: React.ComponentType
-  } & (
-    | { color?: string; theme?: never }
-    | { color?: never; theme: Record<keyof typeof THEMES, string> }
-  )
->
-
-type ChartContextProps = {
-  config: ChartConfig
-}
-
-const ChartContext = React.createContext<ChartContextProps | null>(null)
-
-function useChart() {
-  const context = React.useContext(ChartContext)
-
-  if (!context) {
-    throw new Error("useChart must be used within a <ChartContainer />")
-  }
-
-  return context
-}
-
-function ChartContainer({
-  id,
-  className,
-  children,
-  config,
-  initialDimension = INITIAL_DIMENSION,
-  ...props
-}: React.ComponentProps<"div"> & {
-  config: ChartConfig
-  children: React.ComponentProps<
-    typeof RechartsPrimitive.ResponsiveContainer
-  >["children"]
-  initialDimension?: {
-    width: number
-    height: number
-  }
-}) {
-  const uniqueId = React.useId()
-  const chartId = `chart-${id ?? uniqueId.replace(/:/g, "")}`
-
-  return (
-    <ChartContext.Provider value={{ config }}>
-      <div
-        data-slot="chart"
-        data-chart={chartId}
-        className={cn(
-          "flex aspect-video justify-center text-xs [&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-hidden [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line_[stroke='#ccc']]:stroke-border [&_.recharts-sector]:outline-hidden [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-surface]:outline-hidden",
-          className
-        )}
-        {...props}
-      >
-        <ChartStyle id={chartId} config={config} />
-        <RechartsPrimitive.ResponsiveContainer
-          initialDimension={initialDimension}
-        >
-          {children}
-        </RechartsPrimitive.ResponsiveContainer>
-      </div>
-    </ChartContext.Provider>
-  )
-}
-
-const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
-  const colorConfig = Object.entries(config).filter(
-    ([, config]) => config.theme ?? config.color
-  )
-
-  if (!colorConfig.length) {
-    return null
-  }
-
-  return (
-    <style
-      dangerouslySetInnerHTML={{
-        __html: Object.entries(THEMES)
-          .map(
-            ([theme, prefix]) => `
-${prefix} [data-chart=${id}] {
-${colorConfig
-  .map(([key, itemConfig]) => {
-    const color =
-      itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ??
-      itemConfig.color
-    return color ? `  --color-${key}: ${color};` : null
-  })
-  .join("\n")}
-}
-`
-          )
-          .join("\n"),
-      }}
-    />
-  )
-}
-
-const ChartTooltip = RechartsPrimitive.Tooltip
-
-function ChartTooltipContent({
-  active,
-  payload,
-  className,
-  indicator = "dot",
-  hideLabel = false,
-  hideIndicator = false,
-  label,
-  labelFormatter,
-  labelClassName,
-  formatter,
-  color,
-  nameKey,
-  labelKey,
-}: React.ComponentProps<typeof RechartsPrimitive.Tooltip> &
-  React.ComponentProps<"div"> & {
-    hideLabel?: boolean
-    hideIndicator?: boolean
-    indicator?: "line" | "dot" | "dashed"
-    nameKey?: string
-    labelKey?: string
-  } & Omit<
-    RechartsPrimitive.DefaultTooltipContentProps<
-      TooltipValueType,
-      TooltipNameType
-    >,
-    "accessibilityLayer"
-  >) {
-  const { config } = useChart()
-
-  const tooltipLabel = React.useMemo(() => {
-    if (hideLabel || !payload?.length) {
-      return null
-    }
-
-    const [item] = payload
-    const key = `${labelKey ?? item?.dataKey ?? item?.name ?? "value"}`
-    const itemConfig = getPayloadConfigFromPayload(config, item, key)
-    const value =
-      !labelKey && typeof label === "string"
-        ? (config[label]?.label ?? label)
-        : itemConfig?.label
-
-    if (labelFormatter) {
-      return (
-        <div className={cn("font-medium", labelClassName)}>
-          {labelFormatter(value, payload)}
-        </div>
-      )
-    }
-
-    if (!value) {
-      return null
-    }
-
-    return <div className={cn("font-medium", labelClassName)}>{value}</div>
-  }, [
-    label,
-    labelFormatter,
-    payload,
-    hideLabel,
-    labelClassName,
-    config,
-    labelKey,
-  ])
-
-  if (!active || !payload?.length) {
-    return null
-  }
-
-  const nestLabel = payload.length === 1 && indicator !== "dot"
-
-  return (
-    <div
-      className={cn(
-        "grid min-w-32 items-start gap-1.5 rounded-lg border border-border/50 bg-background px-2.5 py-1.5 text-xs shadow-xl",
-        className
-      )}
-    >
-      {!nestLabel ? tooltipLabel : null}
-      <div className="grid gap-1.5">
-        {payload
-          .filter((item) => item.type !== "none")
-          .map((item, index) => {
-            const key = `${nameKey ?? item.name ?? item.dataKey ?? "value"}`
-            const itemConfig = getPayloadConfigFromPayload(config, item, key)
-            const indicatorColor = color ?? item.payload?.fill ?? item.color
-
-            return (
-              <div
-                key={index}
-                className={cn(
-                  "flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5 [&>svg]:text-muted-foreground",
-                  indicator === "dot" && "items-center"
-                )}
-              >
-                {formatter && item?.value !== undefined && item.name ? (
-                  formatter(item.value, item.name, item, index, item.payload)
-                ) : (
-                  <>
-                    {itemConfig?.icon ? (
-                      <itemConfig.icon />
-                    ) : (
-                      !hideIndicator && (
-                        <div
-                          className={cn(
-                            "shrink-0 rounded-[2px] border-(--color-border) bg-(--color-bg)",
-                            {
-                              "h-2.5 w-2.5": indicator === "dot",
-                              "w-1": indicator === "line",
-                              "w-0 border-[1.5px] border-dashed bg-transparent":
-                                indicator === "dashed",
-                              "my-0.5": nestLabel && indicator === "dashed",
-                            }
-                          )}
-                          style={
-                            {
-                              "--color-bg": indicatorColor,
-                              "--color-border": indicatorColor,
-                            } as React.CSSProperties
-                          }
-                        />
-                      )
-                    )}
-                    <div
-                      className={cn(
-                        "flex flex-1 justify-between leading-none",
-                        nestLabel ? "items-end" : "items-center"
-                      )}
-                    >
-                      <div className="grid gap-1.5">
-                        {nestLabel ? tooltipLabel : null}
-                        <span className="text-muted-foreground">
-                          {itemConfig?.label ?? item.name}
-                        </span>
-                      </div>
-                      {item.value != null && (
-                        <span className="font-mono font-medium text-foreground tabular-nums">
-                          {typeof item.value === "number"
-                            ? item.value.toLocaleString()
-                            : String(item.value)}
-                        </span>
-                      )}
-                    </div>
-                  </>
-                )}
-              </div>
-            )
-          })}
-      </div>
-    </div>
-  )
-}
-
-const ChartLegend = RechartsPrimitive.Legend
-
-function ChartLegendContent({
-  className,
-  hideIcon = false,
-  payload,
-  verticalAlign = "bottom",
-  nameKey,
-}: React.ComponentProps<"div"> & {
-  hideIcon?: boolean
-  nameKey?: string
-} & RechartsPrimitive.DefaultLegendContentProps) {
-  const { config } = useChart()
-
-  if (!payload?.length) {
-    return null
-  }
-
-  return (
-    <div
-      className={cn(
-        "flex items-center justify-center gap-4",
-        verticalAlign === "top" ? "pb-3" : "pt-3",
-        className
-      )}
-    >
-      {payload
-        .filter((item) => item.type !== "none")
-        .map((item, index) => {
-          const key = `${nameKey ?? item.dataKey ?? "value"}`
-          const itemConfig = getPayloadConfigFromPayload(config, item, key)
-
-          return (
-            <div
-              key={index}
-              className={cn(
-                "flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3 [&>svg]:text-muted-foreground"
-              )}
-            >
-              {itemConfig?.icon && !hideIcon ? (
-                <itemConfig.icon />
-              ) : (
-                <div
-                  className="h-2 w-2 shrink-0 rounded-[2px]"
-                  style={{
-                    backgroundColor: item.color,
-                  }}
-                />
-              )}
-              {itemConfig?.label}
-            </div>
-          )
-        })}
-    </div>
-  )
-}
-
-function getPayloadConfigFromPayload(
-  config: ChartConfig,
-  payload: unknown,
-  key: string
-) {
-  if (typeof payload !== "object" || payload === null) {
-    return undefined
-  }
-
-  const payloadPayload =
-    "payload" in payload &&
-    typeof payload.payload === "object" &&
-    payload.payload !== null
-      ? payload.payload
-      : undefined
-
-  let configLabelKey: string = key
-
-  if (
-    key in payload &&
-    typeof payload[key as keyof typeof payload] === "string"
-  ) {
-    configLabelKey = payload[key as keyof typeof payload]
-  } else if (
-    payloadPayload &&
-    key in payloadPayload &&
-    typeof payloadPayload[key as keyof typeof payloadPayload] === "string"
-  ) {
-    configLabelKey = payloadPayload[key as keyof typeof payloadPayload]
-  }
-
-  return configLabelKey in config ? config[configLabelKey] : config[key]
-}
-
-export {
-  ChartContainer,
-  ChartTooltip,
-  ChartTooltipContent,
-  ChartLegend,
-  ChartLegendContent,
-  ChartStyle,
-}
diff --git a/spa/src/components/ui/combobox.tsx b/spa/src/components/ui/combobox.tsx
deleted file mode 100644
index 5374cdf..0000000
--- a/spa/src/components/ui/combobox.tsx
+++ /dev/null
@@ -1,298 +0,0 @@
-import * as React from "react"
-import { Combobox as ComboboxPrimitive } from "@base-ui/react"
-
-import { cn } from "@/lib/utils"
-import { Button } from "@/components/ui/button"
-import {
-  InputGroup,
-  InputGroupAddon,
-  InputGroupButton,
-  InputGroupInput,
-} from "@/components/ui/input-group"
-import { ChevronDownIcon, XIcon, CheckIcon } from "lucide-react"
-
-const Combobox = ComboboxPrimitive.Root
-
-function ComboboxValue({ ...props }: ComboboxPrimitive.Value.Props) {
-  return <ComboboxPrimitive.Value data-slot="combobox-value" {...props} />
-}
-
-function ComboboxTrigger({
-  className,
-  children,
-  ...props
-}: ComboboxPrimitive.Trigger.Props) {
-  return (
-    <ComboboxPrimitive.Trigger
-      data-slot="combobox-trigger"
-      className={cn("[&_svg:not([class*='size-'])]:size-4", className)}
-      {...props}
-    >
-      {children}
-      <ChevronDownIcon className="pointer-events-none size-4 text-muted-foreground" />
-    </ComboboxPrimitive.Trigger>
-  )
-}
-
-function ComboboxClear({ className, ...props }: ComboboxPrimitive.Clear.Props) {
-  return (
-    <ComboboxPrimitive.Clear
-      data-slot="combobox-clear"
-      render={<InputGroupButton variant="ghost" size="icon-xs" />}
-      className={cn(className)}
-      {...props}
-    >
-      <XIcon className="pointer-events-none" />
-    </ComboboxPrimitive.Clear>
-  )
-}
-
-function ComboboxInput({
-  className,
-  children,
-  disabled = false,
-  showTrigger = true,
-  showClear = false,
-  ...props
-}: ComboboxPrimitive.Input.Props & {
-  showTrigger?: boolean
-  showClear?: boolean
-}) {
-  return (
-    <InputGroup className={cn("w-auto", className)}>
-      <ComboboxPrimitive.Input
-        render={<InputGroupInput disabled={disabled} />}
-        {...props}
-      />
-      <InputGroupAddon align="inline-end">
-        {showTrigger && (
-          <InputGroupButton
-            size="icon-xs"
-            variant="ghost"
-            render={<ComboboxTrigger />}
-            data-slot="input-group-button"
-            className="group-has-data-[slot=combobox-clear]/input-group:hidden data-pressed:bg-transparent"
-            disabled={disabled}
-          />
-        )}
-        {showClear && <ComboboxClear disabled={disabled} />}
-      </InputGroupAddon>
-      {children}
-    </InputGroup>
-  )
-}
-
-function ComboboxContent({
-  className,
-  side = "bottom",
-  sideOffset = 6,
-  align = "start",
-  alignOffset = 0,
-  anchor,
-  ...props
-}: ComboboxPrimitive.Popup.Props &
-  Pick<
-    ComboboxPrimitive.Positioner.Props,
-    "side" | "align" | "sideOffset" | "alignOffset" | "anchor"
-  >) {
-  return (
-    <ComboboxPrimitive.Portal>
-      <ComboboxPrimitive.Positioner
-        side={side}
-        sideOffset={sideOffset}
-        align={align}
-        alignOffset={alignOffset}
-        anchor={anchor}
-        className="isolate z-50"
-      >
-        <ComboboxPrimitive.Popup
-          data-slot="combobox-content"
-          data-chips={!!anchor}
-          className={cn(
-            "group/combobox-content relative max-h-(--available-height) w-(--anchor-width) max-w-(--available-width) min-w-[calc(var(--anchor-width)+--spacing(7))] origin-(--transform-origin) overflow-hidden rounded-lg bg-popover text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[chips=true]:min-w-(--anchor-width) data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 *:data-[slot=input-group]:m-1 *:data-[slot=input-group]:mb-0 *:data-[slot=input-group]:h-8 *:data-[slot=input-group]:border-input/30 *:data-[slot=input-group]:bg-input/30 *:data-[slot=input-group]:shadow-none data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
-            className
-          )}
-          {...props}
-        />
-      </ComboboxPrimitive.Positioner>
-    </ComboboxPrimitive.Portal>
-  )
-}
-
-function ComboboxList({ className, ...props }: ComboboxPrimitive.List.Props) {
-  return (
-    <ComboboxPrimitive.List
-      data-slot="combobox-list"
-      className={cn(
-        "no-scrollbar max-h-[min(calc(--spacing(72)---spacing(9)),calc(var(--available-height)---spacing(9)))] scroll-py-1 overflow-y-auto overscroll-contain p-1 data-empty:p-0",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ComboboxItem({
-  className,
-  children,
-  ...props
-}: ComboboxPrimitive.Item.Props) {
-  return (
-    <ComboboxPrimitive.Item
-      data-slot="combobox-item"
-      className={cn(
-        "relative flex w-full cursor-default items-center gap-2 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none data-highlighted:bg-accent data-highlighted:text-accent-foreground not-data-[variant=destructive]:data-highlighted:**:text-accent-foreground data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    >
-      {children}
-      <ComboboxPrimitive.ItemIndicator
-        render={
-          <span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center" />
-        }
-      >
-        <CheckIcon className="pointer-events-none" />
-      </ComboboxPrimitive.ItemIndicator>
-    </ComboboxPrimitive.Item>
-  )
-}
-
-function ComboboxGroup({ className, ...props }: ComboboxPrimitive.Group.Props) {
-  return (
-    <ComboboxPrimitive.Group
-      data-slot="combobox-group"
-      className={cn(className)}
-      {...props}
-    />
-  )
-}
-
-function ComboboxLabel({
-  className,
-  ...props
-}: ComboboxPrimitive.GroupLabel.Props) {
-  return (
-    <ComboboxPrimitive.GroupLabel
-      data-slot="combobox-label"
-      className={cn("px-2 py-1.5 text-xs text-muted-foreground", className)}
-      {...props}
-    />
-  )
-}
-
-function ComboboxCollection({ ...props }: ComboboxPrimitive.Collection.Props) {
-  return (
-    <ComboboxPrimitive.Collection data-slot="combobox-collection" {...props} />
-  )
-}
-
-function ComboboxEmpty({ className, ...props }: ComboboxPrimitive.Empty.Props) {
-  return (
-    <ComboboxPrimitive.Empty
-      data-slot="combobox-empty"
-      className={cn(
-        "hidden w-full justify-center py-2 text-center text-sm text-muted-foreground group-data-empty/combobox-content:flex",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ComboboxSeparator({
-  className,
-  ...props
-}: ComboboxPrimitive.Separator.Props) {
-  return (
-    <ComboboxPrimitive.Separator
-      data-slot="combobox-separator"
-      className={cn("-mx-1 my-1 h-px bg-border", className)}
-      {...props}
-    />
-  )
-}
-
-function ComboboxChips({
-  className,
-  ...props
-}: React.ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> &
-  ComboboxPrimitive.Chips.Props) {
-  return (
-    <ComboboxPrimitive.Chips
-      data-slot="combobox-chips"
-      className={cn(
-        "flex min-h-8 flex-wrap items-center gap-1 rounded-lg border border-input bg-transparent bg-clip-padding px-2.5 py-1 text-sm transition-colors focus-within:border-ring focus-within:ring-3 focus-within:ring-ring/50 has-aria-invalid:border-destructive has-aria-invalid:ring-3 has-aria-invalid:ring-destructive/20 has-data-[slot=combobox-chip]:px-1 dark:bg-input/30 dark:has-aria-invalid:border-destructive/50 dark:has-aria-invalid:ring-destructive/40",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ComboboxChip({
-  className,
-  children,
-  showRemove = true,
-  ...props
-}: ComboboxPrimitive.Chip.Props & {
-  showRemove?: boolean
-}) {
-  return (
-    <ComboboxPrimitive.Chip
-      data-slot="combobox-chip"
-      className={cn(
-        "flex h-[calc(--spacing(5.25))] w-fit items-center justify-center gap-1 rounded-sm bg-muted px-1.5 text-xs font-medium whitespace-nowrap text-foreground has-disabled:pointer-events-none has-disabled:cursor-not-allowed has-disabled:opacity-50 has-data-[slot=combobox-chip-remove]:pr-0",
-        className
-      )}
-      {...props}
-    >
-      {children}
-      {showRemove && (
-        <ComboboxPrimitive.ChipRemove
-          render={<Button variant="ghost" size="icon-xs" />}
-          className="-ml-1 opacity-50 hover:opacity-100"
-          data-slot="combobox-chip-remove"
-        >
-          <XIcon className="pointer-events-none" />
-        </ComboboxPrimitive.ChipRemove>
-      )}
-    </ComboboxPrimitive.Chip>
-  )
-}
-
-function ComboboxChipsInput({
-  className,
-  ...props
-}: ComboboxPrimitive.Input.Props) {
-  return (
-    <ComboboxPrimitive.Input
-      data-slot="combobox-chip-input"
-      className={cn("min-w-16 flex-1 outline-none", className)}
-      {...props}
-    />
-  )
-}
-
-function useComboboxAnchor() {
-  return React.useRef<HTMLDivElement | null>(null)
-}
-
-export {
-  Combobox,
-  ComboboxInput,
-  ComboboxContent,
-  ComboboxList,
-  ComboboxItem,
-  ComboboxGroup,
-  ComboboxLabel,
-  ComboboxCollection,
-  ComboboxEmpty,
-  ComboboxSeparator,
-  ComboboxChips,
-  ComboboxChip,
-  ComboboxChipsInput,
-  ComboboxTrigger,
-  ComboboxValue,
-  useComboboxAnchor,
-}
diff --git a/spa/src/components/ui/command.tsx b/spa/src/components/ui/command.tsx
deleted file mode 100644
index 6cc0532..0000000
--- a/spa/src/components/ui/command.tsx
+++ /dev/null
@@ -1,193 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { Command as CommandPrimitive } from "cmdk"
-
-import { cn } from "@/lib/utils"
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/ui/dialog"
-import { InputGroup, InputGroupAddon } from "@/components/ui/input-group"
-import { SearchIcon, CheckIcon } from "lucide-react"
-
-function Command({
-  className,
-  ...props
-}: React.ComponentProps<typeof CommandPrimitive>) {
-  return (
-    <CommandPrimitive
-      data-slot="command"
-      className={cn(
-        "flex size-full flex-col overflow-hidden rounded-xl! bg-popover p-1 text-popover-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function CommandDialog({
-  title = "Command Palette",
-  description = "Search for a command to run...",
-  children,
-  className,
-  showCloseButton = false,
-  ...props
-}: Omit<React.ComponentProps<typeof Dialog>, "children"> & {
-  title?: string
-  description?: string
-  className?: string
-  showCloseButton?: boolean
-  children: React.ReactNode
-}) {
-  return (
-    <Dialog {...props}>
-      <DialogHeader className="sr-only">
-        <DialogTitle>{title}</DialogTitle>
-        <DialogDescription>{description}</DialogDescription>
-      </DialogHeader>
-      <DialogContent
-        className={cn(
-          "top-1/3 translate-y-0 overflow-hidden rounded-xl! p-0",
-          className
-        )}
-        showCloseButton={showCloseButton}
-      >
-        {children}
-      </DialogContent>
-    </Dialog>
-  )
-}
-
-function CommandInput({
-  className,
-  ...props
-}: React.ComponentProps<typeof CommandPrimitive.Input>) {
-  return (
-    <div data-slot="command-input-wrapper" className="p-1 pb-0">
-      <InputGroup className="h-8! rounded-lg! border-input/30 bg-input/30 shadow-none! *:data-[slot=input-group-addon]:pl-2!">
-        <CommandPrimitive.Input
-          data-slot="command-input"
-          className={cn(
-            "w-full text-sm outline-hidden disabled:cursor-not-allowed disabled:opacity-50",
-            className
-          )}
-          {...props}
-        />
-        <InputGroupAddon>
-          <SearchIcon className="size-4 shrink-0 opacity-50" />
-        </InputGroupAddon>
-      </InputGroup>
-    </div>
-  )
-}
-
-function CommandList({
-  className,
-  ...props
-}: React.ComponentProps<typeof CommandPrimitive.List>) {
-  return (
-    <CommandPrimitive.List
-      data-slot="command-list"
-      className={cn(
-        "no-scrollbar max-h-72 scroll-py-1 overflow-x-hidden overflow-y-auto outline-none",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function CommandEmpty({
-  className,
-  ...props
-}: React.ComponentProps<typeof CommandPrimitive.Empty>) {
-  return (
-    <CommandPrimitive.Empty
-      data-slot="command-empty"
-      className={cn("py-6 text-center text-sm", className)}
-      {...props}
-    />
-  )
-}
-
-function CommandGroup({
-  className,
-  ...props
-}: React.ComponentProps<typeof CommandPrimitive.Group>) {
-  return (
-    <CommandPrimitive.Group
-      data-slot="command-group"
-      className={cn(
-        "overflow-hidden p-1 text-foreground **:[[cmdk-group-heading]]:px-2 **:[[cmdk-group-heading]]:py-1.5 **:[[cmdk-group-heading]]:text-xs **:[[cmdk-group-heading]]:font-medium **:[[cmdk-group-heading]]:text-muted-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function CommandSeparator({
-  className,
-  ...props
-}: React.ComponentProps<typeof CommandPrimitive.Separator>) {
-  return (
-    <CommandPrimitive.Separator
-      data-slot="command-separator"
-      className={cn("-mx-1 h-px bg-border", className)}
-      {...props}
-    />
-  )
-}
-
-function CommandItem({
-  className,
-  children,
-  ...props
-}: React.ComponentProps<typeof CommandPrimitive.Item>) {
-  return (
-    <CommandPrimitive.Item
-      data-slot="command-item"
-      className={cn(
-        "group/command-item relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none in-data-[slot=dialog-content]:rounded-lg! data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50 data-selected:bg-muted data-selected:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 data-selected:*:[svg]:text-foreground",
-        className
-      )}
-      {...props}
-    >
-      {children}
-      <CheckIcon className="ml-auto opacity-0 group-has-data-[slot=command-shortcut]/command-item:hidden group-data-[checked=true]/command-item:opacity-100" />
-    </CommandPrimitive.Item>
-  )
-}
-
-function CommandShortcut({
-  className,
-  ...props
-}: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="command-shortcut"
-      className={cn(
-        "ml-auto text-xs tracking-widest text-muted-foreground group-data-selected/command-item:text-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export {
-  Command,
-  CommandDialog,
-  CommandInput,
-  CommandList,
-  CommandEmpty,
-  CommandGroup,
-  CommandItem,
-  CommandShortcut,
-  CommandSeparator,
-}
diff --git a/spa/src/components/ui/context-menu.tsx b/spa/src/components/ui/context-menu.tsx
deleted file mode 100644
index 0083a86..0000000
--- a/spa/src/components/ui/context-menu.tsx
+++ /dev/null
@@ -1,272 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { ContextMenu as ContextMenuPrimitive } from "@base-ui/react/context-menu"
-
-import { cn } from "@/lib/utils"
-import { ChevronRightIcon, CheckIcon } from "lucide-react"
-
-function ContextMenu({ ...props }: ContextMenuPrimitive.Root.Props) {
-  return <ContextMenuPrimitive.Root data-slot="context-menu" {...props} />
-}
-
-function ContextMenuPortal({ ...props }: ContextMenuPrimitive.Portal.Props) {
-  return (
-    <ContextMenuPrimitive.Portal data-slot="context-menu-portal" {...props} />
-  )
-}
-
-function ContextMenuTrigger({
-  className,
-  ...props
-}: ContextMenuPrimitive.Trigger.Props) {
-  return (
-    <ContextMenuPrimitive.Trigger
-      data-slot="context-menu-trigger"
-      className={cn("select-none", className)}
-      {...props}
-    />
-  )
-}
-
-function ContextMenuContent({
-  className,
-  align = "start",
-  alignOffset = 4,
-  side = "right",
-  sideOffset = 0,
-  ...props
-}: ContextMenuPrimitive.Popup.Props &
-  Pick<
-    ContextMenuPrimitive.Positioner.Props,
-    "align" | "alignOffset" | "side" | "sideOffset"
-  >) {
-  return (
-    <ContextMenuPrimitive.Portal>
-      <ContextMenuPrimitive.Positioner
-        className="isolate z-50 outline-none"
-        align={align}
-        alignOffset={alignOffset}
-        side={side}
-        sideOffset={sideOffset}
-      >
-        <ContextMenuPrimitive.Popup
-          data-slot="context-menu-content"
-          className={cn(
-            "z-50 max-h-(--available-height) min-w-36 origin-(--transform-origin) overflow-x-hidden overflow-y-auto rounded-lg bg-popover p-1 text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 outline-none data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
-            className
-          )}
-          {...props}
-        />
-      </ContextMenuPrimitive.Positioner>
-    </ContextMenuPrimitive.Portal>
-  )
-}
-
-function ContextMenuGroup({ ...props }: ContextMenuPrimitive.Group.Props) {
-  return (
-    <ContextMenuPrimitive.Group data-slot="context-menu-group" {...props} />
-  )
-}
-
-function ContextMenuLabel({
-  className,
-  inset,
-  ...props
-}: ContextMenuPrimitive.GroupLabel.Props & {
-  inset?: boolean
-}) {
-  return (
-    <ContextMenuPrimitive.GroupLabel
-      data-slot="context-menu-label"
-      data-inset={inset}
-      className={cn(
-        "px-1.5 py-1 text-xs font-medium text-muted-foreground data-inset:pl-7",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ContextMenuItem({
-  className,
-  inset,
-  variant = "default",
-  ...props
-}: ContextMenuPrimitive.Item.Props & {
-  inset?: boolean
-  variant?: "default" | "destructive"
-}) {
-  return (
-    <ContextMenuPrimitive.Item
-      data-slot="context-menu-item"
-      data-inset={inset}
-      data-variant={variant}
-      className={cn(
-        "group/context-menu-item relative flex cursor-default items-center gap-1.5 rounded-md px-1.5 py-1 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground data-inset:pl-7 data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 data-[variant=destructive]:focus:text-destructive dark:data-[variant=destructive]:focus:bg-destructive/20 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 focus:*:[svg]:text-accent-foreground data-[variant=destructive]:*:[svg]:text-destructive",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ContextMenuSub({ ...props }: ContextMenuPrimitive.SubmenuRoot.Props) {
-  return (
-    <ContextMenuPrimitive.SubmenuRoot data-slot="context-menu-sub" {...props} />
-  )
-}
-
-function ContextMenuSubTrigger({
-  className,
-  inset,
-  children,
-  ...props
-}: ContextMenuPrimitive.SubmenuTrigger.Props & {
-  inset?: boolean
-}) {
-  return (
-    <ContextMenuPrimitive.SubmenuTrigger
-      data-slot="context-menu-sub-trigger"
-      data-inset={inset}
-      className={cn(
-        "flex cursor-default items-center gap-1.5 rounded-md px-1.5 py-1 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground data-inset:pl-7 data-open:bg-accent data-open:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    >
-      {children}
-      <ChevronRightIcon className="ml-auto" />
-    </ContextMenuPrimitive.SubmenuTrigger>
-  )
-}
-
-function ContextMenuSubContent({
-  ...props
-}: React.ComponentProps<typeof ContextMenuContent>) {
-  return (
-    <ContextMenuContent
-      data-slot="context-menu-sub-content"
-      className="shadow-lg"
-      side="right"
-      {...props}
-    />
-  )
-}
-
-function ContextMenuCheckboxItem({
-  className,
-  children,
-  checked,
-  inset,
-  ...props
-}: ContextMenuPrimitive.CheckboxItem.Props & {
-  inset?: boolean
-}) {
-  return (
-    <ContextMenuPrimitive.CheckboxItem
-      data-slot="context-menu-checkbox-item"
-      data-inset={inset}
-      className={cn(
-        "relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      checked={checked}
-      {...props}
-    >
-      <span className="pointer-events-none absolute right-2">
-        <ContextMenuPrimitive.CheckboxItemIndicator>
-          <CheckIcon />
-        </ContextMenuPrimitive.CheckboxItemIndicator>
-      </span>
-      {children}
-    </ContextMenuPrimitive.CheckboxItem>
-  )
-}
-
-function ContextMenuRadioGroup({
-  ...props
-}: ContextMenuPrimitive.RadioGroup.Props) {
-  return (
-    <ContextMenuPrimitive.RadioGroup
-      data-slot="context-menu-radio-group"
-      {...props}
-    />
-  )
-}
-
-function ContextMenuRadioItem({
-  className,
-  children,
-  inset,
-  ...props
-}: ContextMenuPrimitive.RadioItem.Props & {
-  inset?: boolean
-}) {
-  return (
-    <ContextMenuPrimitive.RadioItem
-      data-slot="context-menu-radio-item"
-      data-inset={inset}
-      className={cn(
-        "relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    >
-      <span className="pointer-events-none absolute right-2">
-        <ContextMenuPrimitive.RadioItemIndicator>
-          <CheckIcon />
-        </ContextMenuPrimitive.RadioItemIndicator>
-      </span>
-      {children}
-    </ContextMenuPrimitive.RadioItem>
-  )
-}
-
-function ContextMenuSeparator({
-  className,
-  ...props
-}: ContextMenuPrimitive.Separator.Props) {
-  return (
-    <ContextMenuPrimitive.Separator
-      data-slot="context-menu-separator"
-      className={cn("-mx-1 my-1 h-px bg-border", className)}
-      {...props}
-    />
-  )
-}
-
-function ContextMenuShortcut({
-  className,
-  ...props
-}: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="context-menu-shortcut"
-      className={cn(
-        "ml-auto text-xs tracking-widest text-muted-foreground group-focus/context-menu-item:text-accent-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export {
-  ContextMenu,
-  ContextMenuTrigger,
-  ContextMenuContent,
-  ContextMenuItem,
-  ContextMenuCheckboxItem,
-  ContextMenuRadioItem,
-  ContextMenuLabel,
-  ContextMenuSeparator,
-  ContextMenuShortcut,
-  ContextMenuGroup,
-  ContextMenuPortal,
-  ContextMenuSub,
-  ContextMenuSubContent,
-  ContextMenuSubTrigger,
-  ContextMenuRadioGroup,
-}
diff --git a/spa/src/components/ui/direction.tsx b/spa/src/components/ui/direction.tsx
deleted file mode 100644
index 3bb2f70..0000000
--- a/spa/src/components/ui/direction.tsx
+++ /dev/null
@@ -1,4 +0,0 @@
-export {
-  DirectionProvider,
-  useDirection,
-} from "@base-ui/react/direction-provider"
diff --git a/spa/src/components/ui/dropdown-menu.tsx b/spa/src/components/ui/dropdown-menu.tsx
deleted file mode 100644
index 30ddda7..0000000
--- a/spa/src/components/ui/dropdown-menu.tsx
+++ /dev/null
@@ -1,270 +0,0 @@
-import * as React from "react"
-import { Menu as MenuPrimitive } from "@base-ui/react/menu"
-
-import { cn } from "@/lib/utils"
-import { ChevronRightIcon, CheckIcon } from "lucide-react"
-
-function DropdownMenu({ ...props }: MenuPrimitive.Root.Props) {
-  return <MenuPrimitive.Root data-slot="dropdown-menu" {...props} />
-}
-
-function DropdownMenuPortal({ ...props }: MenuPrimitive.Portal.Props) {
-  return <MenuPrimitive.Portal data-slot="dropdown-menu-portal" {...props} />
-}
-
-function DropdownMenuTrigger({ ...props }: MenuPrimitive.Trigger.Props) {
-  return <MenuPrimitive.Trigger data-slot="dropdown-menu-trigger" {...props} />
-}
-
-function DropdownMenuContent({
-  align = "start",
-  alignOffset = 0,
-  side = "bottom",
-  sideOffset = 4,
-  className,
-  ...props
-}: MenuPrimitive.Popup.Props &
-  Pick<
-    MenuPrimitive.Positioner.Props,
-    "align" | "alignOffset" | "side" | "sideOffset"
-  >) {
-  return (
-    <MenuPrimitive.Portal>
-      <MenuPrimitive.Positioner
-        className="isolate z-50 outline-none"
-        align={align}
-        alignOffset={alignOffset}
-        side={side}
-        sideOffset={sideOffset}
-      >
-        <MenuPrimitive.Popup
-          data-slot="dropdown-menu-content"
-          className={cn(
-            "z-50 max-h-(--available-height) w-(--anchor-width) min-w-32 origin-(--transform-origin) overflow-x-hidden overflow-y-auto rounded-lg bg-popover p-1 text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 outline-none data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:overflow-hidden data-closed:fade-out-0 data-closed:zoom-out-95",
-            className
-          )}
-          {...props}
-        />
-      </MenuPrimitive.Positioner>
-    </MenuPrimitive.Portal>
-  )
-}
-
-function DropdownMenuGroup({ ...props }: MenuPrimitive.Group.Props) {
-  return <MenuPrimitive.Group data-slot="dropdown-menu-group" {...props} />
-}
-
-function DropdownMenuLabel({
-  className,
-  inset,
-  ...props
-}: MenuPrimitive.GroupLabel.Props & {
-  inset?: boolean
-}) {
-  return (
-    <MenuPrimitive.GroupLabel
-      data-slot="dropdown-menu-label"
-      data-inset={inset}
-      className={cn(
-        "px-1.5 py-1 text-xs font-medium text-muted-foreground data-inset:pl-7",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function DropdownMenuItem({
-  className,
-  inset,
-  variant = "default",
-  ...props
-}: MenuPrimitive.Item.Props & {
-  inset?: boolean
-  variant?: "default" | "destructive"
-}) {
-  return (
-    <MenuPrimitive.Item
-      data-slot="dropdown-menu-item"
-      data-inset={inset}
-      data-variant={variant}
-      className={cn(
-        "group/dropdown-menu-item relative flex cursor-default items-center gap-1.5 rounded-md px-1.5 py-1 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 data-[variant=destructive]:focus:text-destructive dark:data-[variant=destructive]:focus:bg-destructive/20 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 data-[variant=destructive]:*:[svg]:text-destructive",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function DropdownMenuSub({ ...props }: MenuPrimitive.SubmenuRoot.Props) {
-  return <MenuPrimitive.SubmenuRoot data-slot="dropdown-menu-sub" {...props} />
-}
-
-function DropdownMenuSubTrigger({
-  className,
-  inset,
-  children,
-  ...props
-}: MenuPrimitive.SubmenuTrigger.Props & {
-  inset?: boolean
-}) {
-  return (
-    <MenuPrimitive.SubmenuTrigger
-      data-slot="dropdown-menu-sub-trigger"
-      data-inset={inset}
-      className={cn(
-        "flex cursor-default items-center gap-1.5 rounded-md px-1.5 py-1 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-popup-open:bg-accent data-popup-open:text-accent-foreground data-open:bg-accent data-open:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    >
-      {children}
-      <ChevronRightIcon className="ml-auto" />
-    </MenuPrimitive.SubmenuTrigger>
-  )
-}
-
-function DropdownMenuSubContent({
-  align = "start",
-  alignOffset = -3,
-  side = "right",
-  sideOffset = 0,
-  className,
-  ...props
-}: React.ComponentProps<typeof DropdownMenuContent>) {
-  return (
-    <DropdownMenuContent
-      data-slot="dropdown-menu-sub-content"
-      className={cn(
-        "w-auto min-w-[96px] rounded-lg bg-popover p-1 text-popover-foreground shadow-lg ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
-        className
-      )}
-      align={align}
-      alignOffset={alignOffset}
-      side={side}
-      sideOffset={sideOffset}
-      {...props}
-    />
-  )
-}
-
-function DropdownMenuCheckboxItem({
-  className,
-  children,
-  checked,
-  inset,
-  ...props
-}: MenuPrimitive.CheckboxItem.Props & {
-  inset?: boolean
-}) {
-  return (
-    <MenuPrimitive.CheckboxItem
-      data-slot="dropdown-menu-checkbox-item"
-      data-inset={inset}
-      className={cn(
-        "relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      checked={checked}
-      {...props}
-    >
-      <span
-        className="pointer-events-none absolute right-2 flex items-center justify-center"
-        data-slot="dropdown-menu-checkbox-item-indicator"
-      >
-        <MenuPrimitive.CheckboxItemIndicator>
-          <CheckIcon />
-        </MenuPrimitive.CheckboxItemIndicator>
-      </span>
-      {children}
-    </MenuPrimitive.CheckboxItem>
-  )
-}
-
-function DropdownMenuRadioGroup({ ...props }: MenuPrimitive.RadioGroup.Props) {
-  return (
-    <MenuPrimitive.RadioGroup
-      data-slot="dropdown-menu-radio-group"
-      {...props}
-    />
-  )
-}
-
-function DropdownMenuRadioItem({
-  className,
-  children,
-  inset,
-  ...props
-}: MenuPrimitive.RadioItem.Props & {
-  inset?: boolean
-}) {
-  return (
-    <MenuPrimitive.RadioItem
-      data-slot="dropdown-menu-radio-item"
-      data-inset={inset}
-      className={cn(
-        "relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    >
-      <span
-        className="pointer-events-none absolute right-2 flex items-center justify-center"
-        data-slot="dropdown-menu-radio-item-indicator"
-      >
-        <MenuPrimitive.RadioItemIndicator>
-          <CheckIcon />
-        </MenuPrimitive.RadioItemIndicator>
-      </span>
-      {children}
-    </MenuPrimitive.RadioItem>
-  )
-}
-
-function DropdownMenuSeparator({
-  className,
-  ...props
-}: MenuPrimitive.Separator.Props) {
-  return (
-    <MenuPrimitive.Separator
-      data-slot="dropdown-menu-separator"
-      className={cn("-mx-1 my-1 h-px bg-border", className)}
-      {...props}
-    />
-  )
-}
-
-function DropdownMenuShortcut({
-  className,
-  ...props
-}: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="dropdown-menu-shortcut"
-      className={cn(
-        "ml-auto text-xs tracking-widest text-muted-foreground group-focus/dropdown-menu-item:text-accent-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export {
-  DropdownMenu,
-  DropdownMenuPortal,
-  DropdownMenuTrigger,
-  DropdownMenuContent,
-  DropdownMenuGroup,
-  DropdownMenuLabel,
-  DropdownMenuItem,
-  DropdownMenuCheckboxItem,
-  DropdownMenuRadioGroup,
-  DropdownMenuRadioItem,
-  DropdownMenuSeparator,
-  DropdownMenuShortcut,
-  DropdownMenuSub,
-  DropdownMenuSubTrigger,
-  DropdownMenuSubContent,
-}
diff --git a/spa/src/components/ui/hover-card.tsx b/spa/src/components/ui/hover-card.tsx
deleted file mode 100644
index 58a477c..0000000
--- a/spa/src/components/ui/hover-card.tsx
+++ /dev/null
@@ -1,51 +0,0 @@
-"use client"
-
-import { PreviewCard as PreviewCardPrimitive } from "@base-ui/react/preview-card"
-
-import { cn } from "@/lib/utils"
-
-function HoverCard({ ...props }: PreviewCardPrimitive.Root.Props) {
-  return <PreviewCardPrimitive.Root data-slot="hover-card" {...props} />
-}
-
-function HoverCardTrigger({ ...props }: PreviewCardPrimitive.Trigger.Props) {
-  return (
-    <PreviewCardPrimitive.Trigger data-slot="hover-card-trigger" {...props} />
-  )
-}
-
-function HoverCardContent({
-  className,
-  side = "bottom",
-  sideOffset = 4,
-  align = "center",
-  alignOffset = 4,
-  ...props
-}: PreviewCardPrimitive.Popup.Props &
-  Pick<
-    PreviewCardPrimitive.Positioner.Props,
-    "align" | "alignOffset" | "side" | "sideOffset"
-  >) {
-  return (
-    <PreviewCardPrimitive.Portal data-slot="hover-card-portal">
-      <PreviewCardPrimitive.Positioner
-        align={align}
-        alignOffset={alignOffset}
-        side={side}
-        sideOffset={sideOffset}
-        className="isolate z-50"
-      >
-        <PreviewCardPrimitive.Popup
-          data-slot="hover-card-content"
-          className={cn(
-            "z-50 w-64 origin-(--transform-origin) rounded-lg bg-popover p-2.5 text-sm text-popover-foreground shadow-md ring-1 ring-foreground/10 outline-hidden duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
-            className
-          )}
-          {...props}
-        />
-      </PreviewCardPrimitive.Positioner>
-    </PreviewCardPrimitive.Portal>
-  )
-}
-
-export { HoverCard, HoverCardTrigger, HoverCardContent }
diff --git a/spa/src/components/ui/input-group.tsx b/spa/src/components/ui/input-group.tsx
deleted file mode 100644
index 44ba816..0000000
--- a/spa/src/components/ui/input-group.tsx
+++ /dev/null
@@ -1,159 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { cva } from "class-variance-authority"
-import type { VariantProps } from "class-variance-authority"
-
-import { cn } from "@/lib/utils"
-import { Button } from "@/components/ui/button"
-import { Input } from "@/components/ui/input"
-import { Textarea } from "@/components/ui/textarea"
-
-function InputGroup({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="input-group"
-      role="group"
-      className={cn(
-        "group/input-group relative flex h-8 w-full min-w-0 items-center rounded-lg border border-input transition-colors outline-none in-data-[slot=combobox-content]:focus-within:border-inherit in-data-[slot=combobox-content]:focus-within:ring-0 has-disabled:bg-input/50 has-disabled:opacity-50 has-[[data-slot=input-group-control]:focus-visible]:border-ring has-[[data-slot=input-group-control]:focus-visible]:ring-3 has-[[data-slot=input-group-control]:focus-visible]:ring-ring/50 has-[[data-slot][aria-invalid=true]]:border-destructive has-[[data-slot][aria-invalid=true]]:ring-3 has-[[data-slot][aria-invalid=true]]:ring-destructive/20 has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>textarea]:h-auto dark:bg-input/30 dark:has-disabled:bg-input/80 dark:has-[[data-slot][aria-invalid=true]]:ring-destructive/40 has-[>[data-align=block-end]]:[&>input]:pt-3 has-[>[data-align=block-start]]:[&>input]:pb-3 has-[>[data-align=inline-end]]:[&>input]:pr-1.5 has-[>[data-align=inline-start]]:[&>input]:pl-1.5",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-const inputGroupAddonVariants = cva(
-  "flex h-auto cursor-text items-center justify-center gap-2 py-1.5 text-sm font-medium text-muted-foreground select-none group-data-[disabled=true]/input-group:opacity-50 [&>kbd]:rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-4",
-  {
-    variants: {
-      align: {
-        "inline-start":
-          "order-first pl-2 has-[>button]:ml-[-0.3rem] has-[>kbd]:ml-[-0.15rem]",
-        "inline-end":
-          "order-last pr-2 has-[>button]:mr-[-0.3rem] has-[>kbd]:mr-[-0.15rem]",
-        "block-start":
-          "order-first w-full justify-start px-2.5 pt-2 group-has-[>input]/input-group:pt-2 [.border-b]:pb-2",
-        "block-end":
-          "order-last w-full justify-start px-2.5 pb-2 group-has-[>input]/input-group:pb-2 [.border-t]:pt-2",
-      },
-    },
-    defaultVariants: {
-      align: "inline-start",
-    },
-  }
-)
-
-function InputGroupAddon({
-  className,
-  align = "inline-start",
-  ...props
-}: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>) {
-  return (
-    <div
-      role="group"
-      data-slot="input-group-addon"
-      data-align={align}
-      className={cn(inputGroupAddonVariants({ align }), className)}
-      onClick={(e) => {
-        if ((e.target as HTMLElement).closest("button")) {
-          return
-        }
-        e.currentTarget.parentElement?.querySelector("input")?.focus()
-      }}
-      {...props}
-    />
-  )
-}
-
-const inputGroupButtonVariants = cva(
-  "flex items-center gap-2 text-sm shadow-none",
-  {
-    variants: {
-      size: {
-        xs: "h-6 gap-1 rounded-[calc(var(--radius)-3px)] px-1.5 [&>svg:not([class*='size-'])]:size-3.5",
-        sm: "",
-        "icon-xs":
-          "size-6 rounded-[calc(var(--radius)-3px)] p-0 has-[>svg]:p-0",
-        "icon-sm": "size-8 p-0 has-[>svg]:p-0",
-      },
-    },
-    defaultVariants: {
-      size: "xs",
-    },
-  }
-)
-
-function InputGroupButton({
-  className,
-  type = "button",
-  variant = "ghost",
-  size = "xs",
-  ...props
-}: Omit<React.ComponentProps<typeof Button>, "size" | "type"> &
-  VariantProps<typeof inputGroupButtonVariants> & {
-    type?: "button" | "submit" | "reset"
-  }) {
-  return (
-    <Button
-      type={type}
-      data-size={size}
-      variant={variant}
-      className={cn(inputGroupButtonVariants({ size }), className)}
-      {...props}
-    />
-  )
-}
-
-function InputGroupText({ className, ...props }: React.ComponentProps<"span">) {
-  return (
-    <span
-      className={cn(
-        "flex items-center gap-2 text-sm text-muted-foreground [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function InputGroupInput({
-  className,
-  ...props
-}: React.ComponentProps<"input">) {
-  return (
-    <Input
-      data-slot="input-group-control"
-      className={cn(
-        "flex-1 rounded-none border-0 bg-transparent shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function InputGroupTextarea({
-  className,
-  ...props
-}: React.ComponentProps<"textarea">) {
-  return (
-    <Textarea
-      data-slot="input-group-control"
-      className={cn(
-        "flex-1 resize-none rounded-none border-0 bg-transparent py-2 shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export {
-  InputGroup,
-  InputGroupAddon,
-  InputGroupButton,
-  InputGroupText,
-  InputGroupInput,
-  InputGroupTextarea,
-}
diff --git a/spa/src/components/ui/input-otp.tsx b/spa/src/components/ui/input-otp.tsx
deleted file mode 100644
index 44727a0..0000000
--- a/spa/src/components/ui/input-otp.tsx
+++ /dev/null
@@ -1,84 +0,0 @@
-import * as React from "react"
-import { OTPInput, OTPInputContext } from "input-otp"
-
-import { cn } from "@/lib/utils"
-import { MinusIcon } from "lucide-react"
-
-function InputOTP({
-  className,
-  containerClassName,
-  ...props
-}: React.ComponentProps<typeof OTPInput> & {
-  containerClassName?: string
-}) {
-  return (
-    <OTPInput
-      data-slot="input-otp"
-      containerClassName={cn(
-        "cn-input-otp flex items-center has-disabled:opacity-50",
-        containerClassName
-      )}
-      spellCheck={false}
-      className={cn("disabled:cursor-not-allowed", className)}
-      {...props}
-    />
-  )
-}
-
-function InputOTPGroup({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="input-otp-group"
-      className={cn(
-        "flex items-center rounded-lg has-aria-invalid:border-destructive has-aria-invalid:ring-3 has-aria-invalid:ring-destructive/20 dark:has-aria-invalid:ring-destructive/40",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function InputOTPSlot({
-  index,
-  className,
-  ...props
-}: React.ComponentProps<"div"> & {
-  index: number
-}) {
-  const inputOTPContext = React.useContext(OTPInputContext)
-  const { char, hasFakeCaret, isActive } = inputOTPContext?.slots[index] ?? {}
-
-  return (
-    <div
-      data-slot="input-otp-slot"
-      data-active={isActive}
-      className={cn(
-        "relative flex size-8 items-center justify-center border-y border-r border-input text-sm transition-all outline-none first:rounded-l-lg first:border-l last:rounded-r-lg aria-invalid:border-destructive data-[active=true]:z-10 data-[active=true]:border-ring data-[active=true]:ring-3 data-[active=true]:ring-ring/50 data-[active=true]:aria-invalid:border-destructive data-[active=true]:aria-invalid:ring-destructive/20 dark:bg-input/30 dark:data-[active=true]:aria-invalid:ring-destructive/40",
-        className
-      )}
-      {...props}
-    >
-      {char}
-      {hasFakeCaret && (
-        <div className="pointer-events-none absolute inset-0 flex items-center justify-center">
-          <div className="h-4 w-px animate-caret-blink bg-foreground duration-1000" />
-        </div>
-      )}
-    </div>
-  )
-}
-
-function InputOTPSeparator({ ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="input-otp-separator"
-      className="flex items-center [&_svg:not([class*='size-'])]:size-4"
-      role="separator"
-      {...props}
-    >
-      <MinusIcon />
-    </div>
-  )
-}
-
-export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator }
diff --git a/spa/src/components/ui/item.tsx b/spa/src/components/ui/item.tsx
deleted file mode 100644
index 1dd8863..0000000
--- a/spa/src/components/ui/item.tsx
+++ /dev/null
@@ -1,202 +0,0 @@
-import * as React from "react"
-import { mergeProps } from "@base-ui/react/merge-props"
-import { useRender } from "@base-ui/react/use-render"
-import { cva } from "class-variance-authority"
-import type { VariantProps } from "class-variance-authority"
-
-import { cn } from "@/lib/utils"
-import { Separator } from "@/components/ui/separator"
-
-function ItemGroup({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      role="list"
-      data-slot="item-group"
-      className={cn(
-        "group/item-group flex w-full flex-col gap-4 has-data-[size=sm]:gap-2.5 has-data-[size=xs]:gap-2",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ItemSeparator({
-  className,
-  ...props
-}: React.ComponentProps<typeof Separator>) {
-  return (
-    <Separator
-      data-slot="item-separator"
-      orientation="horizontal"
-      className={cn("my-2", className)}
-      {...props}
-    />
-  )
-}
-
-const itemVariants = cva(
-  "group/item flex w-full flex-wrap items-center rounded-lg border text-sm transition-colors duration-100 outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 [a]:transition-colors [a]:hover:bg-muted",
-  {
-    variants: {
-      variant: {
-        default: "border-transparent",
-        outline: "border-border",
-        muted: "border-transparent bg-muted/50",
-      },
-      size: {
-        default: "gap-2.5 px-3 py-2.5",
-        sm: "gap-2.5 px-3 py-2.5",
-        xs: "gap-2 px-2.5 py-2 in-data-[slot=dropdown-menu-content]:p-0",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-      size: "default",
-    },
-  }
-)
-
-function Item({
-  className,
-  variant = "default",
-  size = "default",
-  render,
-  ...props
-}: useRender.ComponentProps<"div"> & VariantProps<typeof itemVariants>) {
-  return useRender({
-    defaultTagName: "div",
-    props: mergeProps<"div">(
-      {
-        className: cn(itemVariants({ variant, size, className })),
-      },
-      props
-    ),
-    render,
-    state: {
-      slot: "item",
-      variant,
-      size,
-    },
-  })
-}
-
-const itemMediaVariants = cva(
-  "flex shrink-0 items-center justify-center gap-2 group-has-data-[slot=item-description]/item:translate-y-0.5 group-has-data-[slot=item-description]/item:self-start [&_svg]:pointer-events-none",
-  {
-    variants: {
-      variant: {
-        default: "bg-transparent",
-        icon: "[&_svg:not([class*='size-'])]:size-4",
-        image:
-          "size-10 overflow-hidden rounded-sm group-data-[size=sm]/item:size-8 group-data-[size=xs]/item:size-6 [&_img]:size-full [&_img]:object-cover",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-    },
-  }
-)
-
-function ItemMedia({
-  className,
-  variant = "default",
-  ...props
-}: React.ComponentProps<"div"> & VariantProps<typeof itemMediaVariants>) {
-  return (
-    <div
-      data-slot="item-media"
-      data-variant={variant}
-      className={cn(itemMediaVariants({ variant, className }))}
-      {...props}
-    />
-  )
-}
-
-function ItemContent({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="item-content"
-      className={cn(
-        "flex flex-1 flex-col gap-1 group-data-[size=xs]/item:gap-0 [&+[data-slot=item-content]]:flex-none",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ItemTitle({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="item-title"
-      className={cn(
-        "line-clamp-1 flex w-fit items-center gap-2 text-sm leading-snug font-medium underline-offset-4",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ItemDescription({ className, ...props }: React.ComponentProps<"p">) {
-  return (
-    <p
-      data-slot="item-description"
-      className={cn(
-        "line-clamp-2 text-left text-sm leading-normal font-normal text-muted-foreground group-data-[size=xs]/item:text-xs [&>a]:underline [&>a]:underline-offset-4 [&>a:hover]:text-primary",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ItemActions({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="item-actions"
-      className={cn("flex items-center gap-2", className)}
-      {...props}
-    />
-  )
-}
-
-function ItemHeader({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="item-header"
-      className={cn(
-        "flex basis-full items-center justify-between gap-2",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ItemFooter({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="item-footer"
-      className={cn(
-        "flex basis-full items-center justify-between gap-2",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export {
-  Item,
-  ItemMedia,
-  ItemContent,
-  ItemActions,
-  ItemGroup,
-  ItemSeparator,
-  ItemTitle,
-  ItemDescription,
-  ItemHeader,
-  ItemFooter,
-}
diff --git a/spa/src/components/ui/kbd.tsx b/spa/src/components/ui/kbd.tsx
deleted file mode 100644
index ff93b53..0000000
--- a/spa/src/components/ui/kbd.tsx
+++ /dev/null
@@ -1,26 +0,0 @@
-import { cn } from "@/lib/utils"
-
-function Kbd({ className, ...props }: React.ComponentProps<"kbd">) {
-  return (
-    <kbd
-      data-slot="kbd"
-      className={cn(
-        "pointer-events-none inline-flex h-5 w-fit min-w-5 items-center justify-center gap-1 rounded-sm bg-muted px-1 font-sans text-xs font-medium text-muted-foreground select-none in-data-[slot=tooltip-content]:bg-background/20 in-data-[slot=tooltip-content]:text-background dark:in-data-[slot=tooltip-content]:bg-background/10 [&_svg:not([class*='size-'])]:size-3",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function KbdGroup({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <kbd
-      data-slot="kbd-group"
-      className={cn("inline-flex items-center gap-1", className)}
-      {...props}
-    />
-  )
-}
-
-export { Kbd, KbdGroup }
diff --git a/spa/src/components/ui/marker.tsx b/spa/src/components/ui/marker.tsx
deleted file mode 100644
index 5fb0af3..0000000
--- a/spa/src/components/ui/marker.tsx
+++ /dev/null
@@ -1,72 +0,0 @@
-import * as React from "react"
-import { mergeProps } from "@base-ui/react/merge-props"
-import { useRender } from "@base-ui/react/use-render"
-import { cva } from "class-variance-authority"
-import type { VariantProps } from "class-variance-authority"
-
-import { cn } from "@/lib/utils"
-
-const markerVariants = cva(
-  "group/marker relative flex min-h-4 w-full items-center gap-2 text-left text-sm text-muted-foreground [&_svg:not([class*='size-'])]:size-4 [a]:underline [a]:underline-offset-3 [a]:hover:text-foreground",
-  {
-    variants: {
-      variant: {
-        default: "",
-        separator:
-          "before:mr-1 before:h-px before:min-w-0 before:flex-1 before:bg-border after:ml-1 after:h-px after:min-w-0 after:flex-1 after:bg-border",
-        border: "border-b border-border pb-2",
-      },
-    },
-  }
-)
-
-function Marker({
-  className,
-  variant = "default",
-  render,
-  ...props
-}: useRender.ComponentProps<"div"> & VariantProps<typeof markerVariants>) {
-  return useRender({
-    defaultTagName: "div",
-    props: mergeProps<"div">(
-      {
-        className: cn(markerVariants({ variant, className })),
-      },
-      props
-    ),
-    render,
-    state: {
-      slot: "marker",
-      variant,
-    },
-  })
-}
-
-function MarkerIcon({ className, ...props }: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="marker-icon"
-      aria-hidden="true"
-      className={cn(
-        "size-4 shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MarkerContent({ className, ...props }: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="marker-content"
-      className={cn(
-        "min-w-0 wrap-break-word group-data-[variant=separator]/marker:flex-none group-data-[variant=separator]/marker:text-center *:[a]:underline *:[a]:underline-offset-3 *:[a]:hover:text-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export { Marker, MarkerIcon, MarkerContent, markerVariants }
diff --git a/spa/src/components/ui/menubar.tsx b/spa/src/components/ui/menubar.tsx
deleted file mode 100644
index a332bb9..0000000
--- a/spa/src/components/ui/menubar.tsx
+++ /dev/null
@@ -1,284 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { Menu as MenuPrimitive } from "@base-ui/react/menu"
-import { Menubar as MenubarPrimitive } from "@base-ui/react/menubar"
-
-import { cn } from "@/lib/utils"
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuGroup,
-  DropdownMenuItem,
-  DropdownMenuLabel,
-  DropdownMenuPortal,
-  DropdownMenuRadioGroup,
-  DropdownMenuSeparator,
-  DropdownMenuShortcut,
-  DropdownMenuSub,
-  DropdownMenuSubContent,
-  DropdownMenuSubTrigger,
-  DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu"
-import { CheckIcon } from "lucide-react"
-
-function Menubar({ className, ...props }: MenubarPrimitive.Props) {
-  return (
-    <MenubarPrimitive
-      data-slot="menubar"
-      className={cn(
-        "flex h-8 items-center gap-0.5 rounded-lg border p-[3px]",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MenubarMenu({ ...props }: React.ComponentProps<typeof DropdownMenu>) {
-  return <DropdownMenu data-slot="menubar-menu" {...props} />
-}
-
-function MenubarGroup({
-  ...props
-}: React.ComponentProps<typeof DropdownMenuGroup>) {
-  return <DropdownMenuGroup data-slot="menubar-group" {...props} />
-}
-
-function MenubarPortal({
-  ...props
-}: React.ComponentProps<typeof DropdownMenuPortal>) {
-  return <DropdownMenuPortal data-slot="menubar-portal" {...props} />
-}
-
-function MenubarTrigger({
-  className,
-  ...props
-}: React.ComponentProps<typeof DropdownMenuTrigger>) {
-  return (
-    <DropdownMenuTrigger
-      data-slot="menubar-trigger"
-      className={cn(
-        "flex items-center rounded-sm px-1.5 py-[2px] text-sm font-medium outline-hidden select-none hover:bg-muted aria-expanded:bg-muted",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MenubarContent({
-  className,
-  align = "start",
-  alignOffset = -4,
-  sideOffset = 8,
-  ...props
-}: React.ComponentProps<typeof DropdownMenuContent>) {
-  return (
-    <DropdownMenuContent
-      data-slot="menubar-content"
-      align={align}
-      alignOffset={alignOffset}
-      sideOffset={sideOffset}
-      className={cn(
-        "min-w-36 rounded-lg bg-popover p-1 text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MenubarItem({
-  className,
-  inset,
-  variant = "default",
-  ...props
-}: React.ComponentProps<typeof DropdownMenuItem>) {
-  return (
-    <DropdownMenuItem
-      data-slot="menubar-item"
-      data-inset={inset}
-      data-variant={variant}
-      className={cn(
-        "group/menubar-item gap-1.5 rounded-md px-1.5 py-1 text-sm focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-inset:pl-7 data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 data-[variant=destructive]:focus:text-destructive dark:data-[variant=destructive]:focus:bg-destructive/20 data-disabled:opacity-50 [&_svg:not([class*='size-'])]:size-4 data-[variant=destructive]:*:[svg]:text-destructive!",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MenubarCheckboxItem({
-  className,
-  children,
-  checked,
-  inset,
-  ...props
-}: MenuPrimitive.CheckboxItem.Props & {
-  inset?: boolean
-}) {
-  return (
-    <MenuPrimitive.CheckboxItem
-      data-slot="menubar-checkbox-item"
-      data-inset={inset}
-      className={cn(
-        "relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-1.5 pl-7 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
-        className
-      )}
-      checked={checked}
-      {...props}
-    >
-      <span className="pointer-events-none absolute left-1.5 flex size-4 items-center justify-center [&_svg:not([class*='size-'])]:size-4">
-        <MenuPrimitive.CheckboxItemIndicator>
-          <CheckIcon />
-        </MenuPrimitive.CheckboxItemIndicator>
-      </span>
-      {children}
-    </MenuPrimitive.CheckboxItem>
-  )
-}
-
-function MenubarRadioGroup({
-  ...props
-}: React.ComponentProps<typeof DropdownMenuRadioGroup>) {
-  return <DropdownMenuRadioGroup data-slot="menubar-radio-group" {...props} />
-}
-
-function MenubarRadioItem({
-  className,
-  children,
-  inset,
-  ...props
-}: MenuPrimitive.RadioItem.Props & {
-  inset?: boolean
-}) {
-  return (
-    <MenuPrimitive.RadioItem
-      data-slot="menubar-radio-item"
-      data-inset={inset}
-      className={cn(
-        "relative flex cursor-default items-center gap-1.5 rounded-md py-1 pr-1.5 pl-7 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground data-inset:pl-7 data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    >
-      <span className="pointer-events-none absolute left-1.5 flex size-4 items-center justify-center [&_svg:not([class*='size-'])]:size-4">
-        <MenuPrimitive.RadioItemIndicator>
-          <CheckIcon />
-        </MenuPrimitive.RadioItemIndicator>
-      </span>
-      {children}
-    </MenuPrimitive.RadioItem>
-  )
-}
-
-function MenubarLabel({
-  className,
-  inset,
-  ...props
-}: React.ComponentProps<typeof DropdownMenuLabel> & {
-  inset?: boolean
-}) {
-  return (
-    <DropdownMenuLabel
-      data-slot="menubar-label"
-      data-inset={inset}
-      className={cn(
-        "px-1.5 py-1 text-sm font-medium data-inset:pl-7",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MenubarSeparator({
-  className,
-  ...props
-}: React.ComponentProps<typeof DropdownMenuSeparator>) {
-  return (
-    <DropdownMenuSeparator
-      data-slot="menubar-separator"
-      className={cn("-mx-1 my-1 h-px bg-border", className)}
-      {...props}
-    />
-  )
-}
-
-function MenubarShortcut({
-  className,
-  ...props
-}: React.ComponentProps<typeof DropdownMenuShortcut>) {
-  return (
-    <DropdownMenuShortcut
-      data-slot="menubar-shortcut"
-      className={cn(
-        "ml-auto text-xs tracking-widest text-muted-foreground group-focus/menubar-item:text-accent-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MenubarSub({
-  ...props
-}: React.ComponentProps<typeof DropdownMenuSub>) {
-  return <DropdownMenuSub data-slot="menubar-sub" {...props} />
-}
-
-function MenubarSubTrigger({
-  className,
-  inset,
-  ...props
-}: React.ComponentProps<typeof DropdownMenuSubTrigger> & {
-  inset?: boolean
-}) {
-  return (
-    <DropdownMenuSubTrigger
-      data-slot="menubar-sub-trigger"
-      data-inset={inset}
-      className={cn(
-        "gap-1.5 rounded-md px-1.5 py-1 text-sm focus:bg-accent focus:text-accent-foreground data-inset:pl-7 data-open:bg-accent data-open:text-accent-foreground [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MenubarSubContent({
-  className,
-  ...props
-}: React.ComponentProps<typeof DropdownMenuSubContent>) {
-  return (
-    <DropdownMenuSubContent
-      data-slot="menubar-sub-content"
-      className={cn(
-        "min-w-32 rounded-lg bg-popover p-1 text-popover-foreground shadow-lg ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export {
-  Menubar,
-  MenubarPortal,
-  MenubarMenu,
-  MenubarTrigger,
-  MenubarContent,
-  MenubarGroup,
-  MenubarSeparator,
-  MenubarLabel,
-  MenubarItem,
-  MenubarShortcut,
-  MenubarCheckboxItem,
-  MenubarRadioGroup,
-  MenubarRadioItem,
-  MenubarSub,
-  MenubarSubTrigger,
-  MenubarSubContent,
-}
diff --git a/spa/src/components/ui/message-scroller.tsx b/spa/src/components/ui/message-scroller.tsx
deleted file mode 100644
index 5eecc1a..0000000
--- a/spa/src/components/ui/message-scroller.tsx
+++ /dev/null
@@ -1,128 +0,0 @@
-import * as React from "react"
-import {
-  MessageScroller as MessageScrollerPrimitive,
-  useMessageScroller,
-  useMessageScrollerScrollable,
-  useMessageScrollerVisibility,
-} from "@shadcn/react/message-scroller"
-
-import { cn } from "@/lib/utils"
-import { Button } from "@/components/ui/button"
-import { ArrowDownIcon } from "lucide-react"
-
-function MessageScrollerProvider(
-  props: React.ComponentProps<typeof MessageScrollerPrimitive.Provider>
-) {
-  return <MessageScrollerPrimitive.Provider {...props} />
-}
-
-function MessageScroller({
-  className,
-  ...props
-}: React.ComponentProps<typeof MessageScrollerPrimitive.Root>) {
-  return (
-    <MessageScrollerPrimitive.Root
-      data-slot="message-scroller"
-      className={cn(
-        "group/message-scroller relative flex size-full min-h-0 flex-col overflow-hidden",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MessageScrollerViewport({
-  className,
-  ...props
-}: React.ComponentProps<typeof MessageScrollerPrimitive.Viewport>) {
-  return (
-    <MessageScrollerPrimitive.Viewport
-      data-slot="message-scroller-viewport"
-      className={cn(
-        "size-full min-h-0 min-w-0 scroll-fade-b scrollbar-thin scrollbar-gutter-stable overflow-y-auto overscroll-contain contain-content data-autoscrolling:scrollbar-thumb-transparent data-autoscrolling:scrollbar-track-transparent",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MessageScrollerContent({
-  className,
-  ...props
-}: React.ComponentProps<typeof MessageScrollerPrimitive.Content>) {
-  return (
-    <MessageScrollerPrimitive.Content
-      data-slot="message-scroller-content"
-      className={cn("flex h-max min-h-full flex-col gap-6", className)}
-      {...props}
-    />
-  )
-}
-
-function MessageScrollerItem({
-  className,
-  scrollAnchor = false,
-  ...props
-}: React.ComponentProps<typeof MessageScrollerPrimitive.Item>) {
-  return (
-    <MessageScrollerPrimitive.Item
-      data-slot="message-scroller-item"
-      scrollAnchor={scrollAnchor}
-      className={cn(
-        "min-w-0 shrink-0 [contain-intrinsic-size:auto_10rem] [content-visibility:auto]",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MessageScrollerButton({
-  direction = "end",
-  className,
-  children,
-  render,
-  variant = "secondary",
-  size = "icon-sm",
-  ...props
-}: React.ComponentProps<typeof MessageScrollerPrimitive.Button> &
-  Pick<React.ComponentProps<typeof Button>, "variant" | "size">) {
-  return (
-    <MessageScrollerPrimitive.Button
-      data-slot="message-scroller-button"
-      data-direction={direction}
-      data-variant={variant}
-      data-size={size}
-      direction={direction}
-      className={cn(
-        "absolute inset-s-1/2 -translate-x-1/2 border-border bg-background text-foreground transition-[translate,scale,opacity] duration-200 hover:bg-muted hover:text-foreground data-[active=false]:pointer-events-none data-[active=false]:scale-95 data-[active=false]:opacity-0 data-[active=false]:duration-400 data-[active=false]:ease-[cubic-bezier(0.7,0,0.84,0)] data-[active=true]:translate-y-0 data-[active=true]:scale-100 data-[active=true]:opacity-100 data-[active=true]:ease-[cubic-bezier(0.23,1,0.32,1)] data-[direction=end]:bottom-4 data-[direction=end]:data-[active=false]:translate-y-full data-[direction=start]:top-4 data-[direction=start]:data-[active=false]:-translate-y-full rtl:translate-x-1/2 data-[direction=start]:[&_svg]:rotate-180",
-        className
-      )}
-      render={render ?? <Button variant={variant} size={size} />}
-      {...props}
-    >
-      {children ?? (
-        <>
-          <ArrowDownIcon />
-          <span className="sr-only">
-            {direction === "end" ? "Scroll to end" : "Scroll to start"}
-          </span>
-        </>
-      )}
-    </MessageScrollerPrimitive.Button>
-  )
-}
-
-export {
-  MessageScrollerProvider,
-  MessageScroller,
-  MessageScrollerViewport,
-  MessageScrollerContent,
-  MessageScrollerItem,
-  MessageScrollerButton,
-  useMessageScroller,
-  useMessageScrollerScrollable,
-  useMessageScrollerVisibility,
-}
diff --git a/spa/src/components/ui/message.tsx b/spa/src/components/ui/message.tsx
deleted file mode 100644
index 53437e8..0000000
--- a/spa/src/components/ui/message.tsx
+++ /dev/null
@@ -1,92 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-
-function MessageGroup({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="message-group"
-      className={cn("flex min-w-0 flex-col gap-2", className)}
-      {...props}
-    />
-  )
-}
-
-function Message({
-  className,
-  align = "start",
-  ...props
-}: React.ComponentProps<"div"> & { align?: "start" | "end" }) {
-  return (
-    <div
-      data-slot="message"
-      data-align={align}
-      className={cn(
-        "group/message relative flex w-full min-w-0 gap-2 text-sm data-[align=end]:flex-row-reverse",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MessageAvatar({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="message-avatar"
-      className={cn(
-        "flex w-fit min-w-8 shrink-0 items-center justify-center self-end overflow-hidden rounded-full bg-muted group-has-data-[slot=message-footer]/message:-translate-y-8",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MessageContent({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="message-content"
-      className={cn(
-        "flex w-full min-w-0 flex-col gap-2.5 wrap-break-word group-data-[align=end]/message:*:data-slot:self-end",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MessageHeader({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="message-header"
-      className={cn(
-        "flex max-w-full min-w-0 items-center px-3 text-xs font-medium text-muted-foreground group-has-data-[variant=ghost]/message:px-0",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function MessageFooter({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="message-footer"
-      className={cn(
-        "flex max-w-full min-w-0 items-center px-3 text-xs font-medium text-muted-foreground group-has-data-[variant=ghost]/message:px-0 group-data-[align=end]/message:justify-end",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-export {
-  MessageGroup,
-  Message,
-  MessageAvatar,
-  MessageContent,
-  MessageFooter,
-  MessageHeader,
-}
diff --git a/spa/src/components/ui/native-select.tsx b/spa/src/components/ui/native-select.tsx
deleted file mode 100644
index 5073291..0000000
--- a/spa/src/components/ui/native-select.tsx
+++ /dev/null
@@ -1,65 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-import { ChevronDownIcon } from "lucide-react"
-
-type NativeSelectProps = Omit<React.ComponentProps<"select">, "size"> & {
-  size?: "sm" | "default"
-}
-
-function NativeSelect({
-  className,
-  size = "default",
-  ...props
-}: NativeSelectProps) {
-  return (
-    <div
-      className={cn(
-        "group/native-select relative w-fit has-[select:disabled]:opacity-50",
-        className
-      )}
-      data-slot="native-select-wrapper"
-      data-size={size}
-    >
-      <select
-        data-slot="native-select"
-        data-size={size}
-        className="h-8 w-full min-w-0 appearance-none rounded-lg border border-input bg-transparent py-1 pr-8 pl-2.5 text-sm transition-colors outline-none select-none selection:bg-primary selection:text-primary-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] data-[size=sm]:py-0.5 dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40"
-        {...props}
-      />
-      <ChevronDownIcon
-        className="pointer-events-none absolute top-1/2 right-2.5 size-4 -translate-y-1/2 text-muted-foreground select-none"
-        aria-hidden="true"
-        data-slot="native-select-icon"
-      />
-    </div>
-  )
-}
-
-function NativeSelectOption({
-  className,
-  ...props
-}: React.ComponentProps<"option">) {
-  return (
-    <option
-      data-slot="native-select-option"
-      className={cn("bg-[Canvas] text-[CanvasText]", className)}
-      {...props}
-    />
-  )
-}
-
-function NativeSelectOptGroup({
-  className,
-  ...props
-}: React.ComponentProps<"optgroup">) {
-  return (
-    <optgroup
-      data-slot="native-select-optgroup"
-      className={cn("bg-[Canvas] text-[CanvasText]", className)}
-      {...props}
-    />
-  )
-}
-
-export { NativeSelect, NativeSelectOptGroup, NativeSelectOption }
diff --git a/spa/src/components/ui/navigation-menu.tsx b/spa/src/components/ui/navigation-menu.tsx
deleted file mode 100644
index 94eb5d8..0000000
--- a/spa/src/components/ui/navigation-menu.tsx
+++ /dev/null
@@ -1,171 +0,0 @@
-import { NavigationMenu as NavigationMenuPrimitive } from "@base-ui/react/navigation-menu"
-import { cva } from "class-variance-authority"
-
-import { cn } from "@/lib/utils"
-import { ChevronDownIcon } from "lucide-react"
-
-function NavigationMenu({
-  align = "start",
-  className,
-  children,
-  ...props
-}: NavigationMenuPrimitive.Root.Props &
-  Pick<NavigationMenuPrimitive.Positioner.Props, "align">) {
-  return (
-    <NavigationMenuPrimitive.Root
-      data-slot="navigation-menu"
-      className={cn(
-        "group/navigation-menu relative flex max-w-max flex-1 items-center justify-center",
-        className
-      )}
-      {...props}
-    >
-      {children}
-      <NavigationMenuPositioner align={align} />
-    </NavigationMenuPrimitive.Root>
-  )
-}
-
-function NavigationMenuList({
-  className,
-  ...props
-}: React.ComponentPropsWithRef<typeof NavigationMenuPrimitive.List>) {
-  return (
-    <NavigationMenuPrimitive.List
-      data-slot="navigation-menu-list"
-      className={cn(
-        "group flex flex-1 list-none items-center justify-center gap-0",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function NavigationMenuItem({
-  className,
-  ...props
-}: React.ComponentPropsWithRef<typeof NavigationMenuPrimitive.Item>) {
-  return (
-    <NavigationMenuPrimitive.Item
-      data-slot="navigation-menu-item"
-      className={cn("relative", className)}
-      {...props}
-    />
-  )
-}
-
-const navigationMenuTriggerStyle = cva(
-  "group/navigation-menu-trigger inline-flex h-9 w-max items-center justify-center rounded-lg px-2.5 py-1.5 text-sm font-medium transition-all outline-none hover:bg-muted focus:bg-muted focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 disabled:pointer-events-none disabled:opacity-50 data-popup-open:bg-muted/50 data-popup-open:hover:bg-muted data-open:bg-muted/50 data-open:hover:bg-muted data-open:focus:bg-muted"
-)
-
-function NavigationMenuTrigger({
-  className,
-  children,
-  ...props
-}: NavigationMenuPrimitive.Trigger.Props) {
-  return (
-    <NavigationMenuPrimitive.Trigger
-      data-slot="navigation-menu-trigger"
-      className={cn(navigationMenuTriggerStyle(), "group", className)}
-      {...props}
-    >
-      {children}{" "}
-      <ChevronDownIcon
-        className="relative top-px ml-1 size-3 transition duration-300 group-data-popup-open/navigation-menu-trigger:rotate-180 group-data-open/navigation-menu-trigger:rotate-180"
-        aria-hidden="true"
-      />
-    </NavigationMenuPrimitive.Trigger>
-  )
-}
-
-function NavigationMenuContent({
-  className,
-  ...props
-}: NavigationMenuPrimitive.Content.Props) {
-  return (
-    <NavigationMenuPrimitive.Content
-      data-slot="navigation-menu-content"
-      className={cn(
-        "data-ending-style:data-activation-direction=left:translate-x-[50%] data-ending-style:data-activation-direction=right:translate-x-[-50%] data-starting-style:data-activation-direction=left:translate-x-[-50%] data-starting-style:data-activation-direction=right:translate-x-[50%] h-full w-auto p-1 transition-[opacity,transform,translate] duration-[0.35s] ease-[cubic-bezier(0.22,1,0.36,1)] group-data-[viewport=false]/navigation-menu:rounded-lg group-data-[viewport=false]/navigation-menu:bg-popover group-data-[viewport=false]/navigation-menu:text-popover-foreground group-data-[viewport=false]/navigation-menu:shadow group-data-[viewport=false]/navigation-menu:ring-1 group-data-[viewport=false]/navigation-menu:ring-foreground/10 group-data-[viewport=false]/navigation-menu:duration-300 data-ending-style:opacity-0 data-starting-style:opacity-0 data-[motion=from-end]:slide-in-from-right-52 data-[motion=from-start]:slide-in-from-left-52 data-[motion=to-end]:slide-out-to-right-52 data-[motion=to-start]:slide-out-to-left-52 data-[motion^=from-]:animate-in data-[motion^=from-]:fade-in data-[motion^=to-]:animate-out data-[motion^=to-]:fade-out **:data-[slot=navigation-menu-link]:focus:ring-0 **:data-[slot=navigation-menu-link]:focus:outline-none group-data-[viewport=false]/navigation-menu:data-open:animate-in group-data-[viewport=false]/navigation-menu:data-open:fade-in-0 group-data-[viewport=false]/navigation-menu:data-open:zoom-in-95 group-data-[viewport=false]/navigation-menu:data-closed:animate-out group-data-[viewport=false]/navigation-menu:data-closed:fade-out-0 group-data-[viewport=false]/navigation-menu:data-closed:zoom-out-95",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function NavigationMenuPositioner({
-  className,
-  side = "bottom",
-  sideOffset = 8,
-  align = "start",
-  alignOffset = 0,
-  ...props
-}: NavigationMenuPrimitive.Positioner.Props) {
-  return (
-    <NavigationMenuPrimitive.Portal>
-      <NavigationMenuPrimitive.Positioner
-        side={side}
-        sideOffset={sideOffset}
-        align={align}
-        alignOffset={alignOffset}
-        className={cn(
-          "isolate z-50 h-(--positioner-height) w-(--positioner-width) max-w-(--available-width) transition-[top,left,right,bottom] duration-[0.35s] ease-[cubic-bezier(0.22,1,0.36,1)] data-instant:transition-none data-[side=bottom]:before:top-[-10px] data-[side=bottom]:before:right-0 data-[side=bottom]:before:left-0",
-          className
-        )}
-        {...props}
-      >
-        <NavigationMenuPrimitive.Popup className="data-[ending-style]:easing-[ease] xs:w-(--popup-width) relative h-(--popup-height) w-(--popup-width) origin-(--transform-origin) rounded-lg bg-popover text-popover-foreground shadow ring-1 ring-foreground/10 transition-[opacity,transform,width,height,scale,translate] duration-[0.35s] ease-[cubic-bezier(0.22,1,0.36,1)] outline-none data-ending-style:scale-90 data-ending-style:opacity-0 data-ending-style:duration-150 data-starting-style:scale-90 data-starting-style:opacity-0">
-          <NavigationMenuPrimitive.Viewport className="relative size-full overflow-hidden" />
-        </NavigationMenuPrimitive.Popup>
-      </NavigationMenuPrimitive.Positioner>
-    </NavigationMenuPrimitive.Portal>
-  )
-}
-
-function NavigationMenuLink({
-  className,
-  ...props
-}: NavigationMenuPrimitive.Link.Props) {
-  return (
-    <NavigationMenuPrimitive.Link
-      data-slot="navigation-menu-link"
-      className={cn(
-        "flex items-center gap-2 rounded-lg p-2 text-sm transition-all outline-none hover:bg-muted focus:bg-muted focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 in-data-[slot=navigation-menu-content]:rounded-md data-active:bg-muted/50 data-active:hover:bg-muted data-active:focus:bg-muted [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function NavigationMenuIndicator({
-  className,
-  ...props
-}: React.ComponentPropsWithRef<typeof NavigationMenuPrimitive.Icon>) {
-  return (
-    <NavigationMenuPrimitive.Icon
-      data-slot="navigation-menu-indicator"
-      className={cn(
-        "top-full z-1 flex h-1.5 items-end justify-center overflow-hidden data-[state=hidden]:animate-out data-[state=hidden]:fade-out data-[state=visible]:animate-in data-[state=visible]:fade-in",
-        className
-      )}
-      {...props}
-    >
-      <div className="relative top-[60%] h-2 w-2 rotate-45 rounded-tl-sm bg-border shadow-md" />
-    </NavigationMenuPrimitive.Icon>
-  )
-}
-
-export {
-  NavigationMenu,
-  NavigationMenuContent,
-  NavigationMenuIndicator,
-  NavigationMenuItem,
-  NavigationMenuLink,
-  NavigationMenuList,
-  NavigationMenuTrigger,
-  navigationMenuTriggerStyle,
-  NavigationMenuPositioner,
-}
diff --git a/spa/src/components/ui/pagination.tsx b/spa/src/components/ui/pagination.tsx
deleted file mode 100644
index b8097fd..0000000
--- a/spa/src/components/ui/pagination.tsx
+++ /dev/null
@@ -1,133 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-import { Button } from "@/components/ui/button"
-import {
-  ChevronLeftIcon,
-  ChevronRightIcon,
-  MoreHorizontalIcon,
-} from "lucide-react"
-
-function Pagination({ className, ...props }: React.ComponentProps<"nav">) {
-  return (
-    <nav
-      role="navigation"
-      aria-label="pagination"
-      data-slot="pagination"
-      className={cn("mx-auto flex w-full justify-center", className)}
-      {...props}
-    />
-  )
-}
-
-function PaginationContent({
-  className,
-  ...props
-}: React.ComponentProps<"ul">) {
-  return (
-    <ul
-      data-slot="pagination-content"
-      className={cn("flex items-center gap-0.5", className)}
-      {...props}
-    />
-  )
-}
-
-function PaginationItem({ ...props }: React.ComponentProps<"li">) {
-  return <li data-slot="pagination-item" {...props} />
-}
-
-type PaginationLinkProps = {
-  isActive?: boolean
-} & Pick<React.ComponentProps<typeof Button>, "size"> &
-  React.ComponentProps<"a">
-
-function PaginationLink({
-  className,
-  isActive,
-  size = "icon",
-  ...props
-}: PaginationLinkProps) {
-  return (
-    <Button
-      variant={isActive ? "outline" : "ghost"}
-      size={size}
-      className={cn(className)}
-      nativeButton={false}
-      render={
-        <a
-          aria-current={isActive ? "page" : undefined}
-          data-slot="pagination-link"
-          data-active={isActive}
-          {...props}
-        />
-      }
-    />
-  )
-}
-
-function PaginationPrevious({
-  className,
-  text = "Previous",
-  ...props
-}: React.ComponentProps<typeof PaginationLink> & { text?: string }) {
-  return (
-    <PaginationLink
-      aria-label="Go to previous page"
-      size="default"
-      className={cn("pl-1.5!", className)}
-      {...props}
-    >
-      <ChevronLeftIcon data-icon="inline-start" />
-      <span className="hidden sm:block">{text}</span>
-    </PaginationLink>
-  )
-}
-
-function PaginationNext({
-  className,
-  text = "Next",
-  ...props
-}: React.ComponentProps<typeof PaginationLink> & { text?: string }) {
-  return (
-    <PaginationLink
-      aria-label="Go to next page"
-      size="default"
-      className={cn("pr-1.5!", className)}
-      {...props}
-    >
-      <span className="hidden sm:block">{text}</span>
-      <ChevronRightIcon data-icon="inline-end" />
-    </PaginationLink>
-  )
-}
-
-function PaginationEllipsis({
-  className,
-  ...props
-}: React.ComponentProps<"span">) {
-  return (
-    <span
-      aria-hidden
-      data-slot="pagination-ellipsis"
-      className={cn(
-        "flex size-8 items-center justify-center [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    >
-      <MoreHorizontalIcon />
-      <span className="sr-only">More pages</span>
-    </span>
-  )
-}
-
-export {
-  Pagination,
-  PaginationContent,
-  PaginationEllipsis,
-  PaginationItem,
-  PaginationLink,
-  PaginationNext,
-  PaginationPrevious,
-}
diff --git a/spa/src/components/ui/progress.tsx b/spa/src/components/ui/progress.tsx
deleted file mode 100644
index 986f346..0000000
--- a/spa/src/components/ui/progress.tsx
+++ /dev/null
@@ -1,83 +0,0 @@
-"use client"
-
-import { Progress as ProgressPrimitive } from "@base-ui/react/progress"
-
-import { cn } from "@/lib/utils"
-
-function Progress({
-  className,
-  children,
-  value,
-  ...props
-}: ProgressPrimitive.Root.Props) {
-  return (
-    <ProgressPrimitive.Root
-      value={value}
-      data-slot="progress"
-      className={cn("flex flex-wrap gap-3", className)}
-      {...props}
-    >
-      {children}
-      <ProgressTrack>
-        <ProgressIndicator />
-      </ProgressTrack>
-    </ProgressPrimitive.Root>
-  )
-}
-
-function ProgressTrack({ className, ...props }: ProgressPrimitive.Track.Props) {
-  return (
-    <ProgressPrimitive.Track
-      className={cn(
-        "relative flex h-1 w-full items-center overflow-x-hidden rounded-full bg-muted",
-        className
-      )}
-      data-slot="progress-track"
-      {...props}
-    />
-  )
-}
-
-function ProgressIndicator({
-  className,
-  ...props
-}: ProgressPrimitive.Indicator.Props) {
-  return (
-    <ProgressPrimitive.Indicator
-      data-slot="progress-indicator"
-      className={cn("h-full bg-primary transition-all", className)}
-      {...props}
-    />
-  )
-}
-
-function ProgressLabel({ className, ...props }: ProgressPrimitive.Label.Props) {
-  return (
-    <ProgressPrimitive.Label
-      className={cn("text-sm font-medium", className)}
-      data-slot="progress-label"
-      {...props}
-    />
-  )
-}
-
-function ProgressValue({ className, ...props }: ProgressPrimitive.Value.Props) {
-  return (
-    <ProgressPrimitive.Value
-      className={cn(
-        "ml-auto text-sm text-muted-foreground tabular-nums",
-        className
-      )}
-      data-slot="progress-value"
-      {...props}
-    />
-  )
-}
-
-export {
-  Progress,
-  ProgressTrack,
-  ProgressIndicator,
-  ProgressLabel,
-  ProgressValue,
-}
diff --git a/spa/src/components/ui/questionnaire.tsx b/spa/src/components/ui/questionnaire.tsx
deleted file mode 100644
index 9c5f518..0000000
--- a/spa/src/components/ui/questionnaire.tsx
+++ /dev/null
@@ -1,328 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { Questionnaire as QuestionnairePrimitive } from "@shadcn/react/questionnaire"
-
-import { cn } from "@/lib/utils"
-import { buttonVariants } from "@/components/ui/button"
-import type { Button } from "@/components/ui/button"
-import { CheckIcon } from "lucide-react"
-
-function Questionnaire({
-  className,
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Root>) {
-  return (
-    <QuestionnairePrimitive.Root
-      data-slot="questionnaire"
-      className={cn("flex w-full min-w-0 flex-col gap-4", className)}
-      {...props}
-    />
-  )
-}
-
-function QuestionnaireProgress({
-  className,
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Progress>) {
-  return (
-    <QuestionnairePrimitive.Progress
-      data-slot="questionnaire-progress"
-      className={cn(
-        "min-h-[1lh] w-fit min-w-[14ch] text-xs font-medium text-muted-foreground tabular-nums",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function QuestionnaireItem({
-  className,
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Item>) {
-  return (
-    <QuestionnairePrimitive.Item
-      data-slot="questionnaire-item"
-      className={cn(
-        "flex min-w-0 flex-col gap-4 border-0 p-0 outline-none",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function QuestionnaireTitle({
-  className,
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Title>) {
-  return (
-    <QuestionnairePrimitive.Title
-      data-slot="questionnaire-title"
-      className={cn(
-        "font-heading text-base leading-snug font-medium text-pretty [&:not(:has(~[data-slot=questionnaire-description]))]:mb-4",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function QuestionnaireDescription({
-  className,
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Description>) {
-  return (
-    <QuestionnairePrimitive.Description
-      data-slot="questionnaire-description"
-      className={cn("text-sm text-pretty text-muted-foreground", className)}
-      {...props}
-    />
-  )
-}
-
-function QuestionnaireChoices({
-  className,
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Choices>) {
-  return (
-    <QuestionnairePrimitive.Choices
-      data-slot="questionnaire-choices"
-      className={cn(
-        "group/questionnaire-choices grid min-w-0 gap-2",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function QuestionnaireChoice({
-  children,
-  className,
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Choice>) {
-  return (
-    <QuestionnairePrimitive.Choice
-      data-slot="questionnaire-choice"
-      className={cn(
-        "group/questionnaire-choice relative flex min-h-11 cursor-pointer items-start gap-2.5 rounded-lg border border-input bg-transparent px-3 py-2.5 text-start text-sm transition-colors outline-none select-none hover:bg-muted/50 has-[>input:focus-visible]:border-ring has-[>input:focus-visible]:ring-3 has-[>input:focus-visible]:ring-ring/50 data-invalid:border-destructive dark:bg-input/20 data-checked:border-primary/40 data-checked:bg-muted dark:data-checked:bg-muted",
-        "data-disabled:pointer-events-none data-disabled:cursor-not-allowed data-disabled:opacity-50",
-        className
-      )}
-      {...props}
-    >
-      <QuestionnairePrimitive.ChoiceInput
-        data-slot="questionnaire-choice-input"
-        className="absolute inset-0 z-10 size-full cursor-pointer opacity-0"
-      />
-      <span
-        aria-hidden="true"
-        data-slot="questionnaire-choice-indicator"
-        className="pointer-events-none relative flex size-4 shrink-0 translate-y-[--spacing(0.45)] items-center justify-center rounded-[4px] border border-input group-has-data-[slot=questionnaire-choice-description]/questionnaire-choice:translate-y-0.5 group-data-[type=radio]/questionnaire-choice:rounded-full group-data-checked/questionnaire-choice:border-primary group-data-checked/questionnaire-choice:bg-primary group-data-checked/questionnaire-choice:text-primary-foreground dark:bg-input/30 dark:group-data-checked/questionnaire-choice:bg-primary"
-      >
-        <span
-          data-slot="questionnaire-choice-indicator-dot"
-          className="hidden size-2 rounded-full bg-primary-foreground group-data-[type=checkbox]/questionnaire-choice:hidden group-data-checked/questionnaire-choice:block"
-        />
-        <CheckIcon
-          data-slot="questionnaire-choice-indicator-check"
-          className="hidden size-3.5 group-data-[type=radio]/questionnaire-choice:hidden group-data-checked/questionnaire-choice:block"
-        />
-      </span>
-      <QuestionnairePrimitive.ChoiceLabel
-        data-slot="questionnaire-choice-label"
-        className="flex min-w-0 flex-1 flex-col gap-0.5 leading-snug"
-      >
-        {children}
-      </QuestionnairePrimitive.ChoiceLabel>
-      <QuestionnairePrimitive.ChoiceShortcut
-        data-slot="questionnaire-choice-shortcut"
-        className="pointer-events-none ms-auto hidden size-5 shrink-0 translate-y-[--spacing(0.45)] items-center justify-center rounded-md border border-input bg-background font-mono text-[0.625rem] leading-none font-medium text-muted-foreground group-has-data-[slot=questionnaire-choice-description]/questionnaire-choice:translate-y-0.5 group-data-[shortcut]/questionnaire-choice:inline-flex"
-      />
-    </QuestionnairePrimitive.Choice>
-  )
-}
-
-function QuestionnaireChoiceDescription({
-  className,
-  ...props
-}: React.ComponentProps<"span">) {
-  return (
-    <span
-      data-slot="questionnaire-choice-description"
-      className={cn("text-muted-foreground", className)}
-      {...props}
-    />
-  )
-}
-
-function QuestionnaireInput({
-  className,
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Input>) {
-  return (
-    <div
-      data-slot="questionnaire-input-wrapper"
-      className="group/questionnaire-input relative w-full min-w-0"
-    >
-      <QuestionnairePrimitive.Input
-        data-slot="questionnaire-input"
-        className={cn(
-          "h-8 min-h-11 w-full min-w-0 rounded-lg border border-input bg-transparent px-2.5 py-1 text-base transition-[color,box-shadow,background-color] outline-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 sm:min-h-0 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
-          "selection:bg-primary selection:text-primary-foreground placeholder:text-muted-foreground",
-          className
-        )}
-        {...props}
-      />
-    </div>
-  )
-}
-
-function QuestionnaireError({
-  className,
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Error>) {
-  return (
-    <QuestionnairePrimitive.Error
-      data-slot="questionnaire-error"
-      className={cn("mt-2 text-sm text-destructive", className)}
-      {...props}
-    />
-  )
-}
-
-function QuestionnaireActions({
-  className,
-  ...props
-}: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="questionnaire-actions"
-      className={cn(
-        "grid min-h-11 w-full grid-cols-[minmax(0,1fr)_auto_auto] items-center gap-2 sm:min-h-8",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function QuestionnairePrevious({
-  children,
-  className,
-  size = "default",
-  variant = "outline",
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Previous> &
-  Pick<React.ComponentProps<typeof Button>, "size" | "variant">) {
-  return (
-    <QuestionnairePrimitive.Previous
-      data-slot="questionnaire-previous"
-      data-size={size}
-      data-variant={variant}
-      className={cn(
-        buttonVariants({ size, variant }),
-        "col-start-1 row-start-1 min-h-11 justify-self-start sm:min-h-0",
-        className
-      )}
-      {...props}
-    >
-      {children ?? "Previous"}
-    </QuestionnairePrimitive.Previous>
-  )
-}
-
-function QuestionnaireSkip({
-  children,
-  className,
-  size = "default",
-  variant = "outline",
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Skip> &
-  Pick<React.ComponentProps<typeof Button>, "size" | "variant">) {
-  return (
-    <QuestionnairePrimitive.Skip
-      data-slot="questionnaire-skip"
-      data-size={size}
-      data-variant={variant}
-      className={cn(
-        buttonVariants({ size, variant }),
-        "col-start-2 row-start-1 min-h-11 justify-self-end sm:min-h-0",
-        className
-      )}
-      {...props}
-    >
-      {children ?? "Skip"}
-    </QuestionnairePrimitive.Skip>
-  )
-}
-
-function QuestionnaireNext({
-  children,
-  className,
-  size = "default",
-  variant = "default",
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Next> &
-  Pick<React.ComponentProps<typeof Button>, "size" | "variant">) {
-  return (
-    <QuestionnairePrimitive.Next
-      data-slot="questionnaire-next"
-      data-size={size}
-      data-variant={variant}
-      className={cn(
-        buttonVariants({ size, variant }),
-        "col-start-3 row-start-1 min-h-11 justify-self-end sm:min-h-0",
-        className
-      )}
-      {...props}
-    >
-      {children ?? "Next"}
-    </QuestionnairePrimitive.Next>
-  )
-}
-
-function QuestionnaireSubmit({
-  children,
-  className,
-  size = "default",
-  variant = "default",
-  ...props
-}: React.ComponentProps<typeof QuestionnairePrimitive.Submit> &
-  Pick<React.ComponentProps<typeof Button>, "size" | "variant">) {
-  return (
-    <QuestionnairePrimitive.Submit
-      data-slot="questionnaire-submit"
-      data-size={size}
-      data-variant={variant}
-      className={cn(
-        buttonVariants({ size, variant }),
-        "col-start-3 row-start-1 min-h-11 justify-self-end sm:min-h-0",
-        className
-      )}
-      {...props}
-    >
-      {children ?? "Submit"}
-    </QuestionnairePrimitive.Submit>
-  )
-}
-
-export {
-  Questionnaire,
-  QuestionnaireActions,
-  QuestionnaireChoice,
-  QuestionnaireChoiceDescription,
-  QuestionnaireChoices,
-  QuestionnaireDescription,
-  QuestionnaireError,
-  QuestionnaireInput,
-  QuestionnaireItem,
-  QuestionnaireNext,
-  QuestionnairePrevious,
-  QuestionnaireProgress,
-  QuestionnaireSkip,
-  QuestionnaireSubmit,
-  QuestionnaireTitle,
-}
diff --git a/spa/src/components/ui/radio-group.tsx b/spa/src/components/ui/radio-group.tsx
deleted file mode 100644
index 7887599..0000000
--- a/spa/src/components/ui/radio-group.tsx
+++ /dev/null
@@ -1,36 +0,0 @@
-import { Radio as RadioPrimitive } from "@base-ui/react/radio"
-import { RadioGroup as RadioGroupPrimitive } from "@base-ui/react/radio-group"
-
-import { cn } from "@/lib/utils"
-
-function RadioGroup({ className, ...props }: RadioGroupPrimitive.Props) {
-  return (
-    <RadioGroupPrimitive
-      data-slot="radio-group"
-      className={cn("grid w-full gap-2", className)}
-      {...props}
-    />
-  )
-}
-
-function RadioGroupItem({ className, ...props }: RadioPrimitive.Root.Props) {
-  return (
-    <RadioPrimitive.Root
-      data-slot="radio-group-item"
-      className={cn(
-        "group/radio-group-item peer relative flex aspect-square size-4 shrink-0 rounded-full border border-input outline-none group-has-[:focus-visible]/field-label:ring-0 group-has-[:focus-visible]/field-label:not-data-checked:border-input after:absolute after:-inset-x-3 after:-inset-y-2 focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 aria-invalid:aria-checked:border-primary dark:bg-input/30 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 data-checked:border-primary data-checked:bg-primary data-checked:text-primary-foreground group-has-[:focus-visible]/field-label:data-checked:border-primary dark:data-checked:bg-primary",
-        className
-      )}
-      {...props}
-    >
-      <RadioPrimitive.Indicator
-        data-slot="radio-group-indicator"
-        className="flex size-4 items-center justify-center"
-      >
-        <span className="absolute top-1/2 left-1/2 size-2 -translate-x-1/2 -translate-y-1/2 rounded-full bg-primary-foreground" />
-      </RadioPrimitive.Indicator>
-    </RadioPrimitive.Root>
-  )
-}
-
-export { RadioGroup, RadioGroupItem }
diff --git a/spa/src/components/ui/resizable.tsx b/spa/src/components/ui/resizable.tsx
deleted file mode 100644
index c9e767a..0000000
--- a/spa/src/components/ui/resizable.tsx
+++ /dev/null
@@ -1,50 +0,0 @@
-"use client"
-
-import * as ResizablePrimitive from "react-resizable-panels"
-
-import { cn } from "@/lib/utils"
-
-function ResizablePanelGroup({
-  className,
-  ...props
-}: ResizablePrimitive.GroupProps) {
-  return (
-    <ResizablePrimitive.Group
-      data-slot="resizable-panel-group"
-      className={cn(
-        "flex h-full w-full aria-[orientation=vertical]:flex-col",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function ResizablePanel({ ...props }: ResizablePrimitive.PanelProps) {
-  return <ResizablePrimitive.Panel data-slot="resizable-panel" {...props} />
-}
-
-function ResizableHandle({
-  withHandle,
-  className,
-  ...props
-}: ResizablePrimitive.SeparatorProps & {
-  withHandle?: boolean
-}) {
-  return (
-    <ResizablePrimitive.Separator
-      data-slot="resizable-handle"
-      className={cn(
-        "relative flex w-px items-center justify-center bg-border ring-offset-background after:absolute after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2 focus-visible:ring-1 focus-visible:ring-ring focus-visible:outline-hidden aria-[orientation=horizontal]:h-px aria-[orientation=horizontal]:w-full aria-[orientation=horizontal]:after:left-0 aria-[orientation=horizontal]:after:h-1 aria-[orientation=horizontal]:after:w-full aria-[orientation=horizontal]:after:translate-x-0 aria-[orientation=horizontal]:after:-translate-y-1/2 [&[aria-orientation=horizontal]>div]:rotate-90",
-        className
-      )}
-      {...props}
-    >
-      {withHandle && (
-        <div className="z-10 flex h-6 w-1 shrink-0 rounded-lg bg-border" />
-      )}
-    </ResizablePrimitive.Separator>
-  )
-}
-
-export { ResizableHandle, ResizablePanel, ResizablePanelGroup }
diff --git a/spa/src/components/ui/scroll-area.tsx b/spa/src/components/ui/scroll-area.tsx
deleted file mode 100644
index 7668f21..0000000
--- a/spa/src/components/ui/scroll-area.tsx
+++ /dev/null
@@ -1,52 +0,0 @@
-import { ScrollArea as ScrollAreaPrimitive } from "@base-ui/react/scroll-area"
-
-import { cn } from "@/lib/utils"
-
-function ScrollArea({
-  className,
-  children,
-  ...props
-}: ScrollAreaPrimitive.Root.Props) {
-  return (
-    <ScrollAreaPrimitive.Root
-      data-slot="scroll-area"
-      className={cn("relative", className)}
-      {...props}
-    >
-      <ScrollAreaPrimitive.Viewport
-        data-slot="scroll-area-viewport"
-        className="size-full rounded-[inherit] transition-[color,box-shadow] outline-none focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-1"
-      >
-        {children}
-      </ScrollAreaPrimitive.Viewport>
-      <ScrollBar />
-      <ScrollAreaPrimitive.Corner />
-    </ScrollAreaPrimitive.Root>
-  )
-}
-
-function ScrollBar({
-  className,
-  orientation = "vertical",
-  ...props
-}: ScrollAreaPrimitive.Scrollbar.Props) {
-  return (
-    <ScrollAreaPrimitive.Scrollbar
-      data-slot="scroll-area-scrollbar"
-      data-orientation={orientation}
-      orientation={orientation}
-      className={cn(
-        "flex touch-none p-px transition-colors select-none data-horizontal:h-2.5 data-horizontal:flex-col data-horizontal:border-t data-horizontal:border-t-transparent data-vertical:h-full data-vertical:w-2.5 data-vertical:border-l data-vertical:border-l-transparent",
-        className
-      )}
-      {...props}
-    >
-      <ScrollAreaPrimitive.Thumb
-        data-slot="scroll-area-thumb"
-        className="relative flex-1 rounded-full bg-border"
-      />
-    </ScrollAreaPrimitive.Scrollbar>
-  )
-}
-
-export { ScrollArea, ScrollBar }
diff --git a/spa/src/components/ui/select.tsx b/spa/src/components/ui/select.tsx
deleted file mode 100644
index da4c5ee..0000000
--- a/spa/src/components/ui/select.tsx
+++ /dev/null
@@ -1,202 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { Select as SelectPrimitive } from "@base-ui/react/select"
-
-import { cn } from "@/lib/utils"
-import { ChevronDownIcon, CheckIcon, ChevronUpIcon } from "lucide-react"
-
-const Select = SelectPrimitive.Root
-
-function SelectGroup({ className, ...props }: SelectPrimitive.Group.Props) {
-  return (
-    <SelectPrimitive.Group
-      data-slot="select-group"
-      className={cn("scroll-my-1 p-1", className)}
-      {...props}
-    />
-  )
-}
-
-function SelectValue({ className, ...props }: SelectPrimitive.Value.Props) {
-  return (
-    <SelectPrimitive.Value
-      data-slot="select-value"
-      className={cn("flex flex-1 text-left", className)}
-      {...props}
-    />
-  )
-}
-
-function SelectTrigger({
-  className,
-  size = "default",
-  children,
-  ...props
-}: SelectPrimitive.Trigger.Props & {
-  size?: "sm" | "default"
-}) {
-  return (
-    <SelectPrimitive.Trigger
-      data-slot="select-trigger"
-      data-size={size}
-      className={cn(
-        "flex w-fit items-center justify-between gap-1.5 rounded-lg border border-input bg-transparent py-2 pr-2 pl-2.5 text-sm whitespace-nowrap transition-colors outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-placeholder:text-muted-foreground data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-1.5 dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    >
-      {children}
-      <SelectPrimitive.Icon
-        render={
-          <ChevronDownIcon className="pointer-events-none size-4 text-muted-foreground" />
-        }
-      />
-    </SelectPrimitive.Trigger>
-  )
-}
-
-function SelectContent({
-  className,
-  children,
-  side = "bottom",
-  sideOffset = 4,
-  align = "center",
-  alignOffset = 0,
-  alignItemWithTrigger = true,
-  ...props
-}: SelectPrimitive.Popup.Props &
-  Pick<
-    SelectPrimitive.Positioner.Props,
-    "align" | "alignOffset" | "side" | "sideOffset" | "alignItemWithTrigger"
-  >) {
-  return (
-    <SelectPrimitive.Portal>
-      <SelectPrimitive.Positioner
-        side={side}
-        sideOffset={sideOffset}
-        align={align}
-        alignOffset={alignOffset}
-        alignItemWithTrigger={alignItemWithTrigger}
-        className="isolate z-50"
-      >
-        <SelectPrimitive.Popup
-          data-slot="select-content"
-          data-align-trigger={alignItemWithTrigger}
-          className={cn(
-            "relative isolate z-50 max-h-(--available-height) w-(--anchor-width) min-w-36 origin-(--transform-origin) overflow-x-hidden overflow-y-auto rounded-lg bg-popover text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[align-trigger=true]:animate-none data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
-            className
-          )}
-          {...props}
-        >
-          <SelectScrollUpButton />
-          <SelectPrimitive.List>{children}</SelectPrimitive.List>
-          <SelectScrollDownButton />
-        </SelectPrimitive.Popup>
-      </SelectPrimitive.Positioner>
-    </SelectPrimitive.Portal>
-  )
-}
-
-function SelectLabel({
-  className,
-  ...props
-}: SelectPrimitive.GroupLabel.Props) {
-  return (
-    <SelectPrimitive.GroupLabel
-      data-slot="select-label"
-      className={cn("px-1.5 py-1 text-xs text-muted-foreground", className)}
-      {...props}
-    />
-  )
-}
-
-function SelectItem({
-  className,
-  children,
-  ...props
-}: SelectPrimitive.Item.Props) {
-  return (
-    <SelectPrimitive.Item
-      data-slot="select-item"
-      className={cn(
-        "relative flex w-full cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
-        className
-      )}
-      {...props}
-    >
-      <SelectPrimitive.ItemText className="flex flex-1 shrink-0 gap-2 whitespace-nowrap">
-        {children}
-      </SelectPrimitive.ItemText>
-      <SelectPrimitive.ItemIndicator
-        render={
-          <span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center" />
-        }
-      >
-        <CheckIcon className="pointer-events-none" />
-      </SelectPrimitive.ItemIndicator>
-    </SelectPrimitive.Item>
-  )
-}
-
-function SelectSeparator({
-  className,
-  ...props
-}: SelectPrimitive.Separator.Props) {
-  return (
-    <SelectPrimitive.Separator
-      data-slot="select-separator"
-      className={cn("pointer-events-none -mx-1 my-1 h-px bg-border", className)}
-      {...props}
-    />
-  )
-}
-
-function SelectScrollUpButton({
-  className,
-  ...props
-}: React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>) {
-  return (
-    <SelectPrimitive.ScrollUpArrow
-      data-slot="select-scroll-up-button"
-      className={cn(
-        "top-0 z-10 flex w-full cursor-default items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    >
-      <ChevronUpIcon />
-    </SelectPrimitive.ScrollUpArrow>
-  )
-}
-
-function SelectScrollDownButton({
-  className,
-  ...props
-}: React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>) {
-  return (
-    <SelectPrimitive.ScrollDownArrow
-      data-slot="select-scroll-down-button"
-      className={cn(
-        "bottom-0 z-10 flex w-full cursor-default items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4",
-        className
-      )}
-      {...props}
-    >
-      <ChevronDownIcon />
-    </SelectPrimitive.ScrollDownArrow>
-  )
-}
-
-export {
-  Select,
-  SelectContent,
-  SelectGroup,
-  SelectItem,
-  SelectLabel,
-  SelectScrollDownButton,
-  SelectScrollUpButton,
-  SelectSeparator,
-  SelectTrigger,
-  SelectValue,
-}
diff --git a/spa/src/components/ui/sheet.tsx b/spa/src/components/ui/sheet.tsx
deleted file mode 100644
index d4636d1..0000000
--- a/spa/src/components/ui/sheet.tsx
+++ /dev/null
@@ -1,135 +0,0 @@
-import * as React from "react"
-import { Dialog as SheetPrimitive } from "@base-ui/react/dialog"
-
-import { cn } from "@/lib/utils"
-import { Button } from "@/components/ui/button"
-import { XIcon } from "lucide-react"
-
-function Sheet({ ...props }: SheetPrimitive.Root.Props) {
-  return <SheetPrimitive.Root data-slot="sheet" {...props} />
-}
-
-function SheetTrigger({ ...props }: SheetPrimitive.Trigger.Props) {
-  return <SheetPrimitive.Trigger data-slot="sheet-trigger" {...props} />
-}
-
-function SheetClose({ ...props }: SheetPrimitive.Close.Props) {
-  return <SheetPrimitive.Close data-slot="sheet-close" {...props} />
-}
-
-function SheetPortal({ ...props }: SheetPrimitive.Portal.Props) {
-  return <SheetPrimitive.Portal data-slot="sheet-portal" {...props} />
-}
-
-function SheetOverlay({ className, ...props }: SheetPrimitive.Backdrop.Props) {
-  return (
-    <SheetPrimitive.Backdrop
-      data-slot="sheet-overlay"
-      className={cn(
-        "fixed inset-0 z-50 bg-black/10 transition-opacity duration-150 data-ending-style:opacity-0 data-starting-style:opacity-0 supports-backdrop-filter:backdrop-blur-xs",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function SheetContent({
-  className,
-  children,
-  side = "right",
-  showCloseButton = true,
-  ...props
-}: SheetPrimitive.Popup.Props & {
-  side?: "top" | "right" | "bottom" | "left"
-  showCloseButton?: boolean
-}) {
-  return (
-    <SheetPortal>
-      <SheetOverlay />
-      <SheetPrimitive.Popup
-        data-slot="sheet-content"
-        data-side={side}
-        className={cn(
-          "fixed z-50 flex flex-col gap-4 bg-popover bg-clip-padding text-sm text-popover-foreground shadow-lg transition duration-200 ease-in-out data-ending-style:opacity-0 data-starting-style:opacity-0 data-[side=bottom]:inset-x-0 data-[side=bottom]:bottom-0 data-[side=bottom]:h-auto data-[side=bottom]:border-t data-[side=bottom]:data-ending-style:translate-y-[2.5rem] data-[side=bottom]:data-starting-style:translate-y-[2.5rem] data-[side=left]:inset-y-0 data-[side=left]:left-0 data-[side=left]:h-full data-[side=left]:w-3/4 data-[side=left]:border-r data-[side=left]:data-ending-style:translate-x-[-2.5rem] data-[side=left]:data-starting-style:translate-x-[-2.5rem] data-[side=right]:inset-y-0 data-[side=right]:right-0 data-[side=right]:h-full data-[side=right]:w-3/4 data-[side=right]:border-l data-[side=right]:data-ending-style:translate-x-[2.5rem] data-[side=right]:data-starting-style:translate-x-[2.5rem] data-[side=top]:inset-x-0 data-[side=top]:top-0 data-[side=top]:h-auto data-[side=top]:border-b data-[side=top]:data-ending-style:translate-y-[-2.5rem] data-[side=top]:data-starting-style:translate-y-[-2.5rem] data-[side=left]:sm:max-w-sm data-[side=right]:sm:max-w-sm",
-          className
-        )}
-        {...props}
-      >
-        {children}
-        {showCloseButton && (
-          <SheetPrimitive.Close
-            data-slot="sheet-close"
-            render={
-              <Button
-                variant="ghost"
-                className="absolute top-3 right-3"
-                size="icon-sm"
-              />
-            }
-          >
-            <XIcon />
-            <span className="sr-only">Close</span>
-          </SheetPrimitive.Close>
-        )}
-      </SheetPrimitive.Popup>
-    </SheetPortal>
-  )
-}
-
-function SheetHeader({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="sheet-header"
-      className={cn("flex flex-col gap-0.5 p-4", className)}
-      {...props}
-    />
-  )
-}
-
-function SheetFooter({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="sheet-footer"
-      className={cn("mt-auto flex flex-col gap-2 p-4", className)}
-      {...props}
-    />
-  )
-}
-
-function SheetTitle({ className, ...props }: SheetPrimitive.Title.Props) {
-  return (
-    <SheetPrimitive.Title
-      data-slot="sheet-title"
-      className={cn(
-        "font-heading text-base font-medium text-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function SheetDescription({
-  className,
-  ...props
-}: SheetPrimitive.Description.Props) {
-  return (
-    <SheetPrimitive.Description
-      data-slot="sheet-description"
-      className={cn("text-sm text-muted-foreground", className)}
-      {...props}
-    />
-  )
-}
-
-export {
-  Sheet,
-  SheetTrigger,
-  SheetClose,
-  SheetContent,
-  SheetHeader,
-  SheetFooter,
-  SheetTitle,
-  SheetDescription,
-}
diff --git a/spa/src/components/ui/sidebar.tsx b/spa/src/components/ui/sidebar.tsx
deleted file mode 100644
index 39b4c1b..0000000
--- a/spa/src/components/ui/sidebar.tsx
+++ /dev/null
@@ -1,724 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { mergeProps } from "@base-ui/react/merge-props"
-import { useRender } from "@base-ui/react/use-render"
-import { cva } from "class-variance-authority"
-import type { VariantProps } from "class-variance-authority"
-
-import { useIsMobile } from "@/hooks/use-mobile"
-import { cn } from "@/lib/utils"
-import { Button } from "@/components/ui/button"
-import { Input } from "@/components/ui/input"
-import { Separator } from "@/components/ui/separator"
-import {
-  Sheet,
-  SheetContent,
-  SheetDescription,
-  SheetHeader,
-  SheetTitle,
-} from "@/components/ui/sheet"
-import { Skeleton } from "@/components/ui/skeleton"
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipTrigger,
-} from "@/components/ui/tooltip"
-import { PanelLeftIcon } from "lucide-react"
-
-const SIDEBAR_COOKIE_NAME = "sidebar_state"
-const SIDEBAR_COOKIE_MAX_AGE = 60 * 60 * 24 * 7
-const SIDEBAR_WIDTH = "16rem"
-const SIDEBAR_WIDTH_MOBILE = "18rem"
-const SIDEBAR_WIDTH_ICON = "3rem"
-const SIDEBAR_KEYBOARD_SHORTCUT = "b"
-
-type SidebarContextProps = {
-  state: "expanded" | "collapsed"
-  open: boolean
-  setOpen: (open: boolean) => void
-  openMobile: boolean
-  setOpenMobile: (open: boolean) => void
-  isMobile: boolean
-  toggleSidebar: () => void
-}
-
-const SidebarContext = React.createContext<SidebarContextProps | null>(null)
-
-function useSidebar() {
-  const context = React.useContext(SidebarContext)
-  if (!context) {
-    throw new Error("useSidebar must be used within a SidebarProvider.")
-  }
-
-  return context
-}
-
-function SidebarProvider({
-  defaultOpen = true,
-  open: openProp,
-  onOpenChange: setOpenProp,
-  className,
-  style,
-  children,
-  ...props
-}: React.ComponentProps<"div"> & {
-  defaultOpen?: boolean
-  open?: boolean
-  onOpenChange?: (open: boolean) => void
-}) {
-  const isMobile = useIsMobile()
-  const [openMobile, setOpenMobile] = React.useState(false)
-
-  // This is the internal state of the sidebar.
-  // We use openProp and setOpenProp for control from outside the component.
-  const [_open, _setOpen] = React.useState(defaultOpen)
-  const open = openProp ?? _open
-  const setOpen = React.useCallback(
-    (value: boolean | ((value: boolean) => boolean)) => {
-      const openState = typeof value === "function" ? value(open) : value
-      if (setOpenProp) {
-        setOpenProp(openState)
-      } else {
-        _setOpen(openState)
-      }
-
-      // This sets the cookie to keep the sidebar state.
-      document.cookie = `${SIDEBAR_COOKIE_NAME}=${openState}; path=/; max-age=${SIDEBAR_COOKIE_MAX_AGE}`
-    },
-    [setOpenProp, open]
-  )
-
-  // Helper to toggle the sidebar.
-  const toggleSidebar = React.useCallback(() => {
-    return isMobile ? setOpenMobile((open) => !open) : setOpen((open) => !open)
-  }, [isMobile, setOpen, setOpenMobile])
-
-  // Adds a keyboard shortcut to toggle the sidebar.
-  React.useEffect(() => {
-    const handleKeyDown = (event: KeyboardEvent) => {
-      if (
-        event.key === SIDEBAR_KEYBOARD_SHORTCUT &&
-        (event.metaKey || event.ctrlKey)
-      ) {
-        event.preventDefault()
-        toggleSidebar()
-      }
-    }
-
-    window.addEventListener("keydown", handleKeyDown)
-    return () => window.removeEventListener("keydown", handleKeyDown)
-  }, [toggleSidebar])
-
-  // We add a state so that we can do data-state="expanded" or "collapsed".
-  // This makes it easier to style the sidebar with Tailwind classes.
-  const state = open ? "expanded" : "collapsed"
-
-  const contextValue = React.useMemo<SidebarContextProps>(
-    () => ({
-      state,
-      open,
-      setOpen,
-      isMobile,
-      openMobile,
-      setOpenMobile,
-      toggleSidebar,
-    }),
-    [state, open, setOpen, isMobile, openMobile, setOpenMobile, toggleSidebar]
-  )
-
-  return (
-    <SidebarContext.Provider value={contextValue}>
-      <div
-        data-slot="sidebar-wrapper"
-        style={
-          {
-            "--sidebar-width": SIDEBAR_WIDTH,
-            "--sidebar-width-icon": SIDEBAR_WIDTH_ICON,
-            ...style,
-          } as React.CSSProperties
-        }
-        className={cn(
-          "group/sidebar-wrapper flex min-h-svh w-full has-data-[variant=inset]:bg-sidebar",
-          className
-        )}
-        {...props}
-      >
-        {children}
-      </div>
-    </SidebarContext.Provider>
-  )
-}
-
-function Sidebar({
-  side = "left",
-  variant = "sidebar",
-  collapsible = "offcanvas",
-  className,
-  children,
-  dir,
-  ...props
-}: React.ComponentProps<"div"> & {
-  side?: "left" | "right"
-  variant?: "sidebar" | "floating" | "inset"
-  collapsible?: "offcanvas" | "icon" | "none"
-}) {
-  const { isMobile, state, openMobile, setOpenMobile } = useSidebar()
-
-  if (collapsible === "none") {
-    return (
-      <div
-        data-slot="sidebar"
-        className={cn(
-          "flex h-full w-(--sidebar-width) flex-col bg-sidebar text-sidebar-foreground",
-          className
-        )}
-        {...props}
-      >
-        {children}
-      </div>
-    )
-  }
-
-  if (isMobile) {
-    return (
-      <Sheet open={openMobile} onOpenChange={setOpenMobile} {...props}>
-        <SheetContent
-          dir={dir}
-          data-sidebar="sidebar"
-          data-slot="sidebar"
-          data-mobile="true"
-          className="w-(--sidebar-width) bg-sidebar p-0 text-sidebar-foreground [&>button]:hidden"
-          style={
-            {
-              "--sidebar-width": SIDEBAR_WIDTH_MOBILE,
-            } as React.CSSProperties
-          }
-          side={side}
-        >
-          <SheetHeader className="sr-only">
-            <SheetTitle>Sidebar</SheetTitle>
-            <SheetDescription>Displays the mobile sidebar.</SheetDescription>
-          </SheetHeader>
-          <div className="flex h-full w-full flex-col">{children}</div>
-        </SheetContent>
-      </Sheet>
-    )
-  }
-
-  return (
-    <div
-      className="group peer hidden text-sidebar-foreground md:block"
-      data-state={state}
-      data-collapsible={state === "collapsed" ? collapsible : ""}
-      data-variant={variant}
-      data-side={side}
-      data-slot="sidebar"
-    >
-      {/* This is what handles the sidebar gap on desktop */}
-      <div
-        data-slot="sidebar-gap"
-        className={cn(
-          "relative w-(--sidebar-width) bg-transparent transition-[width] duration-200 ease-linear",
-          "group-data-[collapsible=offcanvas]:w-0",
-          "group-data-[side=right]:rotate-180",
-          variant === "floating" || variant === "inset"
-            ? "group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)+(--spacing(4)))]"
-            : "group-data-[collapsible=icon]:w-(--sidebar-width-icon)"
-        )}
-      />
-      <div
-        data-slot="sidebar-container"
-        data-side={side}
-        className={cn(
-          "fixed inset-y-0 z-10 hidden h-svh w-(--sidebar-width) transition-[left,right,width] duration-200 ease-linear data-[side=left]:left-0 data-[side=left]:group-data-[collapsible=offcanvas]:left-[calc(var(--sidebar-width)*-1)] data-[side=right]:right-0 data-[side=right]:group-data-[collapsible=offcanvas]:right-[calc(var(--sidebar-width)*-1)] md:flex",
-          // Adjust the padding for floating and inset variants.
-          variant === "floating" || variant === "inset"
-            ? "p-2 group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)+(--spacing(4))+2px)]"
-            : "group-data-[collapsible=icon]:w-(--sidebar-width-icon) group-data-[side=left]:border-r group-data-[side=right]:border-l",
-          className
-        )}
-        {...props}
-      >
-        <div
-          data-sidebar="sidebar"
-          data-slot="sidebar-inner"
-          className="flex size-full flex-col bg-sidebar group-data-[variant=floating]:rounded-lg group-data-[variant=floating]:shadow-sm group-data-[variant=floating]:ring-1 group-data-[variant=floating]:ring-sidebar-border"
-        >
-          {children}
-        </div>
-      </div>
-    </div>
-  )
-}
-
-function SidebarTrigger({
-  className,
-  onClick,
-  ...props
-}: React.ComponentProps<typeof Button>) {
-  const { toggleSidebar } = useSidebar()
-
-  return (
-    <Button
-      data-sidebar="trigger"
-      data-slot="sidebar-trigger"
-      variant="ghost"
-      size="icon-sm"
-      className={cn(className)}
-      onClick={(event) => {
-        onClick?.(event)
-        toggleSidebar()
-      }}
-      {...props}
-    >
-      <PanelLeftIcon />
-      <span className="sr-only">Toggle Sidebar</span>
-    </Button>
-  )
-}
-
-function SidebarRail({ className, ...props }: React.ComponentProps<"button">) {
-  const { toggleSidebar } = useSidebar()
-
-  return (
-    <button
-      data-sidebar="rail"
-      data-slot="sidebar-rail"
-      aria-label="Toggle Sidebar"
-      tabIndex={-1}
-      onClick={toggleSidebar}
-      title="Toggle Sidebar"
-      className={cn(
-        "absolute inset-y-0 z-20 hidden w-4 transition-all ease-linear group-data-[side=left]:-right-4 group-data-[side=right]:left-0 after:absolute after:inset-y-0 after:start-1/2 after:w-[2px] hover:after:bg-sidebar-border sm:flex ltr:-translate-x-1/2 rtl:-translate-x-1/2",
-        "in-data-[side=left]:cursor-w-resize in-data-[side=right]:cursor-e-resize",
-        "[[data-side=left][data-state=collapsed]_&]:cursor-e-resize [[data-side=right][data-state=collapsed]_&]:cursor-w-resize",
-        "group-data-[collapsible=offcanvas]:translate-x-0 group-data-[collapsible=offcanvas]:after:left-full hover:group-data-[collapsible=offcanvas]:bg-sidebar",
-        "[[data-side=left][data-collapsible=offcanvas]_&]:-right-2",
-        "[[data-side=right][data-collapsible=offcanvas]_&]:-left-2",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function SidebarInset({ className, ...props }: React.ComponentProps<"main">) {
-  return (
-    <main
-      data-slot="sidebar-inset"
-      className={cn(
-        "relative flex w-full flex-1 flex-col bg-background md:peer-data-[variant=inset]:m-2 md:peer-data-[variant=inset]:ml-0 md:peer-data-[variant=inset]:rounded-xl md:peer-data-[variant=inset]:shadow-sm md:peer-data-[variant=inset]:peer-data-[state=collapsed]:ml-2",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function SidebarInput({
-  className,
-  ...props
-}: React.ComponentProps<typeof Input>) {
-  return (
-    <Input
-      data-slot="sidebar-input"
-      data-sidebar="input"
-      className={cn("h-8 w-full bg-background shadow-none", className)}
-      {...props}
-    />
-  )
-}
-
-function SidebarHeader({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="sidebar-header"
-      data-sidebar="header"
-      className={cn("flex flex-col gap-2 p-2", className)}
-      {...props}
-    />
-  )
-}
-
-function SidebarFooter({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="sidebar-footer"
-      data-sidebar="footer"
-      className={cn("flex flex-col gap-2 p-2", className)}
-      {...props}
-    />
-  )
-}
-
-function SidebarSeparator({
-  className,
-  ...props
-}: React.ComponentProps<typeof Separator>) {
-  return (
-    <Separator
-      data-slot="sidebar-separator"
-      data-sidebar="separator"
-      className={cn("mx-2 w-auto bg-sidebar-border", className)}
-      {...props}
-    />
-  )
-}
-
-function SidebarContent({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="sidebar-content"
-      data-sidebar="content"
-      className={cn(
-        "no-scrollbar flex min-h-0 flex-1 flex-col gap-0 overflow-auto group-data-[collapsible=icon]:overflow-hidden",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function SidebarGroup({ className, ...props }: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="sidebar-group"
-      data-sidebar="group"
-      className={cn("relative flex w-full min-w-0 flex-col p-2", className)}
-      {...props}
-    />
-  )
-}
-
-function SidebarGroupLabel({
-  className,
-  render,
-  ...props
-}: useRender.ComponentProps<"div"> & React.ComponentProps<"div">) {
-  return useRender({
-    defaultTagName: "div",
-    props: mergeProps<"div">(
-      {
-        className: cn(
-          "flex h-8 shrink-0 items-center rounded-md px-2 text-xs font-medium text-sidebar-foreground/70 ring-sidebar-ring outline-hidden transition-[margin,opacity] duration-200 ease-linear group-data-[collapsible=icon]:-mt-8 group-data-[collapsible=icon]:opacity-0 focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0",
-          className
-        ),
-      },
-      props
-    ),
-    render,
-    state: {
-      slot: "sidebar-group-label",
-      sidebar: "group-label",
-    },
-  })
-}
-
-function SidebarGroupAction({
-  className,
-  render,
-  ...props
-}: useRender.ComponentProps<"button"> & React.ComponentProps<"button">) {
-  return useRender({
-    defaultTagName: "button",
-    props: mergeProps<"button">(
-      {
-        className: cn(
-          "absolute top-3.5 right-3 flex aspect-square w-5 items-center justify-center rounded-md p-0 text-sidebar-foreground ring-sidebar-ring outline-hidden transition-transform group-data-[collapsible=icon]:hidden after:absolute after:-inset-2 hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 md:after:hidden [&>svg]:size-4 [&>svg]:shrink-0",
-          className
-        ),
-      },
-      props
-    ),
-    render,
-    state: {
-      slot: "sidebar-group-action",
-      sidebar: "group-action",
-    },
-  })
-}
-
-function SidebarGroupContent({
-  className,
-  ...props
-}: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="sidebar-group-content"
-      data-sidebar="group-content"
-      className={cn("w-full text-sm", className)}
-      {...props}
-    />
-  )
-}
-
-function SidebarMenu({ className, ...props }: React.ComponentProps<"ul">) {
-  return (
-    <ul
-      data-slot="sidebar-menu"
-      data-sidebar="menu"
-      className={cn("flex w-full min-w-0 flex-col gap-0", className)}
-      {...props}
-    />
-  )
-}
-
-function SidebarMenuItem({ className, ...props }: React.ComponentProps<"li">) {
-  return (
-    <li
-      data-slot="sidebar-menu-item"
-      data-sidebar="menu-item"
-      className={cn("group/menu-item relative", className)}
-      {...props}
-    />
-  )
-}
-
-const sidebarMenuButtonVariants = cva(
-  "peer/menu-button group/menu-button flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm ring-sidebar-ring outline-hidden transition-[width,height,padding] group-has-data-[sidebar=menu-action]/menu-item:pr-8 group-data-[collapsible=icon]:size-8! group-data-[collapsible=icon]:p-2! hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-open:hover:bg-sidebar-accent data-open:hover:text-sidebar-accent-foreground data-active:bg-sidebar-accent data-active:font-medium data-active:text-sidebar-accent-foreground [&_svg]:size-4 [&_svg]:shrink-0 [&>span:last-child]:truncate",
-  {
-    variants: {
-      variant: {
-        default: "hover:bg-sidebar-accent hover:text-sidebar-accent-foreground",
-        outline:
-          "bg-background shadow-[0_0_0_1px_var(--sidebar-border)] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground hover:shadow-[0_0_0_1px_var(--sidebar-accent)]",
-      },
-      size: {
-        default: "h-8 text-sm",
-        sm: "h-7 text-xs",
-        lg: "h-12 text-sm group-data-[collapsible=icon]:p-0!",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-      size: "default",
-    },
-  }
-)
-
-function SidebarMenuButton({
-  render,
-  isActive = false,
-  variant = "default",
-  size = "default",
-  tooltip,
-  className,
-  ...props
-}: useRender.ComponentProps<"button"> &
-  React.ComponentProps<"button"> & {
-    isActive?: boolean
-    tooltip?: string | React.ComponentProps<typeof TooltipContent>
-  } & VariantProps<typeof sidebarMenuButtonVariants>) {
-  const { isMobile, state } = useSidebar()
-  const comp = useRender({
-    defaultTagName: "button",
-    props: mergeProps<"button">(
-      {
-        className: cn(sidebarMenuButtonVariants({ variant, size }), className),
-      },
-      props
-    ),
-    render: !tooltip ? render : <TooltipTrigger render={render} />,
-    state: {
-      slot: "sidebar-menu-button",
-      sidebar: "menu-button",
-      size,
-      active: isActive,
-    },
-  })
-
-  if (!tooltip) {
-    return comp
-  }
-
-  if (typeof tooltip === "string") {
-    tooltip = {
-      children: tooltip,
-    }
-  }
-
-  return (
-    <Tooltip>
-      {comp}
-      <TooltipContent
-        side="right"
-        align="center"
-        hidden={state !== "collapsed" || isMobile}
-        {...tooltip}
-      />
-    </Tooltip>
-  )
-}
-
-function SidebarMenuAction({
-  className,
-  render,
-  showOnHover = false,
-  ...props
-}: useRender.ComponentProps<"button"> &
-  React.ComponentProps<"button"> & {
-    showOnHover?: boolean
-  }) {
-  return useRender({
-    defaultTagName: "button",
-    props: mergeProps<"button">(
-      {
-        className: cn(
-          "absolute top-1.5 right-1 flex aspect-square w-5 items-center justify-center rounded-md p-0 text-sidebar-foreground ring-sidebar-ring outline-hidden transition-transform group-data-[collapsible=icon]:hidden peer-hover/menu-button:text-sidebar-accent-foreground peer-data-[size=default]/menu-button:top-1.5 peer-data-[size=lg]/menu-button:top-2.5 peer-data-[size=sm]/menu-button:top-1 after:absolute after:-inset-2 hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 md:after:hidden [&>svg]:size-4 [&>svg]:shrink-0",
-          showOnHover &&
-            "group-focus-within/menu-item:opacity-100 group-hover/menu-item:opacity-100 peer-data-active/menu-button:text-sidebar-accent-foreground aria-expanded:opacity-100 md:opacity-0",
-          className
-        ),
-      },
-      props
-    ),
-    render,
-    state: {
-      slot: "sidebar-menu-action",
-      sidebar: "menu-action",
-    },
-  })
-}
-
-function SidebarMenuBadge({
-  className,
-  ...props
-}: React.ComponentProps<"div">) {
-  return (
-    <div
-      data-slot="sidebar-menu-badge"
-      data-sidebar="menu-badge"
-      className={cn(
-        "pointer-events-none absolute right-1 flex h-5 min-w-5 items-center justify-center rounded-md px-1 text-xs font-medium text-sidebar-foreground tabular-nums select-none group-data-[collapsible=icon]:hidden peer-hover/menu-button:text-sidebar-accent-foreground peer-data-[size=default]/menu-button:top-1.5 peer-data-[size=lg]/menu-button:top-2.5 peer-data-[size=sm]/menu-button:top-1 peer-data-active/menu-button:text-sidebar-accent-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function SidebarMenuSkeleton({
-  className,
-  showIcon = false,
-  ...props
-}: React.ComponentProps<"div"> & {
-  showIcon?: boolean
-}) {
-  // Random width between 50 to 90%.
-  const [width] = React.useState(() => {
-    return `${Math.floor(Math.random() * 40) + 50}%`
-  })
-
-  return (
-    <div
-      data-slot="sidebar-menu-skeleton"
-      data-sidebar="menu-skeleton"
-      className={cn("flex h-8 items-center gap-2 rounded-md px-2", className)}
-      {...props}
-    >
-      {showIcon && (
-        <Skeleton
-          className="size-4 rounded-md"
-          data-sidebar="menu-skeleton-icon"
-        />
-      )}
-      <Skeleton
-        className="h-4 max-w-(--skeleton-width) flex-1"
-        data-sidebar="menu-skeleton-text"
-        style={
-          {
-            "--skeleton-width": width,
-          } as React.CSSProperties
-        }
-      />
-    </div>
-  )
-}
-
-function SidebarMenuSub({ className, ...props }: React.ComponentProps<"ul">) {
-  return (
-    <ul
-      data-slot="sidebar-menu-sub"
-      data-sidebar="menu-sub"
-      className={cn(
-        "mx-3.5 flex min-w-0 translate-x-px flex-col gap-1 border-l border-sidebar-border px-2.5 py-0.5 group-data-[collapsible=icon]:hidden",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function SidebarMenuSubItem({
-  className,
-  ...props
-}: React.ComponentProps<"li">) {
-  return (
-    <li
-      data-slot="sidebar-menu-sub-item"
-      data-sidebar="menu-sub-item"
-      className={cn("group/menu-sub-item relative", className)}
-      {...props}
-    />
-  )
-}
-
-function SidebarMenuSubButton({
-  render,
-  size = "md",
-  isActive = false,
-  className,
-  ...props
-}: useRender.ComponentProps<"a"> &
-  React.ComponentProps<"a"> & {
-    size?: "sm" | "md"
-    isActive?: boolean
-  }) {
-  return useRender({
-    defaultTagName: "a",
-    props: mergeProps<"a">(
-      {
-        className: cn(
-          "flex h-7 min-w-0 -translate-x-px items-center gap-2 overflow-hidden rounded-md px-2 text-sidebar-foreground ring-sidebar-ring outline-hidden group-data-[collapsible=icon]:hidden hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[size=md]:text-sm data-[size=sm]:text-xs data-active:bg-sidebar-accent data-active:text-sidebar-accent-foreground [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0 [&>svg]:text-sidebar-accent-foreground",
-          className
-        ),
-      },
-      props
-    ),
-    render,
-    state: {
-      slot: "sidebar-menu-sub-button",
-      sidebar: "menu-sub-button",
-      size,
-      active: isActive,
-    },
-  })
-}
-
-export {
-  Sidebar,
-  SidebarContent,
-  SidebarFooter,
-  SidebarGroup,
-  SidebarGroupAction,
-  SidebarGroupContent,
-  SidebarGroupLabel,
-  SidebarHeader,
-  SidebarInput,
-  SidebarInset,
-  SidebarMenu,
-  SidebarMenuAction,
-  SidebarMenuBadge,
-  SidebarMenuButton,
-  SidebarMenuItem,
-  SidebarMenuSkeleton,
-  SidebarMenuSub,
-  SidebarMenuSubButton,
-  SidebarMenuSubItem,
-  SidebarProvider,
-  SidebarRail,
-  SidebarSeparator,
-  SidebarTrigger,
-  useSidebar,
-}
diff --git a/spa/src/components/ui/table.tsx b/spa/src/components/ui/table.tsx
deleted file mode 100644
index ac9585e..0000000
--- a/spa/src/components/ui/table.tsx
+++ /dev/null
@@ -1,114 +0,0 @@
-import * as React from "react"
-
-import { cn } from "@/lib/utils"
-
-function Table({ className, ...props }: React.ComponentProps<"table">) {
-  return (
-    <div
-      data-slot="table-container"
-      className="relative w-full overflow-x-auto"
-    >
-      <table
-        data-slot="table"
-        className={cn("w-full caption-bottom text-sm", className)}
-        {...props}
-      />
-    </div>
-  )
-}
-
-function TableHeader({ className, ...props }: React.ComponentProps<"thead">) {
-  return (
-    <thead
-      data-slot="table-header"
-      className={cn("[&_tr]:border-b", className)}
-      {...props}
-    />
-  )
-}
-
-function TableBody({ className, ...props }: React.ComponentProps<"tbody">) {
-  return (
-    <tbody
-      data-slot="table-body"
-      className={cn("[&_tr:last-child]:border-0", className)}
-      {...props}
-    />
-  )
-}
-
-function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">) {
-  return (
-    <tfoot
-      data-slot="table-footer"
-      className={cn(
-        "border-t bg-muted/50 font-medium [&>tr]:last:border-b-0",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function TableRow({ className, ...props }: React.ComponentProps<"tr">) {
-  return (
-    <tr
-      data-slot="table-row"
-      className={cn(
-        "border-b transition-colors hover:bg-muted/50 has-aria-expanded:bg-muted/50 data-[state=selected]:bg-muted",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function TableHead({ className, ...props }: React.ComponentProps<"th">) {
-  return (
-    <th
-      data-slot="table-head"
-      className={cn(
-        "h-10 px-2 text-left align-middle font-medium whitespace-nowrap text-foreground [&:has([role=checkbox])]:pr-0",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function TableCell({ className, ...props }: React.ComponentProps<"td">) {
-  return (
-    <td
-      data-slot="table-cell"
-      className={cn(
-        "p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-
-function TableCaption({
-  className,
-  ...props
-}: React.ComponentProps<"caption">) {
-  return (
-    <caption
-      data-slot="table-caption"
-      className={cn("mt-4 text-sm text-muted-foreground", className)}
-      {...props}
-    />
-  )
-}
-
-export {
-  Table,
-  TableHeader,
-  TableBody,
-  TableFooter,
-  TableHead,
-  TableRow,
-  TableCell,
-  TableCaption,
-}
diff --git a/spa/src/components/ui/toggle-group.tsx b/spa/src/components/ui/toggle-group.tsx
deleted file mode 100644
index 8494a41..0000000
--- a/spa/src/components/ui/toggle-group.tsx
+++ /dev/null
@@ -1,87 +0,0 @@
-import * as React from "react"
-import { Toggle as TogglePrimitive } from "@base-ui/react/toggle"
-import { ToggleGroup as ToggleGroupPrimitive } from "@base-ui/react/toggle-group"
-import type { VariantProps } from "class-variance-authority"
-
-import { cn } from "@/lib/utils"
-import { toggleVariants } from "@/components/ui/toggle"
-
-const ToggleGroupContext = React.createContext<
-  VariantProps<typeof toggleVariants> & {
-    spacing?: number
-    orientation?: "horizontal" | "vertical"
-  }
->({
-  size: "default",
-  variant: "default",
-  spacing: 2,
-  orientation: "horizontal",
-})
-
-function ToggleGroup({
-  className,
-  variant,
-  size,
-  spacing = 2,
-  orientation = "horizontal",
-  children,
-  ...props
-}: ToggleGroupPrimitive.Props &
-  VariantProps<typeof toggleVariants> & {
-    spacing?: number
-    orientation?: "horizontal" | "vertical"
-  }) {
-  return (
-    <ToggleGroupPrimitive
-      data-slot="toggle-group"
-      data-variant={variant}
-      data-size={size}
-      data-spacing={spacing}
-      data-orientation={orientation}
-      style={{ "--gap": spacing } as React.CSSProperties}
-      className={cn(
-        "group/toggle-group flex w-fit flex-row items-center gap-[--spacing(var(--gap))] rounded-lg data-[size=sm]:rounded-[min(var(--radius-md),10px)] data-vertical:flex-col data-vertical:items-stretch",
-        className
-      )}
-      {...props}
-    >
-      <ToggleGroupContext.Provider
-        value={{ variant, size, spacing, orientation }}
-      >
-        {children}
-      </ToggleGroupContext.Provider>
-    </ToggleGroupPrimitive>
-  )
-}
-
-function ToggleGroupItem({
-  className,
-  children,
-  variant = "default",
-  size = "default",
-  ...props
-}: TogglePrimitive.Props & VariantProps<typeof toggleVariants>) {
-  const context = React.useContext(ToggleGroupContext)
-
-  return (
-    <TogglePrimitive
-      data-slot="toggle-group-item"
-      data-variant={context.variant || variant}
-      data-size={context.size || size}
-      data-spacing={context.spacing}
-      className={cn(
-        "shrink-0 group-data-[spacing=0]/toggle-group:rounded-none group-data-[spacing=0]/toggle-group:px-2 focus:z-10 focus-visible:z-10 group-data-[spacing=0]/toggle-group:has-data-[icon=inline-end]:pr-1.5 group-data-[spacing=0]/toggle-group:has-data-[icon=inline-start]:pl-1.5 group-data-horizontal/toggle-group:data-[spacing=0]:first:rounded-l-lg group-data-vertical/toggle-group:data-[spacing=0]:first:rounded-t-lg group-data-horizontal/toggle-group:data-[spacing=0]:last:rounded-r-lg group-data-vertical/toggle-group:data-[spacing=0]:last:rounded-b-lg group-data-horizontal/toggle-group:data-[spacing=0]:data-[variant=outline]:border-l-0 group-data-vertical/toggle-group:data-[spacing=0]:data-[variant=outline]:border-t-0 group-data-horizontal/toggle-group:data-[spacing=0]:data-[variant=outline]:first:border-l group-data-vertical/toggle-group:data-[spacing=0]:data-[variant=outline]:first:border-t",
-        toggleVariants({
-          variant: context.variant || variant,
-          size: context.size || size,
-        }),
-        className
-      )}
-      {...props}
-    >
-      {children}
-    </TogglePrimitive>
-  )
-}
-
-export { ToggleGroup, ToggleGroupItem }
diff --git a/spa/src/components/ui/toggle.tsx b/spa/src/components/ui/toggle.tsx
deleted file mode 100644
index e6912bc..0000000
--- a/spa/src/components/ui/toggle.tsx
+++ /dev/null
@@ -1,44 +0,0 @@
-import { Toggle as TogglePrimitive } from "@base-ui/react/toggle"
-import { cva } from "class-variance-authority"
-import type { VariantProps } from "class-variance-authority"
-
-import { cn } from "@/lib/utils"
-
-const toggleVariants = cva(
-  "group/toggle inline-flex items-center justify-center gap-1 rounded-lg text-sm font-medium whitespace-nowrap transition-all outline-none hover:bg-muted hover:text-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 aria-pressed:bg-muted data-[state=on]:bg-muted dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-  {
-    variants: {
-      variant: {
-        default: "bg-transparent",
-        outline: "border border-input bg-transparent hover:bg-muted",
-      },
-      size: {
-        default:
-          "h-8 min-w-8 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
-        sm: "h-7 min-w-7 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
-        lg: "h-9 min-w-9 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-      size: "default",
-    },
-  }
-)
-
-function Toggle({
-  className,
-  variant = "default",
-  size = "default",
-  ...props
-}: TogglePrimitive.Props & VariantProps<typeof toggleVariants>) {
-  return (
-    <TogglePrimitive
-      data-slot="toggle"
-      className={cn(toggleVariants({ variant, size, className }))}
-      {...props}
-    />
-  )
-}
-
-export { Toggle, toggleVariants }
diff --git a/spa/src/components/ui/tooltip.tsx b/spa/src/components/ui/tooltip.tsx
deleted file mode 100644
index 69e8a82..0000000
--- a/spa/src/components/ui/tooltip.tsx
+++ /dev/null
@@ -1,66 +0,0 @@
-"use client"
-
-import { Tooltip as TooltipPrimitive } from "@base-ui/react/tooltip"
-
-import { cn } from "@/lib/utils"
-
-function TooltipProvider({
-  delay = 0,
-  ...props
-}: TooltipPrimitive.Provider.Props) {
-  return (
-    <TooltipPrimitive.Provider
-      data-slot="tooltip-provider"
-      delay={delay}
-      {...props}
-    />
-  )
-}
-
-function Tooltip({ ...props }: TooltipPrimitive.Root.Props) {
-  return <TooltipPrimitive.Root data-slot="tooltip" {...props} />
-}
-
-function TooltipTrigger({ ...props }: TooltipPrimitive.Trigger.Props) {
-  return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />
-}
-
-function TooltipContent({
-  className,
-  side = "top",
-  sideOffset = 4,
-  align = "center",
-  alignOffset = 0,
-  children,
-  ...props
-}: TooltipPrimitive.Popup.Props &
-  Pick<
-    TooltipPrimitive.Positioner.Props,
-    "align" | "alignOffset" | "side" | "sideOffset"
-  >) {
-  return (
-    <TooltipPrimitive.Portal>
-      <TooltipPrimitive.Positioner
-        align={align}
-        alignOffset={alignOffset}
-        side={side}
-        sideOffset={sideOffset}
-        className="isolate z-50"
-      >
-        <TooltipPrimitive.Popup
-          data-slot="tooltip-content"
-          className={cn(
-            "z-50 inline-flex w-fit max-w-xs origin-(--transform-origin) items-center gap-1.5 rounded-md bg-foreground px-3 py-1.5 text-xs text-background has-data-[slot=kbd]:pr-1.5 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 **:data-[slot=kbd]:rounded-sm data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
-            className
-          )}
-          {...props}
-        >
-          {children}
-          <TooltipPrimitive.Arrow className="z-50 size-2.5 translate-y-[calc(-50%-2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground data-[side=bottom]:top-1 data-[side=inline-end]:top-1/2! data-[side=inline-end]:-left-1 data-[side=inline-end]:-translate-y-1/2 data-[side=inline-start]:top-1/2! data-[side=inline-start]:-right-1 data-[side=inline-start]:-translate-y-1/2 data-[side=left]:top-1/2! data-[side=left]:-right-1 data-[side=left]:-translate-y-1/2 data-[side=right]:top-1/2! data-[side=right]:-left-1 data-[side=right]:-translate-y-1/2 data-[side=top]:-bottom-2.5" />
-        </TooltipPrimitive.Popup>
-      </TooltipPrimitive.Positioner>
-    </TooltipPrimitive.Portal>
-  )
-}
-
-export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }
diff --git a/spa/src/fonts.css b/spa/src/fonts.css
new file mode 100644
index 0000000..659111c
--- /dev/null
+++ b/spa/src/fonts.css
@@ -0,0 +1,31 @@
+/*
+ * Inter, latin subsets only. The package ships seven subsets and imports all
+ * of them; cyrillic, greek and vietnamese were ~85 kB of font nobody here was
+ * reading. Anything outside these ranges falls back to the system stack.
+ */
+
+@font-face {
+  font-family: "Inter Variable";
+  font-style: normal;
+  font-display: swap;
+  font-weight: 100 900;
+  src: url("@fontsource-variable/inter/files/inter-latin-wght-normal.woff2")
+    format("woff2-variations");
+  unicode-range:
+    U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC,
+    U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212,
+    U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+  font-family: "Inter Variable";
+  font-style: normal;
+  font-display: swap;
+  font-weight: 100 900;
+  src: url("@fontsource-variable/inter/files/inter-latin-ext-wght-normal.woff2")
+    format("woff2-variations");
+  unicode-range:
+    U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304,
+    U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB,
+    U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
diff --git a/spa/src/hooks/use-api-tokens.ts b/spa/src/hooks/use-api-tokens.ts
index 51225e0..7093ded 100644
--- a/spa/src/hooks/use-api-tokens.ts
+++ b/spa/src/hooks/use-api-tokens.ts
@@ -1,5 +1,6 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
 import { tokens } from "@/api/client"
+import type { MintApiTokenRequest } from "@/api/schema"
 
 const TOKENS = ["api-tokens"]
 
@@ -14,7 +15,7 @@ export function useMintApiToken() {
   const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: (name: string) => tokens.mint(name),
+    mutationFn: (body: MintApiTokenRequest) => tokens.mint(body),
     onSuccess: () => queryClient.invalidateQueries({ queryKey: TOKENS }),
   })
 }
diff --git a/spa/src/hooks/use-auth.ts b/spa/src/hooks/use-auth.ts
index d3c6c0b..1e69624 100644
--- a/spa/src/hooks/use-auth.ts
+++ b/spa/src/hooks/use-auth.ts
@@ -1,13 +1,24 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
-import { auth, users } from "@/api/client"
 import { useNavigate } from "@tanstack/react-router"
+import { auth, users } from "@/api/client"
+import {
+  forgetSession,
+  hasSession,
+  refreshToken,
+  rememberSession,
+} from "@/api/session"
+
+/**
+ * The single read of the signed-in account. Everything that needs the profile
+ * goes through this key so one page load makes one request for it.
+ */
+export const CURRENT_USER_KEY = ["auth", "me"] as const
 
 export function useAuth() {
   const { data: user, isLoading } = useQuery({
-    queryKey: ["auth", "me"],
+    queryKey: CURRENT_USER_KEY,
     queryFn: async () => {
-      const token = localStorage.getItem("accessToken")
-      if (!token) return null
+      if (!hasSession()) return null
 
       try {
         return await users.me()
@@ -31,12 +42,11 @@ export function useLogin() {
   const navigate = useNavigate()
 
   return useMutation({
-    meta: { success: "Welcome back!", silent: false },
+    meta: { silent: true, success: "Welcome back!" },
     mutationFn: (body: { identifier: string; password: string }) =>
       auth.login(body),
     onSuccess: (data) => {
-      localStorage.setItem("accessToken", data.accessToken)
-      localStorage.setItem("refreshToken", data.refreshToken)
+      rememberSession(data)
       queryClient.invalidateQueries({ queryKey: ["auth"] })
       navigate({ to: "/" })
     },
@@ -47,7 +57,7 @@ export function useRegister() {
   const navigate = useNavigate()
 
   return useMutation({
-    meta: { success: "Account created! Please log in." },
+    meta: { silent: true, success: "Account created! Please log in." },
     mutationFn: (body: { username: string; email: string; password: string }) =>
       auth.register(body),
     onSuccess: () => {
@@ -63,14 +73,13 @@ export function useLogout() {
   return useMutation({
     meta: { silent: true },
     mutationFn: async () => {
-      const refreshToken = localStorage.getItem("refreshToken")
-      if (refreshToken) {
-        await auth.logout(refreshToken)
+      const token = refreshToken()
+      if (token) {
+        await auth.logout(token)
       }
     },
     onSettled: () => {
-      localStorage.removeItem("accessToken")
-      localStorage.removeItem("refreshToken")
+      forgetSession()
       queryClient.clear()
       navigate({ to: "/login" })
     },
diff --git a/spa/src/hooks/use-calendar.ts b/spa/src/hooks/use-calendar.ts
index 1bf5c40..e5f24cf 100644
--- a/spa/src/hooks/use-calendar.ts
+++ b/spa/src/hooks/use-calendar.ts
@@ -1,10 +1,9 @@
 import { useQuery } from "@tanstack/react-query"
 import { entries } from "@/api/client"
-import { format, startOfMonth, endOfMonth } from "date-fns"
+import { rangeOfMonth } from "@/lib/instant-range"
 
 export function useCalendar(month: Date) {
-  const from = format(startOfMonth(month), "yyyy-MM-dd'T'00:00:00+00:00")
-  const to = format(endOfMonth(month), "yyyy-MM-dd'T'23:59:59+00:00")
+  const { from, to } = rangeOfMonth(month)
 
   return useQuery({
     queryKey: ["calendar", from, to],
diff --git a/spa/src/hooks/use-date-bounds.ts b/spa/src/hooks/use-date-bounds.ts
index aef1cb3..9ef70f0 100644
--- a/spa/src/hooks/use-date-bounds.ts
+++ b/spa/src/hooks/use-date-bounds.ts
@@ -1,24 +1,15 @@
-import { useQuery } from "@tanstack/react-query"
-import { entries } from "@/api/client"
+import { useMoodStats } from "./use-stats"
 
+/** The first and last day this account ever logged, if it has logged at all. */
 export function useDateBounds() {
-  return useQuery({
-    queryKey: ["entries", "bounds"],
-    queryFn: async () => {
-      const all = await entries.list({ limit: 1, offset: 0 })
-      if (!all.length) return null
-      const newest = new Date(all[0].loggedAt)
+  const { data: stats } = useMoodStats("all")
 
-      const stats = await entries.stats()
-      const total = stats.totalEntries
+  if (!stats?.firstLoggedOn || !stats.lastLoggedOn) return { data: null }
 
-      if (total <= 1) return { oldest: newest, newest }
-
-      const last = await entries.list({ limit: 1, offset: total - 1 })
-      const oldest = last.length ? new Date(last[0].loggedAt) : newest
-
-      return { oldest, newest }
+  return {
+    data: {
+      oldest: new Date(stats.firstLoggedOn),
+      newest: new Date(stats.lastLoggedOn),
     },
-    staleTime: 5 * 60_000,
-  })
+  }
 }
diff --git a/spa/src/hooks/use-entries.ts b/spa/src/hooks/use-entries.ts
index 31666e4..6f9b6ed 100644
--- a/spa/src/hooks/use-entries.ts
+++ b/spa/src/hooks/use-entries.ts
@@ -1,11 +1,47 @@
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import {
+  useInfiniteQuery,
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from "@tanstack/react-query"
+import type { QueryClient } from "@tanstack/react-query"
 import { entries } from "@/api/client"
 import type { CreateEntryRequest } from "@/api/schema"
 
-export function useEntries(options?: { limit?: number; offset?: number }) {
+export const ENTRY_PAGE_SIZE = 30
+
+/** Everything a written entry can change. */
+const JOURNAL_KEYS = [["entries"], ["stats"], ["trend"], ["calendar"]] as const
+
+export function invalidateJournal(queryClient: QueryClient): void {
+  for (const queryKey of JOURNAL_KEYS) {
+    queryClient.invalidateQueries({ queryKey })
+  }
+}
+
+/** A narrowing of the journal. Every field left out widens the selection. */
+export interface EntryFilters {
+  mood?: number
+  activity?: string
+  from?: string
+  to?: string
+}
+
+export function useEntryFeed(filters: EntryFilters = {}) {
+  return useInfiniteQuery({
+    queryKey: ["entries", "feed", filters],
+    initialPageParam: 0,
+    queryFn: ({ pageParam }) =>
+      entries.list({ ...filters, limit: ENTRY_PAGE_SIZE, offset: pageParam }),
+    getNextPageParam: (page) =>
+      page.hasMore ? page.offset + page.limit : undefined,
+  })
+}
+
+export function useRecentEntries(limit: number) {
   return useQuery({
-    queryKey: ["entries", { limit: options?.limit, offset: options?.offset }],
-    queryFn: () => entries.list(options),
+    queryKey: ["entries", "recent", limit],
+    queryFn: () => entries.list({ limit }),
   })
 }
 
@@ -23,10 +59,7 @@ export function useCreateEntry() {
   return useMutation({
     meta: { success: "Entry created" },
     mutationFn: (body: CreateEntryRequest) => entries.create(body),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["entries"] })
-      queryClient.invalidateQueries({ queryKey: ["stats"] })
-    },
+    onSuccess: () => invalidateJournal(queryClient),
   })
 }
 
@@ -36,16 +69,6 @@ export function useDeleteEntry() {
   return useMutation({
     meta: { success: "Entry deleted" },
     mutationFn: (id: string) => entries.delete(id),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["entries"] })
-      queryClient.invalidateQueries({ queryKey: ["stats"] })
-    },
-  })
-}
-
-export function useMoodStats(from?: string, to?: string) {
-  return useQuery({
-    queryKey: ["stats", { from, to }],
-    queryFn: () => entries.stats(from && to ? { from, to } : undefined),
+    onSuccess: () => invalidateJournal(queryClient),
   })
 }
diff --git a/spa/src/hooks/use-entry-draft.ts b/spa/src/hooks/use-entry-draft.ts
new file mode 100644
index 0000000..b13b109
--- /dev/null
+++ b/spa/src/hooks/use-entry-draft.ts
@@ -0,0 +1,96 @@
+import { useCallback, useEffect, useRef, useState } from "react"
+import { emptyDraft, isWorthKeeping } from "@/lib/entry-draft"
+import type { EntryDraft } from "@/lib/entry-draft"
+import { clearDraft, loadDraft, saveDraft } from "@/lib/store/draft-store"
+
+const SAVE_AFTER_IDLE_FOR = 400
+
+export interface DraftControls {
+  draft: EntryDraft
+  isLoading: boolean
+  /** True when what is on screen came back from a previous, abandoned session. */
+  wasRestored: boolean
+  set: <TKey extends keyof EntryDraft>(
+    key: TKey,
+    value: EntryDraft[TKey]
+  ) => void
+  toggleActivity: (activityId: string) => void
+  discard: () => void
+}
+
+interface Options {
+  /** A draft to start from. Editing an existing entry supplies one. */
+  initial?: EntryDraft
+  /** Whether to keep this draft across visits. Only the new entry does. */
+  persist: boolean
+}
+
+export function useEntryDraft({ initial, persist }: Options): DraftControls {
+  const [draft, setDraft] = useState<EntryDraft>(initial ?? emptyDraft)
+  const [isLoading, setIsLoading] = useState(persist)
+  const [wasRestored, setWasRestored] = useState(false)
+  const saveTimer = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+  useEffect(() => {
+    if (!persist) return
+
+    let stillMounted = true
+
+    loadDraft().then((stored) => {
+      if (!stillMounted) return
+
+      if (stored && isWorthKeeping(stored)) {
+        setDraft(stored)
+        setWasRestored(true)
+      }
+      setIsLoading(false)
+    })
+
+    return () => {
+      stillMounted = false
+    }
+  }, [persist])
+
+  useEffect(() => {
+    if (!persist || isLoading) return
+
+    if (saveTimer.current) clearTimeout(saveTimer.current)
+    saveTimer.current = setTimeout(() => {
+      if (isWorthKeeping(draft)) {
+        saveDraft(draft)
+      } else {
+        clearDraft()
+      }
+    }, SAVE_AFTER_IDLE_FOR)
+
+    return () => {
+      if (saveTimer.current) clearTimeout(saveTimer.current)
+    }
+  }, [draft, persist, isLoading])
+
+  const set = useCallback(
+    <TKey extends keyof EntryDraft>(key: TKey, value: EntryDraft[TKey]) => {
+      setDraft((current) => ({ ...current, [key]: value }))
+      setWasRestored(false)
+    },
+    []
+  )
+
+  const toggleActivity = useCallback((activityId: string) => {
+    setDraft((current) => ({
+      ...current,
+      activityIds: current.activityIds.includes(activityId)
+        ? current.activityIds.filter((id) => id !== activityId)
+        : [...current.activityIds, activityId],
+    }))
+    setWasRestored(false)
+  }, [])
+
+  const discard = useCallback(() => {
+    setDraft(emptyDraft())
+    setWasRestored(false)
+    if (persist) clearDraft()
+  }, [persist])
+
+  return { draft, isLoading, wasRestored, set, toggleActivity, discard }
+}
diff --git a/spa/src/hooks/use-infinite-scroll.ts b/spa/src/hooks/use-infinite-scroll.ts
new file mode 100644
index 0000000..5b9710e
--- /dev/null
+++ b/spa/src/hooks/use-infinite-scroll.ts
@@ -0,0 +1,37 @@
+import { useEffect, useRef } from "react"
+
+interface InfiniteScroll {
+  hasMore: boolean
+  isLoading: boolean
+  loadMore: () => void
+}
+
+/**
+ * Loads the next page when a sentinel element scrolls into view. Returns the
+ * ref to hang on that sentinel.
+ */
+export function useInfiniteScroll({
+  hasMore,
+  isLoading,
+  loadMore,
+}: InfiniteScroll) {
+  const sentinelRef = useRef<HTMLDivElement | null>(null)
+  const loadMoreRef = useRef(loadMore)
+  loadMoreRef.current = loadMore
+
+  useEffect(() => {
+    const sentinel = sentinelRef.current
+    if (!sentinel || !hasMore || isLoading) return
+
+    const observer = new IntersectionObserver((observed) => {
+      if (observed.some((entry) => entry.isIntersecting)) {
+        loadMoreRef.current()
+      }
+    })
+
+    observer.observe(sentinel)
+    return () => observer.disconnect()
+  }, [hasMore, isLoading])
+
+  return sentinelRef
+}
diff --git a/spa/src/hooks/use-metrics.ts b/spa/src/hooks/use-metrics.ts
index b7d0b7a..eecc2db 100644
--- a/spa/src/hooks/use-metrics.ts
+++ b/spa/src/hooks/use-metrics.ts
@@ -1,5 +1,7 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { subDays } from "date-fns"
 import { metrics } from "@/api/client"
+import { formatDate } from "@/lib/day"
 import type {
   DailyMetricResponse,
   MetricKind,
@@ -19,6 +21,7 @@ export function useSetDailyMetrics() {
   const queryClient = useQueryClient()
 
   return useMutation({
+    meta: { success: "Metrics saved" },
     mutationFn: ({ date, values }: { date: string; values: MetricPayload[] }) =>
       metrics.set(date, values),
     onSuccess: () => queryClient.invalidateQueries({ queryKey: METRICS }),
@@ -30,3 +33,19 @@ export function byKind(
 ): Map<MetricKind, DailyMetricResponse> {
   return new Map(stored?.map((metric) => [metric.kind, metric]) ?? [])
 }
+
+const DAYS_THAT_MAKE_A_HABIT = 30
+
+/**
+ * Whether this account records daily metrics at all. Someone who has never
+ * entered one should not be shown a card asking about their steps.
+ */
+export function useTracksMetrics(): boolean {
+  const today = new Date()
+  const { data } = useDailyMetrics(
+    formatDate(subDays(today, DAYS_THAT_MAKE_A_HABIT)),
+    formatDate(today)
+  )
+
+  return (data?.length ?? 0) > 0
+}
diff --git a/spa/src/hooks/use-new-entry-form.ts b/spa/src/hooks/use-new-entry-form.ts
new file mode 100644
index 0000000..8fb6846
--- /dev/null
+++ b/spa/src/hooks/use-new-entry-form.ts
@@ -0,0 +1,23 @@
+import { useEntryDraft } from "./use-entry-draft"
+import { useSaveNewEntry } from "./use-save-entry"
+
+/**
+ * The new-entry form, wherever it is shown. The sheet and the full page share
+ * one stored draft, so opening one after the other picks up where it left off.
+ */
+export function useNewEntryForm(onSaved: () => void) {
+  const controls = useEntryDraft({ persist: true })
+  const save = useSaveNewEntry()
+
+  return {
+    controls,
+    isSaving: save.isPending,
+    submit: () =>
+      save.mutate(controls.draft, {
+        onSuccess: () => {
+          controls.discard()
+          onSaved()
+        },
+      }),
+  }
+}
diff --git a/spa/src/hooks/use-online.ts b/spa/src/hooks/use-online.ts
new file mode 100644
index 0000000..ddac9fa
--- /dev/null
+++ b/spa/src/hooks/use-online.ts
@@ -0,0 +1,24 @@
+import { useSyncExternalStore } from "react"
+
+function subscribe(onChange: () => void): () => void {
+  window.addEventListener("online", onChange)
+  window.addEventListener("offline", onChange)
+
+  return () => {
+    window.removeEventListener("online", onChange)
+    window.removeEventListener("offline", onChange)
+  }
+}
+
+/**
+ * Whether the browser believes it has a connection. It can be wrong — a
+ * captive portal reads as online — so this steers the interface, and the
+ * outbox still decides what actually sent.
+ */
+export function useOnline(): boolean {
+  return useSyncExternalStore(
+    subscribe,
+    () => navigator.onLine,
+    () => true
+  )
+}
diff --git a/spa/src/hooks/use-outbox.ts b/spa/src/hooks/use-outbox.ts
new file mode 100644
index 0000000..53285c5
--- /dev/null
+++ b/spa/src/hooks/use-outbox.ts
@@ -0,0 +1,105 @@
+import { useEffect, useRef, useState } from "react"
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { flushOutbox, isStuck, retryQueued } from "@/lib/outbox-sync"
+import { dequeue, enqueue, queuedEntries } from "@/lib/store/outbox"
+import type { QueuedEntry } from "@/lib/store/outbox"
+import type { EntryDraft } from "@/lib/entry-draft"
+import { invalidateJournal } from "./use-entries"
+import { useOnline } from "./use-online"
+
+export const OUTBOX_KEY = ["outbox"] as const
+
+export function useQueuedEntries() {
+  return useQuery({
+    queryKey: OUTBOX_KEY,
+    queryFn: queuedEntries,
+    staleTime: Infinity,
+  })
+}
+
+export function useQueueEntry() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    meta: { success: "Saved — it will send when you are back online" },
+    mutationFn: (draft: EntryDraft) => enqueue(draft),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: OUTBOX_KEY }),
+  })
+}
+
+export function useDiscardQueued() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    meta: { success: "Discarded" },
+    mutationFn: (id: string) => dequeue(id),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: OUTBOX_KEY }),
+  })
+}
+
+export function useRetryQueued() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: (queued: QueuedEntry) => retryQueued(queued),
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: OUTBOX_KEY })
+      invalidateJournal(queryClient)
+    },
+  })
+}
+
+/**
+ * How long to wait after a failed pass before trying again. Without a pause
+ * the failure invalidates the queue, the queue wakes this effect, and it flushes
+ * straight into the same failure — a tight loop that burns an entry's attempts
+ * in a second. Regaining a connection resets it to the front.
+ */
+const RETRY_AFTER_SECONDS = [5, 15, 60, 300]
+
+function pauseAfter(failures: number): number {
+  if (failures === 0) return 0
+
+  const index = Math.min(failures, RETRY_AFTER_SECONDS.length) - 1
+  return RETRY_AFTER_SECONDS[index] * 1000
+}
+
+/**
+ * Drains the outbox whenever there is something worth sending and a connection
+ * to send it over. Mounted once, in the authenticated layout.
+ */
+export function useOutboxSync() {
+  const queryClient = useQueryClient()
+  const online = useOnline()
+  const { data: pending } = useQueuedEntries()
+  const [failures, setFailures] = useState(0)
+  const wasOnline = useRef(online)
+
+  const sendable = pending?.filter((queued) => !isStuck(queued)).length ?? 0
+
+  const flush = useMutation({
+    meta: { silent: true },
+    mutationFn: flushOutbox,
+    onSuccess: (outcome) => {
+      setFailures((count) => (outcome.failed > 0 ? count + 1 : 0))
+      queryClient.invalidateQueries({ queryKey: OUTBOX_KEY })
+      if (outcome.sent > 0) invalidateJournal(queryClient)
+    },
+    onError: () => setFailures((count) => count + 1),
+  })
+
+  const { mutate: startFlush, isPending } = flush
+
+  // A connection that has just come back deserves an immediate try.
+  useEffect(() => {
+    if (online && !wasOnline.current) setFailures(0)
+    wasOnline.current = online
+  }, [online])
+
+  useEffect(() => {
+    if (!online || sendable === 0 || isPending) return
+
+    const timer = setTimeout(() => startFlush(), pauseAfter(failures))
+    return () => clearTimeout(timer)
+  }, [online, sendable, failures, isPending, startFlush])
+}
diff --git a/spa/src/hooks/use-preview-urls.ts b/spa/src/hooks/use-preview-urls.ts
new file mode 100644
index 0000000..6e98184
--- /dev/null
+++ b/spa/src/hooks/use-preview-urls.ts
@@ -0,0 +1,29 @@
+import { useEffect, useMemo } from "react"
+import type { MediaItem } from "@/lib/media"
+
+/**
+ * Object URLs for media picked on this device, revoked as soon as the set they
+ * belong to is replaced. Without the revoke every discarded photo stays in
+ * memory for the life of the tab.
+ */
+export function usePreviewUrls(items: MediaItem[]): Map<string, string> {
+  const urls = useMemo(() => {
+    const created = new Map<string, string>()
+
+    for (const item of items) {
+      if (item.kind === "pending") {
+        created.set(item.localId, URL.createObjectURL(item.file))
+      }
+    }
+
+    return created
+  }, [items])
+
+  useEffect(() => {
+    return () => {
+      for (const url of urls.values()) URL.revokeObjectURL(url)
+    }
+  }, [urls])
+
+  return urls
+}
diff --git a/spa/src/hooks/use-save-entry.ts b/spa/src/hooks/use-save-entry.ts
new file mode 100644
index 0000000..05727c0
--- /dev/null
+++ b/spa/src/hooks/use-save-entry.ts
@@ -0,0 +1,97 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query"
+import { ApiError, entries } from "@/api/client"
+import { toCreateRequest } from "@/lib/entry-draft"
+import type { EntryDraft } from "@/lib/entry-draft"
+import { discardUploads, uploadDraftMedia } from "@/lib/media-upload"
+import { enqueue } from "@/lib/store/outbox"
+import { clearDraft } from "@/lib/store/draft-store"
+import { toast } from "@/components/ui/toast"
+import { invalidateJournal } from "./use-entries"
+import { OUTBOX_KEY } from "./use-outbox"
+import { useOnline } from "./use-online"
+
+export interface SaveOutcome {
+  /** True when the entry is waiting on the device rather than on the server. */
+  queued: boolean
+}
+
+/**
+ * A failure the server never saw. `handleError` only raises an ApiError when a
+ * response came back, so anything else is the connection rather than a refusal
+ * — and a refusal must not be retried behind the reader's back.
+ */
+function neverReachedServer(error: unknown): boolean {
+  return !(error instanceof ApiError)
+}
+
+export function useSaveNewEntry() {
+  const queryClient = useQueryClient()
+  const online = useOnline()
+
+  return useMutation({
+    meta: { silent: true },
+    mutationFn: async (draft: EntryDraft): Promise<SaveOutcome> => {
+      if (!online) {
+        await enqueue(draft)
+        return { queued: true }
+      }
+
+      const receipt = await uploadDraftMedia(draft).catch(async (error) => {
+        if (!neverReachedServer(error)) throw error
+        return null
+      })
+
+      if (receipt === null) {
+        await enqueue(draft)
+        return { queued: true }
+      }
+
+      try {
+        await entries.create(toCreateRequest(draft, receipt))
+        return { queued: false }
+      } catch (error) {
+        await discardUploads(receipt)
+        if (neverReachedServer(error)) {
+          await enqueue(draft)
+          return { queued: true }
+        }
+        throw error
+      }
+    },
+    onSuccess: (outcome) => {
+      clearDraft()
+      queryClient.invalidateQueries({ queryKey: OUTBOX_KEY })
+
+      if (outcome.queued) {
+        toast.add({
+          title: "Saved on this device",
+          description: "It will send itself once you are back online.",
+          type: "info",
+        })
+        return
+      }
+
+      invalidateJournal(queryClient)
+      toast.add({ title: "Entry created", type: "success" })
+    },
+  })
+}
+
+export function useSaveEntryEdit(id: string) {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    meta: { success: "Entry updated" },
+    mutationFn: async (draft: EntryDraft) => {
+      const receipt = await uploadDraftMedia(draft)
+
+      try {
+        return await entries.update(id, toCreateRequest(draft, receipt))
+      } catch (error) {
+        await discardUploads(receipt)
+        throw error
+      }
+    },
+    onSuccess: () => invalidateJournal(queryClient),
+  })
+}
diff --git a/spa/src/hooks/use-server.ts b/spa/src/hooks/use-server.ts
new file mode 100644
index 0000000..ad0f8cc
--- /dev/null
+++ b/spa/src/hooks/use-server.ts
@@ -0,0 +1,12 @@
+import { useQuery } from "@tanstack/react-query"
+import { server } from "@/api/client"
+
+const SERVER = ["server"]
+
+export function useServerInfo() {
+  return useQuery({
+    queryKey: SERVER,
+    queryFn: () => server.info(),
+    staleTime: Infinity,
+  })
+}
diff --git a/spa/src/hooks/use-stats.ts b/spa/src/hooks/use-stats.ts
index 8de2a1f..1ae092b 100644
--- a/spa/src/hooks/use-stats.ts
+++ b/spa/src/hooks/use-stats.ts
@@ -1,70 +1,22 @@
 import { useQuery, keepPreviousData } from "@tanstack/react-query"
 import { entries } from "@/api/client"
-import { format, subDays } from "date-fns"
+import { rangeOfLastDays } from "@/lib/instant-range"
+import type { InstantRange } from "@/lib/instant-range"
+import { PERIOD_DAYS } from "@/lib/period"
+import type { Period } from "@/lib/period"
 
-function dateRange(days: number) {
-  const to = format(new Date(), "yyyy-MM-dd'T'23:59:59+00:00")
-  const from = format(subDays(new Date(), days), "yyyy-MM-dd'T'00:00:00+00:00")
-  return { from, to }
+const STATS_FRESH_FOR = 60_000
+
+export function rangeOfPeriod(period: Period): InstantRange | undefined {
+  const days = PERIOD_DAYS[period]
+  return days === null ? undefined : rangeOfLastDays(days)
 }
 
-export function useMoodStats(
-  period: "week" | "month" | "year" | "all" = "all"
-) {
-  const range =
-    period === "week"
-      ? dateRange(7)
-      : period === "month"
-        ? dateRange(30)
-        : period === "year"
-          ? dateRange(365)
-          : undefined
-
+export function useMoodStats(period: Period = "all") {
   return useQuery({
     queryKey: ["stats", period],
-    queryFn: () => entries.stats(range),
-    staleTime: 60_000,
+    queryFn: () => entries.stats(rangeOfPeriod(period)),
+    staleTime: STATS_FRESH_FOR,
     placeholderData: keepPreviousData,
   })
 }
-
-export type TrendEntry = { loggedAt: string; mood: number }
-
-export function usePeriodEntries(period: "week" | "month" | "year" | "all") {
-  const range =
-    period === "week"
-      ? dateRange(7)
-      : period === "month"
-        ? dateRange(30)
-        : period === "year"
-          ? dateRange(365)
-          : undefined
-
-  const useCalendarEndpoint = period === "year" || period === "all"
-
-  return useQuery<TrendEntry[]>({
-    queryKey: ["entries", "period", period],
-    queryFn: async () => {
-      if (useCalendarEndpoint && range) {
-        const days = await entries.calendar(range)
-        return days.map((day) => ({
-          loggedAt: day.date + "T12:00:00+00:00",
-          mood: day.dayMood ?? 3,
-        }))
-      }
-
-      const list = await entries.list(range)
-      return list.map((e) => ({ loggedAt: e.loggedAt, mood: e.mood }))
-    },
-    staleTime: 60_000,
-    placeholderData: keepPreviousData,
-  })
-}
-
-export function useWeeklyMoods() {
-  return usePeriodEntries("week")
-}
-
-export function useMonthlyMoods() {
-  return usePeriodEntries("month")
-}
diff --git a/spa/src/hooks/use-timezone.ts b/spa/src/hooks/use-timezone.ts
index 08423f2..a56d031 100644
--- a/spa/src/hooks/use-timezone.ts
+++ b/spa/src/hooks/use-timezone.ts
@@ -1,6 +1,7 @@
 import { useEffect } from "react"
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { useMutation, useQueryClient } from "@tanstack/react-query"
 import { users } from "@/api/client"
+import { CURRENT_USER_KEY, useAuth } from "./use-auth"
 
 function platformTimezone(): string | null {
   try {
@@ -10,24 +11,28 @@ function platformTimezone(): string | null {
   }
 }
 
+/**
+ * Adopts the device's timezone the first time an account arrives without one.
+ * Reminders fire against the stored zone, so a missing one is worth filling in
+ * without asking.
+ */
 export function useEnsureTimezone() {
   const queryClient = useQueryClient()
-
-  const profile = useQuery({
-    queryKey: ["me"],
-    queryFn: () => users.me(),
-  })
+  const { user } = useAuth()
 
   const adopt = useMutation({
+    meta: { silent: true },
     mutationFn: (timezone: string) => users.updateProfile({ timezone }),
-    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["me"] }),
+    onSuccess: () =>
+      queryClient.invalidateQueries({ queryKey: CURRENT_USER_KEY }),
   })
 
-  const missing = profile.data !== undefined && profile.data.timezone === null
+  const missing = user !== null && user.timezone === null
   const detected = platformTimezone()
+  const { mutate: adoptTimezone, isPending, isSuccess } = adopt
 
   useEffect(() => {
-    if (!missing || !detected || adopt.isPending || adopt.isSuccess) return
-    adopt.mutate(detected)
-  }, [missing, detected, adopt])
+    if (!missing || !detected || isPending || isSuccess) return
+    adoptTimezone(detected)
+  }, [missing, detected, isPending, isSuccess, adoptTimezone])
 }
diff --git a/spa/src/hooks/use-trend.ts b/spa/src/hooks/use-trend.ts
new file mode 100644
index 0000000..507edbd
--- /dev/null
+++ b/spa/src/hooks/use-trend.ts
@@ -0,0 +1,52 @@
+import { useQuery, keepPreviousData } from "@tanstack/react-query"
+import { entries } from "@/api/client"
+import { rangeOfDays } from "@/lib/instant-range"
+import type { Period } from "@/lib/period"
+import { rangeOfPeriod, useMoodStats } from "./use-stats"
+
+/** One day that was actually logged, and how much was logged that day. */
+export interface TrendPoint {
+  date: string
+  mood: number
+  entryCount: number
+}
+
+const TREND_FRESH_FOR = 60_000
+
+/**
+ * The trend reads the calendar rather than the entry list: the chart plots one
+ * point per day whatever the period, and the calendar already answers in days,
+ * so no period can outgrow a page of entries and be quietly truncated.
+ */
+export function useTrend(period: Period) {
+  const { data: stats } = useMoodStats("all")
+  const wholeHistory =
+    stats?.firstLoggedOn && stats.lastLoggedOn
+      ? rangeOfDays(new Date(stats.firstLoggedOn), new Date(stats.lastLoggedOn))
+      : undefined
+  const range = period === "all" ? wholeHistory : rangeOfPeriod(period)
+
+  return useQuery({
+    queryKey: ["trend", period, range?.from, range?.to],
+    enabled: range !== undefined,
+    queryFn: async (): Promise<TrendPoint[]> => {
+      if (!range) return []
+
+      const days = await entries.calendar(range)
+
+      return days.flatMap((day) =>
+        day.dayMood === null
+          ? []
+          : [
+              {
+                date: day.date,
+                mood: day.dayMood,
+                entryCount: day.entries.length,
+              },
+            ]
+      )
+    },
+    staleTime: TREND_FRESH_FOR,
+    placeholderData: keepPreviousData,
+  })
+}
diff --git a/spa/src/hooks/use-update-entry.ts b/spa/src/hooks/use-update-entry.ts
index 5134671..6decf5d 100644
--- a/spa/src/hooks/use-update-entry.ts
+++ b/spa/src/hooks/use-update-entry.ts
@@ -1,6 +1,7 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query"
 import { entries } from "@/api/client"
 import type { UpdateEntryRequest } from "@/api/schema"
+import { invalidateJournal } from "./use-entries"
 
 export function useUpdateEntry() {
   const queryClient = useQueryClient()
@@ -9,10 +10,6 @@ export function useUpdateEntry() {
     meta: { success: "Entry updated" },
     mutationFn: ({ id, body }: { id: string; body: UpdateEntryRequest }) =>
       entries.update(id, body),
-    onSuccess: (_, { id }) => {
-      queryClient.invalidateQueries({ queryKey: ["entries"] })
-      queryClient.invalidateQueries({ queryKey: ["entries", id] })
-      queryClient.invalidateQueries({ queryKey: ["stats"] })
-    },
+    onSuccess: () => invalidateJournal(queryClient),
   })
 }
diff --git a/spa/src/hooks/use-voice-recorder.ts b/spa/src/hooks/use-voice-recorder.ts
index 1317204..ce88e6f 100644
--- a/spa/src/hooks/use-voice-recorder.ts
+++ b/spa/src/hooks/use-voice-recorder.ts
@@ -56,9 +56,3 @@ export function useVoiceRecorder(onRecorded: (file: File) => void) {
 
   return { recording, duration, start, stop }
 }
-
-export function formatDuration(seconds: number): string {
-  const m = Math.floor(seconds / 60)
-  const s = seconds % 60
-  return `${m}:${s.toString().padStart(2, "0")}`
-}
diff --git a/spa/src/hooks/use-year-calendar.ts b/spa/src/hooks/use-year-calendar.ts
index 8853d19..cd4a364 100644
--- a/spa/src/hooks/use-year-calendar.ts
+++ b/spa/src/hooks/use-year-calendar.ts
@@ -1,16 +1,9 @@
 import { useQuery } from "@tanstack/react-query"
 import { entries } from "@/api/client"
-import { format, startOfYear, endOfYear } from "date-fns"
+import { rangeOfYear } from "@/lib/instant-range"
 
 export function useYearCalendar(year: number) {
-  const from = format(
-    startOfYear(new Date(year, 0, 1)),
-    "yyyy-MM-dd'T'00:00:00+00:00"
-  )
-  const to = format(
-    endOfYear(new Date(year, 0, 1)),
-    "yyyy-MM-dd'T'23:59:59+00:00"
-  )
+  const { from, to } = rangeOfYear(year)
 
   return useQuery({
     queryKey: ["calendar", "year", year],
diff --git a/spa/src/lib/activity-groups.ts b/spa/src/lib/activity-groups.ts
new file mode 100644
index 0000000..592d429
--- /dev/null
+++ b/spa/src/lib/activity-groups.ts
@@ -0,0 +1,60 @@
+import type { ActivityResponse } from "@/api/schema"
+
+/** Where activities with no category of their own are shown. */
+export const UNCATEGORISED = "Other"
+
+export interface ActivityGrouping<T> {
+  category: string
+  items: T[]
+}
+
+function byCategoryName(left: string, right: string): number {
+  if (left === UNCATEGORISED) return 1
+  if (right === UNCATEGORISED) return -1
+  return left.localeCompare(right)
+}
+
+/**
+ * Activities under their categories, uncategorised ones last. Used wherever
+ * activities are listed, so one screen never orders them differently from
+ * another.
+ */
+export function groupByCategory<T extends { category?: string | null }>(
+  activities: T[]
+): ActivityGrouping<T>[] {
+  const groups = new Map<string, T[]>()
+
+  for (const activity of activities) {
+    const category = activity.category ?? UNCATEGORISED
+    const existing = groups.get(category)
+
+    if (existing) {
+      existing.push(activity)
+    } else {
+      groups.set(category, [activity])
+    }
+  }
+
+  return Array.from(groups.entries())
+    .sort(([left], [right]) => byCategoryName(left, right))
+    .map(([category, items]) => ({ category, items }))
+}
+
+/** The named activities behind a set of ids, grouped the same way. */
+export function groupNamesById(
+  activityIds: string[],
+  catalogue: ActivityResponse[]
+): ActivityGrouping<{ id: string; name: string }>[] {
+  const known = new Map(catalogue.map((activity) => [activity.id, activity]))
+
+  const named = activityIds.map((id) => {
+    const activity = known.get(id)
+    return {
+      id,
+      name: activity?.name ?? "Unknown activity",
+      category: activity?.category ?? null,
+    }
+  })
+
+  return groupByCategory(named)
+}
diff --git a/spa/src/lib/api-message.ts b/spa/src/lib/api-message.ts
new file mode 100644
index 0000000..aa3a4a9
--- /dev/null
+++ b/spa/src/lib/api-message.ts
@@ -0,0 +1,19 @@
+import { ApiError } from "@/api/client"
+
+const UNREACHABLE =
+  "Could not reach the server. Check your connection, or the server address."
+
+/**
+ * What to tell the reader about a failed request. A refusal carries the
+ * server's own words; anything else never got there, and saying "invalid
+ * credentials" when the server is down sends people to reset a working
+ * password.
+ */
+export function messageFor(error: unknown): string {
+  if (error instanceof ApiError) return error.message
+  return UNREACHABLE
+}
+
+export function wasRefused(error: unknown): boolean {
+  return error instanceof ApiError
+}
diff --git a/spa/src/lib/button-style.ts b/spa/src/lib/button-style.ts
new file mode 100644
index 0000000..ca6a0b3
--- /dev/null
+++ b/spa/src/lib/button-style.ts
@@ -0,0 +1,15 @@
+import { buttonVariants } from "@/components/ui/button"
+import { cn } from "@/lib/utils"
+import type { VariantProps } from "class-variance-authority"
+
+type ButtonLook = VariantProps<typeof buttonVariants>
+
+/**
+ * Button styling for something that is not a button. Navigation is a link, and
+ * passing a `<Link>` to `Button` renders an anchor where a native button was
+ * declared — this dresses the link instead, so `to` and `params` keep the
+ * router's own type checking.
+ */
+export function buttonLook(look: ButtonLook = {}, className?: string): string {
+  return cn(buttonVariants(look), className)
+}
diff --git a/spa/src/lib/day-label.ts b/spa/src/lib/day-label.ts
new file mode 100644
index 0000000..c5e8328
--- /dev/null
+++ b/spa/src/lib/day-label.ts
@@ -0,0 +1,13 @@
+import { format, isToday, isYesterday } from "date-fns"
+
+const FULL_DAY = "EEEE, MMMM d"
+const FULL_DAY_WITH_YEAR = "EEEE, MMMM d, yyyy"
+
+/** A day named the way a person would name it. */
+export function describeDay(day: Date): string {
+  if (isToday(day)) return "Today"
+  if (isYesterday(day)) return "Yesterday"
+
+  const thisYear = day.getFullYear() === new Date().getFullYear()
+  return format(day, thisYear ? FULL_DAY : FULL_DAY_WITH_YEAR)
+}
diff --git a/spa/src/lib/day.ts b/spa/src/lib/day.ts
new file mode 100644
index 0000000..8138a37
--- /dev/null
+++ b/spa/src/lib/day.ts
@@ -0,0 +1,17 @@
+import { format } from "date-fns"
+
+const DAY = "yyyy-MM-dd"
+
+/** A calendar day as the API keys day-scoped data by. */
+export function formatDate(day: Date): string {
+  return format(day, DAY)
+}
+
+export function today(): string {
+  return formatDate(new Date())
+}
+
+export function parseDate(value: string): Date {
+  const [year, month, day] = value.split("-").map(Number)
+  return new Date(year, month - 1, day)
+}
diff --git a/spa/src/lib/duration.ts b/spa/src/lib/duration.ts
new file mode 100644
index 0000000..a4ea9b4
--- /dev/null
+++ b/spa/src/lib/duration.ts
@@ -0,0 +1,11 @@
+const SECONDS_PER_MINUTE = 60
+
+/** Whole seconds as `m:ss`. */
+export function formatDuration(seconds: number): string {
+  if (!Number.isFinite(seconds) || seconds < 0) return "0:00"
+
+  const minutes = Math.floor(seconds / SECONDS_PER_MINUTE)
+  const remainder = Math.floor(seconds % SECONDS_PER_MINUTE)
+
+  return `${minutes}:${remainder.toString().padStart(2, "0")}`
+}
diff --git a/spa/src/lib/entry-draft.ts b/spa/src/lib/entry-draft.ts
new file mode 100644
index 0000000..642ae2a
--- /dev/null
+++ b/spa/src/lib/entry-draft.ts
@@ -0,0 +1,146 @@
+import {
+  activitiesOf,
+  contentOf,
+  locationOf,
+  photosOf,
+  songOf,
+  voiceMemosOf,
+} from "./dimensions"
+import { existingItem, pendingFiles } from "./media"
+import type { MediaItem } from "./media"
+import { toLoggedAt } from "./logged-at"
+import type { MoodValue } from "./mood"
+import type {
+  CreateEntryRequest,
+  DimensionPayload,
+  EntryResponse,
+} from "@/api/schema"
+
+export interface Coordinates {
+  latitude: number
+  longitude: number
+}
+
+export interface SongNote {
+  title: string
+  artist: string
+}
+
+/** Everything the entry form holds, before any of it reaches the server. */
+export interface EntryDraft {
+  mood: MoodValue | null
+  loggedAt: string
+  content: string
+  activityIds: string[]
+  photos: MediaItem[]
+  voiceMemos: MediaItem[]
+  song: SongNote
+  location: Coordinates | null
+}
+
+const NO_SONG: SongNote = { title: "", artist: "" }
+
+export function emptyDraft(): EntryDraft {
+  return {
+    mood: null,
+    loggedAt: toLoggedAt(new Date()),
+    content: "",
+    activityIds: [],
+    photos: [],
+    voiceMemos: [],
+    song: NO_SONG,
+    location: null,
+  }
+}
+
+export function draftOf(entry: EntryResponse): EntryDraft {
+  return {
+    mood: entry.mood as MoodValue,
+    loggedAt: entry.loggedAt,
+    content: contentOf(entry) ?? "",
+    activityIds: activitiesOf(entry),
+    photos: photosOf(entry).map(existingItem),
+    voiceMemos: voiceMemosOf(entry).map(existingItem),
+    song: songOf(entry) ?? NO_SONG,
+    location: locationOf(entry),
+  }
+}
+
+/**
+ * Whether anything behind the "add more" disclosure has been filled in.
+ * Activities are deliberately not counted: they sit in the always-visible part
+ * of the form, and tagging one should not make the extras spring open.
+ */
+export function hasExtras(draft: EntryDraft): boolean {
+  return (
+    draft.content.trim() !== "" ||
+    draft.photos.length > 0 ||
+    draft.voiceMemos.length > 0 ||
+    draft.location !== null ||
+    draft.song.title.trim() !== "" ||
+    draft.song.artist.trim() !== ""
+  )
+}
+
+/** Whether losing this draft would lose anything the reader entered. */
+export function isWorthKeeping(draft: EntryDraft): boolean {
+  return draft.mood !== null || draft.activityIds.length > 0 || hasExtras(draft)
+}
+
+export function countsPendingUploads(draft: EntryDraft): number {
+  return (
+    pendingFiles(draft.photos).length + pendingFiles(draft.voiceMemos).length
+  )
+}
+
+export interface UploadedMedia {
+  photoIds: string[]
+  voiceMemoIds: string[]
+}
+
+function dimensionsOf(
+  draft: EntryDraft,
+  uploaded: UploadedMedia
+): DimensionPayload[] {
+  const dimensions: DimensionPayload[] = []
+  const text = draft.content.trim()
+
+  if (text) dimensions.push({ kind: "content", text })
+
+  if (draft.activityIds.length) {
+    dimensions.push({ kind: "activities", ids: draft.activityIds })
+  }
+
+  if (uploaded.photoIds.length) {
+    dimensions.push({ kind: "photos", ids: uploaded.photoIds })
+  }
+
+  if (uploaded.voiceMemoIds.length) {
+    dimensions.push({ kind: "voiceMemos", ids: uploaded.voiceMemoIds })
+  }
+
+  if (draft.location) {
+    dimensions.push({ kind: "location", ...draft.location })
+  }
+
+  const title = draft.song.title.trim()
+  const artist = draft.song.artist.trim()
+  if (title && artist) dimensions.push({ kind: "song", title, artist })
+
+  return dimensions
+}
+
+export function toCreateRequest(
+  draft: EntryDraft,
+  uploaded: UploadedMedia
+): CreateEntryRequest {
+  if (draft.mood === null) {
+    throw new Error("An entry cannot be written without a mood")
+  }
+
+  return {
+    mood: draft.mood,
+    loggedAt: draft.loggedAt,
+    dimensions: dimensionsOf(draft, uploaded),
+  }
+}
diff --git a/spa/src/lib/entry-preview.ts b/spa/src/lib/entry-preview.ts
new file mode 100644
index 0000000..df52b9d
--- /dev/null
+++ b/spa/src/lib/entry-preview.ts
@@ -0,0 +1,10 @@
+const MOST_CHARACTERS = 160
+
+/** A note trimmed to something that fits on a card. */
+export function contentPreview(content: string): string {
+  const trimmed = content.trim()
+
+  return trimmed.length > MOST_CHARACTERS
+    ? `${trimmed.slice(0, MOST_CHARACTERS)}…`
+    : trimmed
+}
diff --git a/spa/src/lib/instant-range.ts b/spa/src/lib/instant-range.ts
new file mode 100644
index 0000000..82ef243
--- /dev/null
+++ b/spa/src/lib/instant-range.ts
@@ -0,0 +1,38 @@
+import {
+  endOfDay,
+  endOfMonth,
+  endOfYear,
+  startOfDay,
+  startOfMonth,
+  startOfYear,
+  subDays,
+} from "date-fns"
+import { toLoggedAt } from "./logged-at"
+
+/**
+ * A span of instants the API reads by. Day boundaries are the reader's own —
+ * "this month" ends when the month ends where you are, not in UTC — so the
+ * offset has to travel with the instant rather than being assumed.
+ */
+export interface InstantRange {
+  from: string
+  to: string
+}
+
+export function rangeOfDays(from: Date, to: Date): InstantRange {
+  return { from: toLoggedAt(startOfDay(from)), to: toLoggedAt(endOfDay(to)) }
+}
+
+export function rangeOfMonth(month: Date): InstantRange {
+  return rangeOfDays(startOfMonth(month), endOfMonth(month))
+}
+
+export function rangeOfYear(year: number): InstantRange {
+  const anyDayThatYear = new Date(year, 0, 1)
+  return rangeOfDays(startOfYear(anyDayThatYear), endOfYear(anyDayThatYear))
+}
+
+export function rangeOfLastDays(days: number): InstantRange {
+  const today = new Date()
+  return rangeOfDays(subDays(today, days), today)
+}
diff --git a/spa/src/lib/media-upload.ts b/spa/src/lib/media-upload.ts
new file mode 100644
index 0000000..f1b2072
--- /dev/null
+++ b/spa/src/lib/media-upload.ts
@@ -0,0 +1,54 @@
+import { media } from "@/api/client"
+import { existingIds, pendingFiles } from "./media"
+import type { EntryDraft, UploadedMedia } from "./entry-draft"
+
+/** What an upload put on the server, and which of it this upload created. */
+export interface UploadReceipt extends UploadedMedia {
+  created: { photos: string[]; voiceMemos: string[] }
+}
+
+export const NOTHING_UPLOADED: UploadReceipt = {
+  photoIds: [],
+  voiceMemoIds: [],
+  created: { photos: [], voiceMemos: [] },
+}
+
+/**
+ * Media has to reach the server before the entry that references it, which
+ * leaves a window where the upload has landed and the entry has not. Anything
+ * this call created is handed back so the caller can take it away again if the
+ * entry never arrives.
+ */
+export async function uploadDraftMedia(
+  draft: EntryDraft
+): Promise<UploadReceipt> {
+  const photos: string[] = []
+  const voiceMemos: string[] = []
+
+  try {
+    for (const file of pendingFiles(draft.photos)) {
+      photos.push((await media.uploadPhoto(file)).id)
+    }
+    for (const file of pendingFiles(draft.voiceMemos)) {
+      voiceMemos.push((await media.uploadVoiceMemo(file)).id)
+    }
+  } catch (error) {
+    await discardUploads({ created: { photos, voiceMemos } })
+    throw error
+  }
+
+  return {
+    photoIds: [...existingIds(draft.photos), ...photos],
+    voiceMemoIds: [...existingIds(draft.voiceMemos), ...voiceMemos],
+    created: { photos, voiceMemos },
+  }
+}
+
+export async function discardUploads(
+  receipt: Pick<UploadReceipt, "created">
+): Promise<void> {
+  await Promise.allSettled([
+    ...receipt.created.photos.map((id) => media.deletePhoto(id)),
+    ...receipt.created.voiceMemos.map((id) => media.deleteVoiceMemo(id)),
+  ])
+}
diff --git a/spa/src/lib/media.ts b/spa/src/lib/media.ts
index e9d8853..616b318 100644
--- a/spa/src/lib/media.ts
+++ b/spa/src/lib/media.ts
@@ -1,27 +1,27 @@
+/**
+ * A photo or voice memo attached to an entry: either one the server already
+ * holds, or one picked on this device and not yet uploaded.
+ */
 export type MediaItem =
-  | { type: "existing"; id: string }
-  | { type: "pending"; file: File; preview: string }
+  | { kind: "existing"; id: string }
+  | { kind: "pending"; localId: string; file: File }
 
-export function createPendingItem(file: File): MediaItem {
-  return {
-    type: "pending",
-    file,
-    preview: URL.createObjectURL(file),
-  }
+export function newPendingItem(file: File): MediaItem {
+  return { kind: "pending", localId: crypto.randomUUID(), file }
 }
 
-export function getExistingIds(items: MediaItem[]): string[] {
-  return items.filter((i) => i.type === "existing").map((i) => i.id)
+export function existingItem(id: string): MediaItem {
+  return { kind: "existing", id }
 }
 
-export function getPendingFiles(items: MediaItem[]): File[] {
-  return items.filter((i) => i.type === "pending").map((i) => i.file)
+export function existingIds(items: MediaItem[]): string[] {
+  return items.flatMap((item) => (item.kind === "existing" ? [item.id] : []))
 }
 
-export function cleanupPreviews(items: MediaItem[]) {
-  for (const item of items) {
-    if (item.type === "pending") {
-      URL.revokeObjectURL(item.preview)
-    }
-  }
+export function pendingFiles(items: MediaItem[]): File[] {
+  return items.flatMap((item) => (item.kind === "pending" ? [item.file] : []))
+}
+
+export function keyOf(item: MediaItem): string {
+  return item.kind === "existing" ? item.id : item.localId
 }
diff --git a/spa/src/lib/mood.ts b/spa/src/lib/mood.ts
index aca5e9d..af91723 100644
--- a/spa/src/lib/mood.ts
+++ b/spa/src/lib/mood.ts
@@ -1,15 +1,59 @@
+/**
+ * The five moods, in order. One place for every way a mood is shown: `color`
+ * for text, `background` for a filled cell, `swatch` for canvases and charts
+ * that cannot take a class. They were four separate maps that had drifted.
+ */
 export const MOODS = [
-  { value: 1, label: "Awful", emoji: "😢", color: "text-red-500" },
-  { value: 2, label: "Bad", emoji: "😔", color: "text-orange-500" },
-  { value: 3, label: "Meh", emoji: "😐", color: "text-yellow-500" },
-  { value: 4, label: "Good", emoji: "😊", color: "text-lime-500" },
-  { value: 5, label: "Rad", emoji: "😄", color: "text-green-500" },
+  {
+    value: 1,
+    label: "Awful",
+    emoji: "😢",
+    color: "text-red-500",
+    background: "bg-red-500",
+    swatch: "oklch(0.637 0.237 25.331)",
+  },
+  {
+    value: 2,
+    label: "Bad",
+    emoji: "😔",
+    color: "text-orange-500",
+    background: "bg-orange-500",
+    swatch: "oklch(0.705 0.213 47.604)",
+  },
+  {
+    value: 3,
+    label: "Meh",
+    emoji: "😐",
+    color: "text-yellow-500",
+    background: "bg-yellow-500",
+    swatch: "oklch(0.795 0.184 86.047)",
+  },
+  {
+    value: 4,
+    label: "Good",
+    emoji: "😊",
+    color: "text-lime-500",
+    background: "bg-lime-500",
+    swatch: "oklch(0.768 0.233 130.85)",
+  },
+  {
+    value: 5,
+    label: "Rad",
+    emoji: "😄",
+    color: "text-green-500",
+    background: "bg-green-500",
+    swatch: "oklch(0.723 0.219 149.579)",
+  },
 ] as const
 
 export type MoodValue = (typeof MOODS)[number]["value"]
 
+export const WORST_MOOD = MOODS[0]
+export const MIDDLE_MOOD = MOODS[2]
+export const BEST_MOOD = MOODS[MOODS.length - 1]
+
 export function getMood(value: number) {
-  return MOODS.find((m) => m.value === value) ?? MOODS[2]
+  return MOODS.find((mood) => mood.value === value) ?? MIDDLE_MOOD
 }
 
 export function getMoodColor(value: number): string {
@@ -19,3 +63,21 @@ export function getMoodColor(value: number): string {
 export function getMoodEmoji(value: number): string {
   return getMood(value).emoji
 }
+
+export function getMoodLabel(value: number): string {
+  return getMood(value).label
+}
+
+/**
+ * How a mood reads to a screen reader. Emoji and colour carry the mood
+ * everywhere in the UI; this is the same information in words.
+ */
+export function describeMood(value: number): string {
+  return `Mood: ${getMoodLabel(value)}`
+}
+
+/** Rounds an average onto the scale, for a label that has to name one mood. */
+export function nearestMood(average: number) {
+  const clamped = Math.min(BEST_MOOD.value, Math.max(WORST_MOOD.value, average))
+  return getMood(Math.round(clamped))
+}
diff --git a/spa/src/lib/outbox-sync.ts b/spa/src/lib/outbox-sync.ts
new file mode 100644
index 0000000..df2a1ba
--- /dev/null
+++ b/spa/src/lib/outbox-sync.ts
@@ -0,0 +1,77 @@
+import { ApiError, entries } from "@/api/client"
+import { toCreateRequest } from "./entry-draft"
+import { discardUploads, uploadDraftMedia } from "./media-upload"
+import { dequeue, noteAttempt, queuedEntries } from "./store/outbox"
+import type { QueuedEntry } from "./store/outbox"
+
+/**
+ * How many times a *refused* entry is retried before it is left alone. Only
+ * refusals count: the server has looked at the entry and said no, and asking
+ * again will get the same answer. A failure that never reached the server is
+ * not the entry's fault and is retried for as long as it takes.
+ */
+export const MAX_AUTOMATIC_ATTEMPTS = 5
+
+export interface FlushOutcome {
+  sent: number
+  failed: number
+}
+
+export function isStuck(queued: QueuedEntry): boolean {
+  return queued.attempts >= MAX_AUTOMATIC_ATTEMPTS
+}
+
+function describe(error: unknown): string {
+  if (error instanceof ApiError) return error.message
+  return "No connection to the server"
+}
+
+/** Whether the server saw the request and turned it down. */
+function wasRefused(error: unknown): boolean {
+  return error instanceof ApiError
+}
+
+async function send(queued: QueuedEntry): Promise<void> {
+  const receipt = await uploadDraftMedia(queued.draft)
+
+  try {
+    await entries.create(toCreateRequest(queued.draft, receipt))
+  } catch (error) {
+    await discardUploads(receipt)
+    throw error
+  }
+
+  await dequeue(queued.id)
+}
+
+/**
+ * Sends what is waiting, oldest first, one at a time. Order is kept because a
+ * journal read back out of order would be a different journal.
+ */
+export async function flushOutbox(): Promise<FlushOutcome> {
+  const outcome: FlushOutcome = { sent: 0, failed: 0 }
+
+  for (const queued of await queuedEntries()) {
+    if (isStuck(queued)) continue
+
+    try {
+      await send(queued)
+      outcome.sent += 1
+    } catch (error) {
+      await noteAttempt(queued.id, describe(error), wasRefused(error))
+      outcome.failed += 1
+    }
+  }
+
+  return outcome
+}
+
+/** Retries one entry the automatic pass has given up on. */
+export async function retryQueued(queued: QueuedEntry): Promise<void> {
+  try {
+    await send(queued)
+  } catch (error) {
+    await noteAttempt(queued.id, describe(error), wasRefused(error))
+    throw error
+  }
+}
diff --git a/spa/src/lib/period.ts b/spa/src/lib/period.ts
new file mode 100644
index 0000000..486d197
--- /dev/null
+++ b/spa/src/lib/period.ts
@@ -0,0 +1,18 @@
+export const PERIODS = ["week", "month", "year", "all"] as const
+
+export type Period = (typeof PERIODS)[number]
+
+export const PERIOD_LABELS: Record<Period, string> = {
+  week: "Week",
+  month: "Month",
+  year: "Year",
+  all: "All",
+}
+
+/** How many days back a period reaches, or null when it reaches all the way. */
+export const PERIOD_DAYS: Record<Period, number | null> = {
+  week: 7,
+  month: 30,
+  year: 365,
+  all: null,
+}
diff --git a/spa/src/lib/service-worker.ts b/spa/src/lib/service-worker.ts
new file mode 100644
index 0000000..826502b
--- /dev/null
+++ b/spa/src/lib/service-worker.ts
@@ -0,0 +1,99 @@
+/**
+ * Registration, and noticing when a new build is waiting to take over. The
+ * worker never activates itself, so this is the only path to an update.
+ */
+
+const SKIP_WAITING = "SKIP_WAITING"
+
+export type UpdateReady = (applyUpdate: () => void) => void
+
+function whenWaiting(
+  registration: ServiceWorkerRegistration,
+  onReady: UpdateReady
+): void {
+  const waiting = registration.waiting
+  if (!waiting) return
+
+  onReady(() => {
+    waiting.postMessage({ type: SKIP_WAITING })
+  })
+}
+
+export function registerServiceWorker(onUpdateReady: UpdateReady): void {
+  if (!("serviceWorker" in navigator)) return
+
+  // Never in development. The worker serves same-origin assets cache-first,
+  // which hands the dev server's own modules back stale and breaks hot
+  // reloading in ways that look like impossible application bugs.
+  if (import.meta.env.DEV) return
+
+  navigator.serviceWorker.register("/sw.js").then(
+    (registration) => {
+      // A build that finished installing before this page loaded.
+      whenWaiting(registration, onUpdateReady)
+
+      registration.addEventListener("updatefound", () => {
+        const installing = registration.installing
+        if (!installing) return
+
+        installing.addEventListener("statechange", () => {
+          // Only an update: with no controller this is the very first install.
+          if (
+            installing.state === "installed" &&
+            navigator.serviceWorker.controller
+          ) {
+            whenWaiting(registration, onUpdateReady)
+          }
+        })
+      })
+    },
+    () => {
+      // A refused registration leaves the app working, just without offline assets.
+    }
+  )
+
+  let reloading = false
+  navigator.serviceWorker.addEventListener("controllerchange", () => {
+    if (reloading) return
+    reloading = true
+    window.location.reload()
+  })
+}
+
+const RELOADED_FOR = "reloadedForMissingChunk"
+
+/**
+ * A deploy replaces every hashed chunk. A tab that was open across it still
+ * holds the old index, so the first lazy route it opens asks for a file that
+ * is no longer there and the screen dead-ends. One reload picks up the new
+ * index; the marker makes sure a genuinely missing chunk cannot loop.
+ */
+export function isMissingChunk(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error)
+
+  return (
+    message.includes("Failed to fetch dynamically imported module") ||
+    message.includes("error loading dynamically imported module") ||
+    message.includes("Importing a module script failed")
+  )
+}
+
+export function reloadForMissingChunk(): boolean {
+  try {
+    if (sessionStorage.getItem(RELOADED_FOR)) return false
+    sessionStorage.setItem(RELOADED_FOR, "1")
+  } catch {
+    return false
+  }
+
+  window.location.reload()
+  return true
+}
+
+export function forgetMissingChunkReload(): void {
+  try {
+    sessionStorage.removeItem(RELOADED_FOR)
+  } catch {
+    // Nothing to forget.
+  }
+}
diff --git a/spa/src/lib/store/draft-store.ts b/spa/src/lib/store/draft-store.ts
new file mode 100644
index 0000000..4611201
--- /dev/null
+++ b/spa/src/lib/store/draft-store.ts
@@ -0,0 +1,38 @@
+import { DRAFTS, get, isAvailable, put, remove } from "./idb"
+import type { EntryDraft } from "../entry-draft"
+
+/**
+ * Only the unsent new entry is kept. An edit in progress belongs to the entry
+ * it is editing, and resurrecting one days later would be a surprise.
+ */
+const NEW_ENTRY = "new-entry"
+
+export async function saveDraft(draft: EntryDraft): Promise<void> {
+  if (!isAvailable()) return
+
+  try {
+    await put(DRAFTS, NEW_ENTRY, draft)
+  } catch {
+    // A draft that cannot be stored is not worth failing the form over.
+  }
+}
+
+export async function loadDraft(): Promise<EntryDraft | undefined> {
+  if (!isAvailable()) return undefined
+
+  try {
+    return await get<EntryDraft>(DRAFTS, NEW_ENTRY)
+  } catch {
+    return undefined
+  }
+}
+
+export async function clearDraft(): Promise<void> {
+  if (!isAvailable()) return
+
+  try {
+    await remove(DRAFTS, NEW_ENTRY)
+  } catch {
+    // Nothing to clear.
+  }
+}
diff --git a/spa/src/lib/store/idb.ts b/spa/src/lib/store/idb.ts
new file mode 100644
index 0000000..d31e924
--- /dev/null
+++ b/spa/src/lib/store/idb.ts
@@ -0,0 +1,83 @@
+/**
+ * A small key-value store over IndexedDB. Drafts and queued entries carry
+ * photos and recordings, which localStorage cannot hold.
+ */
+
+const DB_NAME = "k-mood"
+const DB_VERSION = 1
+
+export const DRAFTS = "drafts"
+export const OUTBOX = "outbox"
+
+const STORES = [DRAFTS, OUTBOX] as const
+
+export type StoreName = (typeof STORES)[number]
+
+let connection: Promise<IDBDatabase> | null = null
+
+function open(): Promise<IDBDatabase> {
+  if (connection) return connection
+
+  connection = new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION)
+
+    request.onupgradeneeded = () => {
+      for (const store of STORES) {
+        if (!request.result.objectStoreNames.contains(store)) {
+          request.result.createObjectStore(store)
+        }
+      }
+    }
+
+    request.onsuccess = () => resolve(request.result)
+    request.onerror = () => reject(request.error)
+  })
+
+  connection = connection.catch((error) => {
+    connection = null
+    throw error
+  })
+
+  return connection
+}
+
+function run<T>(
+  store: StoreName,
+  mode: IDBTransactionMode,
+  work: (store: IDBObjectStore) => IDBRequest<T>
+): Promise<T> {
+  return open().then(
+    (db) =>
+      new Promise<T>((resolve, reject) => {
+        const transaction = db.transaction(store, mode)
+        const request = work(transaction.objectStore(store))
+
+        request.onsuccess = () => resolve(request.result)
+        request.onerror = () => reject(request.error)
+      })
+  )
+}
+
+export function put<T>(store: StoreName, key: string, value: T): Promise<void> {
+  return run(store, "readwrite", (objects) => objects.put(value, key)).then(
+    () => undefined
+  )
+}
+
+export function get<T>(store: StoreName, key: string): Promise<T | undefined> {
+  return run<T | undefined>(store, "readonly", (objects) => objects.get(key))
+}
+
+export function remove(store: StoreName, key: string): Promise<void> {
+  return run(store, "readwrite", (objects) => objects.delete(key)).then(
+    () => undefined
+  )
+}
+
+export function all<T>(store: StoreName): Promise<T[]> {
+  return run<T[]>(store, "readonly", (objects) => objects.getAll())
+}
+
+export function isAvailable(): boolean {
+  return typeof indexedDB !== "undefined"
+}
diff --git a/spa/src/lib/store/outbox.ts b/spa/src/lib/store/outbox.ts
new file mode 100644
index 0000000..ff5a5cf
--- /dev/null
+++ b/spa/src/lib/store/outbox.ts
@@ -0,0 +1,64 @@
+import { OUTBOX, all, get, isAvailable, put, remove } from "./idb"
+import type { EntryDraft } from "../entry-draft"
+
+/** An entry written on this device that the server has not accepted yet. */
+export interface QueuedEntry {
+  id: string
+  draft: EntryDraft
+  queuedAt: string
+  attempts: number
+  lastError?: string
+}
+
+export function isSupported(): boolean {
+  return isAvailable()
+}
+
+export async function enqueue(draft: EntryDraft): Promise<QueuedEntry> {
+  const queued: QueuedEntry = {
+    id: crypto.randomUUID(),
+    draft,
+    queuedAt: new Date().toISOString(),
+    attempts: 0,
+  }
+
+  await put(OUTBOX, queued.id, queued)
+  return queued
+}
+
+export async function queuedEntries(): Promise<QueuedEntry[]> {
+  if (!isAvailable()) return []
+
+  try {
+    const entries = await all<QueuedEntry>(OUTBOX)
+    return entries.sort((left, right) =>
+      left.queuedAt.localeCompare(right.queuedAt)
+    )
+  } catch {
+    return []
+  }
+}
+
+export async function dequeue(id: string): Promise<void> {
+  await remove(OUTBOX, id)
+}
+
+/**
+ * Records what went wrong. `countsAgainstIt` is false when the request never
+ * reached the server: a connection that is down says nothing about whether
+ * this entry is acceptable, so it must not use up the entry's attempts.
+ */
+export async function noteAttempt(
+  id: string,
+  error: string,
+  countsAgainstIt: boolean
+): Promise<void> {
+  const queued = await get<QueuedEntry>(OUTBOX, id)
+  if (!queued) return
+
+  await put(OUTBOX, id, {
+    ...queued,
+    attempts: countsAgainstIt ? queued.attempts + 1 : queued.attempts,
+    lastError: error,
+  })
+}
diff --git a/spa/src/lib/trend-buckets.ts b/spa/src/lib/trend-buckets.ts
new file mode 100644
index 0000000..52a679a
--- /dev/null
+++ b/spa/src/lib/trend-buckets.ts
@@ -0,0 +1,89 @@
+import { format, startOfMonth, startOfWeek } from "date-fns"
+import type { TrendPoint } from "@/hooks/use-trend"
+import type { Period } from "./period"
+import { weekStartsOn } from "./week"
+
+export type TrendBucket = "day" | "week" | "month"
+
+/** One plotted column: the days it covers, averaged. */
+export interface TrendBar {
+  label: string
+  tooltip: string
+  average: number
+  entryCount: number
+}
+
+const DAYS_BEFORE_MONTHLY_BUCKETS = 365
+
+export function bucketFor(period: Period, dayCount: number): TrendBucket {
+  if (period === "week" || period === "month") return "day"
+  return dayCount > DAYS_BEFORE_MONTHLY_BUCKETS ? "month" : "week"
+}
+
+interface BucketLabels {
+  key: string
+  label: string
+  tooltip: string
+}
+
+function labelsFor(day: Date, bucket: TrendBucket): BucketLabels {
+  switch (bucket) {
+    case "month":
+      return {
+        key: format(startOfMonth(day), "yyyy-MM"),
+        label: format(day, "MMM yyyy"),
+        tooltip: format(day, "MMMM yyyy"),
+      }
+    case "week": {
+      const weekStart = startOfWeek(day, { weekStartsOn: weekStartsOn() })
+      return {
+        key: format(weekStart, "yyyy-MM-dd"),
+        label: format(weekStart, "MMM d"),
+        tooltip: `Week of ${format(weekStart, "MMM d, yyyy")}`,
+      }
+    }
+    case "day":
+      return {
+        key: format(day, "yyyy-MM-dd"),
+        label: format(day, "MMM d"),
+        tooltip: format(day, "EEE, MMM d"),
+      }
+  }
+}
+
+interface Accumulator extends BucketLabels {
+  moodTotal: number
+  dayCount: number
+  entryCount: number
+}
+
+export function aggregateTrend(
+  points: TrendPoint[],
+  bucket: TrendBucket
+): TrendBar[] {
+  const buckets = new Map<string, Accumulator>()
+
+  for (const point of points) {
+    const labels = labelsFor(new Date(point.date), bucket)
+    const running = buckets.get(labels.key) ?? {
+      ...labels,
+      moodTotal: 0,
+      dayCount: 0,
+      entryCount: 0,
+    }
+
+    running.moodTotal += point.mood
+    running.dayCount += 1
+    running.entryCount += point.entryCount
+    buckets.set(labels.key, running)
+  }
+
+  return Array.from(buckets.values())
+    .sort((left, right) => left.key.localeCompare(right.key))
+    .map(({ label, tooltip, moodTotal, dayCount, entryCount }) => ({
+      label,
+      tooltip,
+      average: moodTotal / dayCount,
+      entryCount,
+    }))
+}
diff --git a/spa/src/lib/week.ts b/spa/src/lib/week.ts
new file mode 100644
index 0000000..d03b4c8
--- /dev/null
+++ b/spa/src/lib/week.ts
@@ -0,0 +1,44 @@
+const MONDAY = 1
+
+type WeekStart = 0 | 1 | 2 | 3 | 4 | 5 | 6
+
+interface WeekInfo {
+  firstDay: number
+}
+
+interface LocaleWithWeekInfo extends Intl.Locale {
+  getWeekInfo?: () => WeekInfo
+  weekInfo?: WeekInfo
+}
+
+/**
+ * The day the reader's week starts on, as `Date.getDay` numbers it (Sunday 0).
+ * The calendar used to be hardcoded to Sunday, which is wrong for most of the
+ * world. Falls back to Monday rather than Sunday when the platform will not say.
+ */
+export function weekStartsOn(): WeekStart {
+  try {
+    const locale = new Intl.Locale(navigator.language) as LocaleWithWeekInfo
+    const info = locale.getWeekInfo?.() ?? locale.weekInfo
+
+    // Intl counts Monday as 1 through Sunday as 7; Date counts Sunday as 0.
+    if (info) return (info.firstDay % 7) as WeekStart
+  } catch {
+    // Older engines do not expose week info.
+  }
+
+  return MONDAY
+}
+
+/** Weekday initials, rotated to start on the reader's first day. */
+export function weekdayInitials(): string[] {
+  const sundayFirst = ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]
+  const start = weekStartsOn()
+
+  return sundayFirst.map((_, index) => sundayFirst[(index + start) % 7])
+}
+
+/** Which row of a week-based grid a day belongs in. */
+export function rowOfWeek(dayOfWeek: number): number {
+  return (dayOfWeek - weekStartsOn() + 7) % 7
+}
diff --git a/spa/src/main.tsx b/spa/src/main.tsx
index 6448d74..68fa20b 100644
--- a/spa/src/main.tsx
+++ b/spa/src/main.tsx
@@ -8,6 +8,7 @@ import {
 import { getRouter } from "./router"
 import { toast, Toaster } from "@/components/ui/toast"
 import { ApiError } from "@/api/client"
+import { registerServiceWorker } from "@/lib/service-worker"
 import "./styles.css"
 
 const queryClient = new QueryClient({
@@ -37,6 +38,12 @@ ReactDOM.createRoot(document.getElementById("root")!).render(
   </QueryClientProvider>
 )
 
-if ("serviceWorker" in navigator) {
-  navigator.serviceWorker.register("/sw.js")
-}
+registerServiceWorker((applyUpdate) => {
+  toast.add({
+    title: "A new version is ready",
+    description: "Reload to pick it up.",
+    type: "info",
+    timeout: 0,
+    actionProps: { children: "Reload", onClick: applyUpdate },
+  })
+})
diff --git a/spa/src/routeTree.gen.ts b/spa/src/routeTree.gen.ts
index 61ce1f8..3e7df6f 100644
--- a/spa/src/routeTree.gen.ts
+++ b/spa/src/routeTree.gen.ts
@@ -49,47 +49,55 @@ const AuthActivitiesRoute = AuthActivitiesRouteImport.update({
   id: '/activities',
   path: '/activities',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() =>
+  import('./routes/_auth/activities.lazy').then((d) => d.Route),
+)
 const AuthAddRoute = AuthAddRouteImport.update({
   id: '/add',
   path: '/add',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() => import('./routes/_auth/add.lazy').then((d) => d.Route))
 const AuthCalendarRoute = AuthCalendarRouteImport.update({
   id: '/calendar',
   path: '/calendar',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() =>
+  import('./routes/_auth/calendar.lazy').then((d) => d.Route),
+)
 const AuthDiaryRoute = AuthDiaryRouteImport.update({
   id: '/diary',
   path: '/diary',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() => import('./routes/_auth/diary.lazy').then((d) => d.Route))
 const AuthExportRoute = AuthExportRouteImport.update({
   id: '/export',
   path: '/export',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() => import('./routes/_auth/export.lazy').then((d) => d.Route))
 const AuthImportRoute = AuthImportRouteImport.update({
   id: '/import',
   path: '/import',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() => import('./routes/_auth/import.lazy').then((d) => d.Route))
 const AuthMetricsRoute = AuthMetricsRouteImport.update({
   id: '/metrics',
   path: '/metrics',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() => import('./routes/_auth/metrics.lazy').then((d) => d.Route))
 const AuthRemindersRoute = AuthRemindersRouteImport.update({
   id: '/reminders',
   path: '/reminders',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() =>
+  import('./routes/_auth/reminders.lazy').then((d) => d.Route),
+)
 const AuthSettingsRoute = AuthSettingsRouteImport.update({
   id: '/settings',
   path: '/settings',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() =>
+  import('./routes/_auth/settings.lazy').then((d) => d.Route),
+)
 const AuthStatsRoute = AuthStatsRouteImport.update({
   id: '/stats',
   path: '/stats',
@@ -99,12 +107,16 @@ const AuthEditIdRoute = AuthEditIdRouteImport.update({
   id: '/edit/$id',
   path: '/edit/$id',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() =>
+  import('./routes/_auth/edit.$id.lazy').then((d) => d.Route),
+)
 const AuthEntryIdRoute = AuthEntryIdRouteImport.update({
   id: '/entry/$id',
   path: '/entry/$id',
   getParentRoute: () => AuthRoute,
-} as any)
+} as any).lazy(() =>
+  import('./routes/_auth/entry.$id.lazy').then((d) => d.Route),
+)
 
 export interface FileRoutesByFullPath {
   '/': typeof AuthIndexRoute
diff --git a/spa/src/router.tsx b/spa/src/router.tsx
index 0e06572..77df762 100644
--- a/spa/src/router.tsx
+++ b/spa/src/router.tsx
@@ -1,11 +1,14 @@
 import { createRouter } from "@tanstack/react-router"
 import { routeTree } from "./routeTree.gen"
+import { RouteError } from "@/components/layout/route-error"
 
 export function getRouter() {
   return createRouter({
     routeTree,
     scrollRestoration: true,
     defaultPreload: "intent",
+    // Without this a single failing screen unmounts the whole application.
+    defaultErrorComponent: RouteError,
   })
 }
 
diff --git a/spa/src/routes/__root.tsx b/spa/src/routes/__root.tsx
index 1e13525..8903890 100644
--- a/spa/src/routes/__root.tsx
+++ b/spa/src/routes/__root.tsx
@@ -1,25 +1,43 @@
-import { Outlet, createRootRoute } from "@tanstack/react-router"
-import { TanStackRouterDevtools } from "@tanstack/react-router-devtools"
-import { ReactQueryDevtools } from "@tanstack/react-query-devtools"
+import { lazy, Suspense } from "react"
+import { Link, Outlet, createRootRoute } from "@tanstack/react-router"
+import { buttonLook } from "@/lib/button-style"
+
+/**
+ * Devtools are development-only and lazily imported, so neither package is
+ * reachable from the production entry chunk.
+ */
+const Devtools = import.meta.env.DEV
+  ? lazy(() => import("@/components/dev/devtools"))
+  : null
 
 export const Route = createRootRoute({
-  notFoundComponent: () => (
-    <main className="flex min-h-svh items-center justify-center p-4">
-      <div className="text-center">
-        <h1 className="text-4xl font-bold">404</h1>
-        <p className="mt-2 text-muted-foreground">Page not found</p>
-      </div>
-    </main>
-  ),
+  notFoundComponent: NotFound,
   component: RootLayout,
 })
 
+function NotFound() {
+  return (
+    <main className="flex min-h-svh items-center justify-center p-4">
+      <div className="flex flex-col items-center gap-4 text-center">
+        <h1 className="text-4xl font-bold">404</h1>
+        <p className="text-muted-foreground">Page not found</p>
+        <Link to="/" className={buttonLook({ variant: "outline" })}>
+          Go home
+        </Link>
+      </div>
+    </main>
+  )
+}
+
 function RootLayout() {
   return (
     <>
       <Outlet />
-      <ReactQueryDevtools buttonPosition="bottom-left" />
-      <TanStackRouterDevtools position="bottom-right" />
+      {Devtools && (
+        <Suspense fallback={null}>
+          <Devtools />
+        </Suspense>
+      )}
     </>
   )
 }
diff --git a/spa/src/routes/_auth.tsx b/spa/src/routes/_auth.tsx
index 37ecaae..1770d16 100644
--- a/spa/src/routes/_auth.tsx
+++ b/spa/src/routes/_auth.tsx
@@ -1,12 +1,14 @@
 import { createFileRoute, Outlet, redirect } from "@tanstack/react-router"
 import { AppShell } from "@/components/layout/app-shell"
+import { ConnectionBanner } from "@/components/offline/connection-banner"
 import { Skeleton } from "@/components/ui/skeleton"
+import { hasSession } from "@/api/session"
 import { useEnsureTimezone } from "@/hooks/use-timezone"
+import { useOutboxSync } from "@/hooks/use-outbox"
 
 export const Route = createFileRoute("/_auth")({
   beforeLoad: () => {
-    const token = localStorage.getItem("accessToken")
-    if (!token) {
+    if (!hasSession()) {
       throw redirect({ to: "/login" })
     }
   },
@@ -24,9 +26,13 @@ export const Route = createFileRoute("/_auth")({
 
 function AuthLayout() {
   useEnsureTimezone()
+  useOutboxSync()
 
   return (
     <AppShell>
+      <div className="pt-3">
+        <ConnectionBanner />
+      </div>
       <Outlet />
     </AppShell>
   )
diff --git a/spa/src/routes/_auth/activities.lazy.tsx b/spa/src/routes/_auth/activities.lazy.tsx
new file mode 100644
index 0000000..e625e70
--- /dev/null
+++ b/spa/src/routes/_auth/activities.lazy.tsx
@@ -0,0 +1,99 @@
+import { useState } from "react"
+import { createLazyFileRoute } from "@tanstack/react-router"
+import { Plus } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Input } from "@/components/ui/input"
+import { Skeleton } from "@/components/ui/skeleton"
+import { useActivities, useCreateActivity } from "@/hooks/use-activities"
+import { ActivityGroup } from "@/components/activity/activity-group"
+import type { ActivityResponse } from "@/api/schema"
+
+export const Route = createLazyFileRoute("/_auth/activities")({
+  component: ActivitiesPage,
+})
+
+function ActivitiesPage() {
+  const { data: activities, isLoading } = useActivities()
+  const createActivity = useCreateActivity()
+  const [newName, setNewName] = useState("")
+  const [newCategory, setNewCategory] = useState("")
+
+  const grouped = groupByCategory(activities ?? [])
+
+  const handleCreate = () => {
+    if (!newName.trim()) return
+    createActivity.mutate(
+      { name: newName.trim(), category: newCategory.trim() || undefined },
+      {
+        onSuccess: () => {
+          setNewName("")
+        },
+      }
+    )
+  }
+
+  return (
+    <div className="flex flex-col gap-4 py-6">
+      <h1 className="text-xl font-bold">Activities</h1>
+
+      <Card>
+        <CardHeader className="pb-2">
+          <CardTitle className="text-sm">Add activity</CardTitle>
+        </CardHeader>
+        <CardContent className="flex flex-col gap-2">
+          <Input
+            placeholder="Activity name"
+            value={newName}
+            onChange={(e) => setNewName(e.target.value)}
+          />
+          <Input
+            placeholder="Category (optional)"
+            value={newCategory}
+            onChange={(e) => setNewCategory(e.target.value)}
+          />
+          <Button
+            size="sm"
+            onClick={handleCreate}
+            disabled={!newName.trim() || createActivity.isPending}
+          >
+            <Plus className="mr-2 h-4 w-4" />
+            {createActivity.isPending ? "Adding..." : "Add"}
+          </Button>
+        </CardContent>
+      </Card>
+
+      {isLoading ? (
+        <Skeleton className="h-40" />
+      ) : (
+        grouped.map(({ category, items }) => (
+          <ActivityGroup
+            key={category}
+            category={category}
+            activities={items}
+          />
+        ))
+      )}
+    </div>
+  )
+}
+
+function groupByCategory(
+  activities: ActivityResponse[]
+): Array<{ category: string; items: ActivityResponse[] }> {
+  const map = new Map<string, ActivityResponse[]>()
+
+  for (const a of activities) {
+    const cat = a.category ?? "Uncategorized"
+    if (!map.has(cat)) map.set(cat, [])
+    map.get(cat)!.push(a)
+  }
+
+  return Array.from(map.entries())
+    .sort(([a], [b]) => {
+      if (a === "Uncategorized") return 1
+      if (b === "Uncategorized") return -1
+      return a.localeCompare(b)
+    })
+    .map(([category, items]) => ({ category, items }))
+}
diff --git a/spa/src/routes/_auth/activities.tsx b/spa/src/routes/_auth/activities.tsx
index 2f88664..2343e5f 100644
--- a/spa/src/routes/_auth/activities.tsx
+++ b/spa/src/routes/_auth/activities.tsx
@@ -1,99 +1,3 @@
-import { useState } from "react"
 import { createFileRoute } from "@tanstack/react-router"
-import { Plus } from "lucide-react"
-import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
-import { Input } from "@/components/ui/input"
-import { Skeleton } from "@/components/ui/skeleton"
-import { useActivities, useCreateActivity } from "@/hooks/use-activities"
-import { ActivityGroup } from "@/components/activity/activity-group"
-import type { ActivityResponse } from "@/api/schema"
 
-export const Route = createFileRoute("/_auth/activities")({
-  component: ActivitiesPage,
-})
-
-function ActivitiesPage() {
-  const { data: activities, isLoading } = useActivities()
-  const createActivity = useCreateActivity()
-  const [newName, setNewName] = useState("")
-  const [newCategory, setNewCategory] = useState("")
-
-  const grouped = groupByCategory(activities ?? [])
-
-  const handleCreate = () => {
-    if (!newName.trim()) return
-    createActivity.mutate(
-      { name: newName.trim(), category: newCategory.trim() || undefined },
-      {
-        onSuccess: () => {
-          setNewName("")
-        },
-      }
-    )
-  }
-
-  return (
-    <div className="flex flex-col gap-4 py-6">
-      <h1 className="text-xl font-bold">Activities</h1>
-
-      <Card>
-        <CardHeader className="pb-2">
-          <CardTitle className="text-sm">Add activity</CardTitle>
-        </CardHeader>
-        <CardContent className="flex flex-col gap-2">
-          <Input
-            placeholder="Activity name"
-            value={newName}
-            onChange={(e) => setNewName(e.target.value)}
-          />
-          <Input
-            placeholder="Category (optional)"
-            value={newCategory}
-            onChange={(e) => setNewCategory(e.target.value)}
-          />
-          <Button
-            size="sm"
-            onClick={handleCreate}
-            disabled={!newName.trim() || createActivity.isPending}
-          >
-            <Plus className="mr-2 h-4 w-4" />
-            {createActivity.isPending ? "Adding..." : "Add"}
-          </Button>
-        </CardContent>
-      </Card>
-
-      {isLoading ? (
-        <Skeleton className="h-40" />
-      ) : (
-        grouped.map(({ category, items }) => (
-          <ActivityGroup
-            key={category}
-            category={category}
-            activities={items}
-          />
-        ))
-      )}
-    </div>
-  )
-}
-
-function groupByCategory(
-  activities: ActivityResponse[]
-): Array<{ category: string; items: ActivityResponse[] }> {
-  const map = new Map<string, ActivityResponse[]>()
-
-  for (const a of activities) {
-    const cat = a.category ?? "Uncategorized"
-    if (!map.has(cat)) map.set(cat, [])
-    map.get(cat)!.push(a)
-  }
-
-  return Array.from(map.entries())
-    .sort(([a], [b]) => {
-      if (a === "Uncategorized") return 1
-      if (b === "Uncategorized") return -1
-      return a.localeCompare(b)
-    })
-    .map(([category, items]) => ({ category, items }))
-}
+export const Route = createFileRoute("/_auth/activities")({})
diff --git a/spa/src/routes/_auth/add.lazy.tsx b/spa/src/routes/_auth/add.lazy.tsx
new file mode 100644
index 0000000..b8dbcf1
--- /dev/null
+++ b/spa/src/routes/_auth/add.lazy.tsx
@@ -0,0 +1,26 @@
+import { createLazyFileRoute, useNavigate } from "@tanstack/react-router"
+import { EntryForm } from "@/components/entry/entry-form"
+import { useNewEntryForm } from "@/hooks/use-new-entry-form"
+
+export const Route = createLazyFileRoute("/_auth/add")({
+  component: AddEntryPage,
+})
+
+function AddEntryPage() {
+  const navigate = useNavigate()
+  const { controls, submit, isSaving } = useNewEntryForm(() =>
+    navigate({ to: "/" })
+  )
+
+  return (
+    <div className="py-6">
+      <EntryForm
+        controls={controls}
+        title="How are you feeling?"
+        submitLabel="Save entry"
+        isSaving={isSaving}
+        onSubmit={submit}
+      />
+    </div>
+  )
+}
diff --git a/spa/src/routes/_auth/add.tsx b/spa/src/routes/_auth/add.tsx
index e037d8b..0c49158 100644
--- a/spa/src/routes/_auth/add.tsx
+++ b/spa/src/routes/_auth/add.tsx
@@ -1,28 +1,3 @@
-import { createFileRoute, useNavigate } from "@tanstack/react-router"
-import { EntryForm } from "@/components/entry/entry-form"
-import type { EntryFormData } from "@/components/entry/entry-form"
-import { useCreateEntry } from "@/hooks/use-entries"
+import { createFileRoute } from "@tanstack/react-router"
 
-export const Route = createFileRoute("/_auth/add")({ component: AddEntryPage })
-
-function AddEntryPage() {
-  const createEntry = useCreateEntry()
-  const navigate = useNavigate()
-
-  const handleSubmit = (data: EntryFormData) => {
-    createEntry.mutate(data, {
-      onSuccess: () => navigate({ to: "/" }),
-    })
-  }
-
-  return (
-    <div className="py-6">
-      <EntryForm
-        title="How are you feeling?"
-        submitLabel="Save entry"
-        isPending={createEntry.isPending}
-        onSubmit={handleSubmit}
-      />
-    </div>
-  )
-}
+export const Route = createFileRoute("/_auth/add")({})
diff --git a/spa/src/routes/_auth/calendar.lazy.tsx b/spa/src/routes/_auth/calendar.lazy.tsx
new file mode 100644
index 0000000..1ac066e
--- /dev/null
+++ b/spa/src/routes/_auth/calendar.lazy.tsx
@@ -0,0 +1,190 @@
+import { useState } from "react"
+import { createLazyFileRoute } from "@tanstack/react-router"
+import {
+  format,
+  addMonths,
+  subMonths,
+  isSameDay,
+  isBefore,
+  isAfter,
+  startOfMonth,
+} from "date-fns"
+import { ChevronLeft, ChevronRight } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent } from "@/components/ui/card"
+import { cn } from "@/lib/utils"
+import { describeDay } from "@/lib/day-label"
+import { formatDate } from "@/lib/day"
+import { getMoodLabel } from "@/lib/mood"
+import { rowOfWeek, weekdayInitials } from "@/lib/week"
+import { useCalendar } from "@/hooks/use-calendar"
+import { useDateBounds } from "@/hooks/use-date-bounds"
+import { EntryCard } from "@/components/entry/entry-card"
+import { MoodDot } from "@/components/mood/mood-dot"
+import { Skeleton } from "@/components/ui/skeleton"
+import type { CalendarDayResponse } from "@/api/schema"
+
+export const Route = createLazyFileRoute("/_auth/calendar")({
+  component: CalendarPage,
+})
+
+function CalendarPage() {
+  const [month, setMonth] = useState(new Date())
+  const [selectedDate, setSelectedDate] = useState<Date | null>(null)
+  const { data: days, isLoading } = useCalendar(month)
+  const { data: bounds } = useDateBounds()
+
+  const canGoBack = bounds?.oldest
+    ? isAfter(startOfMonth(month), startOfMonth(bounds.oldest))
+    : false
+  const canGoForward = isBefore(startOfMonth(month), startOfMonth(new Date()))
+
+  const selectedDay = selectedDate
+    ? days?.find((d) => isSameDay(new Date(d.date), selectedDate))
+    : undefined
+  const selectedEntries = selectedDay?.entries ?? []
+  const selectedCycleDay = selectedDay?.cycleDay ?? null
+
+  return (
+    <div className="flex flex-col gap-4 py-6">
+      <div className="flex items-center justify-between">
+        <Button
+          variant="ghost"
+          size="icon"
+          onClick={() => setMonth((m) => subMonths(m, 1))}
+          disabled={!canGoBack}
+        >
+          <ChevronLeft className="h-5 w-5" />
+        </Button>
+        <h1 className="text-lg font-bold">{format(month, "MMMM yyyy")}</h1>
+        <Button
+          variant="ghost"
+          size="icon"
+          onClick={() => setMonth((m) => addMonths(m, 1))}
+          disabled={!canGoForward}
+        >
+          <ChevronRight className="h-5 w-5" />
+        </Button>
+      </div>
+
+      {isLoading ? (
+        <Skeleton className="h-64" />
+      ) : (
+        <MoodCalendarGrid
+          month={month}
+          days={days ?? []}
+          selectedDate={selectedDate}
+          onSelectDate={setSelectedDate}
+        />
+      )}
+
+      {selectedDate && (
+        <section>
+          <h2 className="mb-2 flex items-baseline gap-2 text-sm font-medium text-muted-foreground">
+            {format(selectedDate, "EEEE, MMMM d")}
+            {selectedCycleDay !== null && (
+              <span className="text-xs font-normal">
+                cycle day {selectedCycleDay}
+              </span>
+            )}
+          </h2>
+          {selectedEntries.length > 0 ? (
+            <div className="flex flex-col gap-2">
+              {selectedEntries.map((entry) => (
+                <EntryCard key={entry.id} entry={entry} />
+              ))}
+            </div>
+          ) : (
+            <Card>
+              <CardContent className="py-6 text-center text-sm text-muted-foreground">
+                No entries for this day
+              </CardContent>
+            </Card>
+          )}
+        </section>
+      )}
+    </div>
+  )
+}
+
+function MoodCalendarGrid({
+  month,
+  days,
+  selectedDate,
+  onSelectDate,
+}: {
+  month: Date
+  days: CalendarDayResponse[]
+  selectedDate: Date | null
+  onSelectDate: (date: Date) => void
+}) {
+  const year = month.getFullYear()
+  const monthIdx = month.getMonth()
+  const blanksBefore = rowOfWeek(new Date(year, monthIdx, 1).getDay())
+  const daysInMonth = new Date(year, monthIdx + 1, 0).getDate()
+
+  const dayNames = weekdayInitials()
+
+  const moodMap = new Map<string, number>()
+  for (const day of days) {
+    if (day.mood) {
+      moodMap.set(day.date, day.mood)
+    }
+  }
+
+  return (
+    <Card>
+      <CardContent className="p-3">
+        <div className="grid grid-cols-7 gap-1 text-center">
+          {dayNames.map((d) => (
+            <div
+              key={d}
+              className="py-1 text-xs font-medium text-muted-foreground"
+            >
+              {d}
+            </div>
+          ))}
+          {Array.from({ length: blanksBefore }).map((_, i) => (
+            <div key={`empty-${i}`} />
+          ))}
+          {Array.from({ length: daysInMonth }).map((_, i) => {
+            const dayNum = i + 1
+            const date = new Date(year, monthIdx, dayNum)
+            const dateStr = formatDate(date)
+            const mood = moodMap.get(dateStr)
+            const isSelected = selectedDate && isSameDay(date, selectedDate)
+            const isToday = isSameDay(date, new Date())
+
+            return (
+              <Button
+                key={dayNum}
+                variant="ghost"
+                aria-label={labelFor(date, mood)}
+                aria-pressed={isSelected ?? false}
+                onClick={() => onSelectDate(date)}
+                className={cn(
+                  "flex h-auto flex-col items-center gap-0.5 rounded-lg px-0 py-1.5 text-sm",
+                  isSelected &&
+                    "bg-primary text-primary-foreground hover:bg-primary/90",
+                  isToday && !isSelected && "bg-muted font-bold"
+                )}
+              >
+                <span aria-hidden="true">{dayNum}</span>
+                {mood ? (
+                  <MoodDot value={mood} labelled={false} />
+                ) : (
+                  <div className="h-2" />
+                )}
+              </Button>
+            )
+          })}
+        </div>
+      </CardContent>
+    </Card>
+  )
+}
+
+function labelFor(date: Date, mood: number | undefined): string {
+  const day = describeDay(date)
+  return mood ? `${day}, ${getMoodLabel(mood)}` : `${day}, nothing logged`
+}
diff --git a/spa/src/routes/_auth/calendar.tsx b/spa/src/routes/_auth/calendar.tsx
index 60d9856..44fcc9e 100644
--- a/spa/src/routes/_auth/calendar.tsx
+++ b/spa/src/routes/_auth/calendar.tsx
@@ -1,175 +1,3 @@
-import { useState } from "react"
 import { createFileRoute } from "@tanstack/react-router"
-import {
-  format,
-  addMonths,
-  subMonths,
-  isSameDay,
-  isBefore,
-  isAfter,
-  startOfMonth,
-} from "date-fns"
-import { ChevronLeft, ChevronRight } from "lucide-react"
-import { Button } from "@/components/ui/button"
-import { Card, CardContent } from "@/components/ui/card"
-import { cn } from "@/lib/utils"
-import { useCalendar } from "@/hooks/use-calendar"
-import { useDateBounds } from "@/hooks/use-date-bounds"
-import { EntryCard } from "@/components/entry/entry-card"
-import { MoodDot } from "@/components/mood/mood-dot"
-import { Skeleton } from "@/components/ui/skeleton"
-import type { CalendarDayResponse } from "@/api/schema"
 
-export const Route = createFileRoute("/_auth/calendar")({
-  component: CalendarPage,
-})
-
-function CalendarPage() {
-  const [month, setMonth] = useState(new Date())
-  const [selectedDate, setSelectedDate] = useState<Date | null>(null)
-  const { data: days, isLoading } = useCalendar(month)
-  const { data: bounds } = useDateBounds()
-
-  const canGoBack = bounds?.oldest
-    ? isAfter(startOfMonth(month), startOfMonth(bounds.oldest))
-    : false
-  const canGoForward = isBefore(startOfMonth(month), startOfMonth(new Date()))
-
-  const selectedDay = selectedDate
-    ? days?.find((d) => isSameDay(new Date(d.date), selectedDate))
-    : undefined
-  const selectedEntries = selectedDay?.entries ?? []
-  const selectedCycleDay = selectedDay?.cycleDay ?? null
-
-  return (
-    <div className="flex flex-col gap-4 py-6">
-      <div className="flex items-center justify-between">
-        <Button
-          variant="ghost"
-          size="icon"
-          onClick={() => setMonth((m) => subMonths(m, 1))}
-          disabled={!canGoBack}
-        >
-          <ChevronLeft className="h-5 w-5" />
-        </Button>
-        <h1 className="text-lg font-bold">{format(month, "MMMM yyyy")}</h1>
-        <Button
-          variant="ghost"
-          size="icon"
-          onClick={() => setMonth((m) => addMonths(m, 1))}
-          disabled={!canGoForward}
-        >
-          <ChevronRight className="h-5 w-5" />
-        </Button>
-      </div>
-
-      {isLoading ? (
-        <Skeleton className="h-64" />
-      ) : (
-        <MoodCalendarGrid
-          month={month}
-          days={days ?? []}
-          selectedDate={selectedDate}
-          onSelectDate={setSelectedDate}
-        />
-      )}
-
-      {selectedDate && (
-        <section>
-          <h2 className="mb-2 flex items-baseline gap-2 text-sm font-medium text-muted-foreground">
-            {format(selectedDate, "EEEE, MMMM d")}
-            {selectedCycleDay !== null && (
-              <span className="text-xs font-normal">
-                cycle day {selectedCycleDay}
-              </span>
-            )}
-          </h2>
-          {selectedEntries.length > 0 ? (
-            <div className="flex flex-col gap-2">
-              {selectedEntries.map((entry) => (
-                <EntryCard key={entry.id} entry={entry} />
-              ))}
-            </div>
-          ) : (
-            <Card>
-              <CardContent className="py-6 text-center text-sm text-muted-foreground">
-                No entries for this day
-              </CardContent>
-            </Card>
-          )}
-        </section>
-      )}
-    </div>
-  )
-}
-
-function MoodCalendarGrid({
-  month,
-  days,
-  selectedDate,
-  onSelectDate,
-}: {
-  month: Date
-  days: CalendarDayResponse[]
-  selectedDate: Date | null
-  onSelectDate: (date: Date) => void
-}) {
-  const year = month.getFullYear()
-  const monthIdx = month.getMonth()
-  const firstDay = new Date(year, monthIdx, 1).getDay()
-  const daysInMonth = new Date(year, monthIdx + 1, 0).getDate()
-
-  const dayNames = ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]
-
-  const moodMap = new Map<string, number>()
-  for (const day of days) {
-    if (day.mood) {
-      moodMap.set(day.date, day.mood)
-    }
-  }
-
-  return (
-    <Card>
-      <CardContent className="p-3">
-        <div className="grid grid-cols-7 gap-1 text-center">
-          {dayNames.map((d) => (
-            <div
-              key={d}
-              className="py-1 text-xs font-medium text-muted-foreground"
-            >
-              {d}
-            </div>
-          ))}
-          {Array.from({ length: firstDay }).map((_, i) => (
-            <div key={`empty-${i}`} />
-          ))}
-          {Array.from({ length: daysInMonth }).map((_, i) => {
-            const dayNum = i + 1
-            const date = new Date(year, monthIdx, dayNum)
-            const dateStr = format(date, "yyyy-MM-dd")
-            const mood = moodMap.get(dateStr)
-            const isSelected = selectedDate && isSameDay(date, selectedDate)
-            const isToday = isSameDay(date, new Date())
-
-            return (
-              <Button
-                key={dayNum}
-                variant="ghost"
-                onClick={() => onSelectDate(date)}
-                className={cn(
-                  "flex h-auto flex-col items-center gap-0.5 rounded-lg px-0 py-1.5 text-sm",
-                  isSelected &&
-                    "bg-primary text-primary-foreground hover:bg-primary/90",
-                  isToday && !isSelected && "bg-muted font-bold"
-                )}
-              >
-                <span>{dayNum}</span>
-                {mood ? <MoodDot value={mood} /> : <div className="h-2" />}
-              </Button>
-            )
-          })}
-        </div>
-      </CardContent>
-    </Card>
-  )
-}
+export const Route = createFileRoute("/_auth/calendar")({})
diff --git a/spa/src/routes/_auth/diary.lazy.tsx b/spa/src/routes/_auth/diary.lazy.tsx
new file mode 100644
index 0000000..d335d3f
--- /dev/null
+++ b/spa/src/routes/_auth/diary.lazy.tsx
@@ -0,0 +1,94 @@
+import { useState } from "react"
+import { createLazyFileRoute } from "@tanstack/react-router"
+import { SlidersHorizontal } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent } from "@/components/ui/card"
+import { Skeleton } from "@/components/ui/skeleton"
+import { Spinner } from "@/components/ui/spinner"
+import { EntryList } from "@/components/entry/entry-list"
+import { PendingEntries } from "@/components/entry/pending-entries"
+import { EntryFiltersBar, isNarrowed } from "@/components/entry/entry-filters"
+import { useEntryFeed } from "@/hooks/use-entries"
+import type { EntryFilters } from "@/hooks/use-entries"
+import { useInfiniteScroll } from "@/hooks/use-infinite-scroll"
+
+export const Route = createLazyFileRoute("/_auth/diary")({
+  component: DiaryPage,
+})
+
+function DiaryPage() {
+  const [filters, setFilters] = useState<EntryFilters>({})
+  const [filtersOpen, setFiltersOpen] = useState(false)
+  const feed = useEntryFeed(filters)
+
+  const entries = feed.data?.pages.flatMap((page) => page.items) ?? []
+  const total = feed.data?.pages[0]?.total ?? 0
+
+  const sentinelRef = useInfiniteScroll({
+    hasMore: feed.hasNextPage,
+    isLoading: feed.isFetchingNextPage,
+    loadMore: feed.fetchNextPage,
+  })
+
+  return (
+    <div className="flex flex-col gap-4 py-6">
+      <header className="flex items-center justify-between">
+        <div>
+          <h1 className="text-xl font-bold">Diary</h1>
+          {!feed.isLoading && (
+            <p className="text-xs text-muted-foreground">
+              {countOf(total, isNarrowed(filters))}
+            </p>
+          )}
+        </div>
+        <Button
+          variant={isNarrowed(filters) ? "default" : "outline"}
+          size="sm"
+          aria-expanded={filtersOpen}
+          onClick={() => setFiltersOpen((open) => !open)}
+        >
+          <SlidersHorizontal className="mr-1 h-4 w-4" aria-hidden="true" />
+          Filter
+        </Button>
+      </header>
+
+      {filtersOpen && (
+        <Card>
+          <CardContent className="py-4">
+            <EntryFiltersBar filters={filters} onChange={setFilters} />
+          </CardContent>
+        </Card>
+      )}
+
+      {!isNarrowed(filters) && <PendingEntries />}
+
+      {feed.isLoading ? (
+        <div className="flex flex-col gap-2">
+          <Skeleton className="h-20" />
+          <Skeleton className="h-20" />
+          <Skeleton className="h-20" />
+        </div>
+      ) : entries.length ? (
+        <EntryList entries={entries} />
+      ) : (
+        <Card>
+          <CardContent className="py-8 text-center text-sm text-muted-foreground">
+            {isNarrowed(filters)
+              ? "Nothing matches these filters."
+              : "No entries yet."}
+          </CardContent>
+        </Card>
+      )}
+
+      <div ref={sentinelRef} className="flex justify-center py-2">
+        {feed.isFetchingNextPage && <Spinner />}
+      </div>
+    </div>
+  )
+}
+
+function countOf(total: number, narrowed: boolean): string {
+  if (narrowed) return `${total} ${total === 1 ? "match" : "matches"}`
+
+  return `${total} ${total === 1 ? "entry" : "entries"}`
+}
diff --git a/spa/src/routes/_auth/diary.tsx b/spa/src/routes/_auth/diary.tsx
index df3a34e..cc26a1e 100644
--- a/spa/src/routes/_auth/diary.tsx
+++ b/spa/src/routes/_auth/diary.tsx
@@ -1,67 +1,3 @@
-import { useState } from "react"
 import { createFileRoute } from "@tanstack/react-router"
-import { Button } from "@/components/ui/button"
-import { Card, CardContent } from "@/components/ui/card"
-import { Skeleton } from "@/components/ui/skeleton"
-import { EntryList } from "@/components/entry/entry-list"
-import { useEntries } from "@/hooks/use-entries"
 
-const PAGE_SIZE = 30
-
-export const Route = createFileRoute("/_auth/diary")({
-  component: DiaryPage,
-})
-
-function DiaryPage() {
-  const [page, setPage] = useState(0)
-  const { data: entries, isLoading } = useEntries({
-    limit: PAGE_SIZE,
-    offset: page * PAGE_SIZE,
-  })
-
-  const hasMore = (entries?.length ?? 0) === PAGE_SIZE
-
-  return (
-    <div className="flex flex-col gap-4 py-6">
-      <header>
-        <h1 className="text-xl font-bold">Diary</h1>
-      </header>
-
-      {isLoading ? (
-        <div className="flex flex-col gap-2">
-          <Skeleton className="h-20" />
-          <Skeleton className="h-20" />
-          <Skeleton className="h-20" />
-        </div>
-      ) : entries?.length ? (
-        <EntryList entries={entries} />
-      ) : (
-        <Card>
-          <CardContent className="py-8 text-center text-sm text-muted-foreground">
-            {page > 0 ? "No more entries" : "No entries yet"}
-          </CardContent>
-        </Card>
-      )}
-
-      <div className="flex items-center justify-between">
-        <Button
-          variant="outline"
-          size="sm"
-          onClick={() => setPage((p) => Math.max(0, p - 1))}
-          disabled={page === 0}
-        >
-          Newer
-        </Button>
-        <span className="text-xs text-muted-foreground">Page {page + 1}</span>
-        <Button
-          variant="outline"
-          size="sm"
-          onClick={() => setPage((p) => p + 1)}
-          disabled={!hasMore}
-        >
-          Older
-        </Button>
-      </div>
-    </div>
-  )
-}
+export const Route = createFileRoute("/_auth/diary")({})
diff --git a/spa/src/routes/_auth/edit.$id.lazy.tsx b/spa/src/routes/_auth/edit.$id.lazy.tsx
new file mode 100644
index 0000000..600f8b8
--- /dev/null
+++ b/spa/src/routes/_auth/edit.$id.lazy.tsx
@@ -0,0 +1,66 @@
+import { createLazyFileRoute, useRouter } from "@tanstack/react-router"
+import { ArrowLeft } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Skeleton } from "@/components/ui/skeleton"
+import { EntryForm } from "@/components/entry/entry-form"
+import { EntryMissing } from "@/components/entry/entry-missing"
+import { useEntry } from "@/hooks/use-entries"
+import { useEntryDraft } from "@/hooks/use-entry-draft"
+import { useSaveEntryEdit } from "@/hooks/use-save-entry"
+import { draftOf } from "@/lib/entry-draft"
+import type { EntryResponse } from "@/api/schema"
+
+export const Route = createLazyFileRoute("/_auth/edit/$id")({
+  component: EditEntryPage,
+})
+
+function EditEntryPage() {
+  const { id } = Route.useParams()
+  const { data: entry, isLoading } = useEntry(id)
+
+  if (isLoading) {
+    return (
+      <div className="flex flex-col gap-4 py-6">
+        <Skeleton className="h-8 w-32" />
+        <Skeleton className="h-40" />
+      </div>
+    )
+  }
+
+  if (!entry) return <EntryMissing />
+
+  return <EditEntryForm entry={entry} />
+}
+
+function EditEntryForm({ entry }: { entry: EntryResponse }) {
+  const router = useRouter()
+  const controls = useEntryDraft({ initial: draftOf(entry), persist: false })
+  const save = useSaveEntryEdit(entry.id)
+
+  return (
+    <div className="py-6">
+      <div className="mb-4 flex items-center gap-3">
+        <Button
+          variant="ghost"
+          size="icon"
+          aria-label="Go back"
+          onClick={() => router.history.back()}
+        >
+          <ArrowLeft className="h-5 w-5" aria-hidden="true" />
+        </Button>
+      </div>
+
+      <EntryForm
+        controls={controls}
+        title="Edit entry"
+        submitLabel="Save changes"
+        isSaving={save.isPending}
+        onSubmit={() =>
+          save.mutate(controls.draft, {
+            onSuccess: () => router.history.back(),
+          })
+        }
+      />
+    </div>
+  )
+}
diff --git a/spa/src/routes/_auth/edit.$id.tsx b/spa/src/routes/_auth/edit.$id.tsx
index e3b6c5e..fb4d32a 100644
--- a/spa/src/routes/_auth/edit.$id.tsx
+++ b/spa/src/routes/_auth/edit.$id.tsx
@@ -1,85 +1,3 @@
-import {
-  activitiesOf,
-  contentOf,
-  locationOf,
-  photosOf,
-  songOf,
-  voiceMemosOf,
-} from "@/lib/dimensions"
-import { createFileRoute, useNavigate } from "@tanstack/react-router"
-import { ArrowLeft } from "lucide-react"
-import { Button } from "@/components/ui/button"
-import { Skeleton } from "@/components/ui/skeleton"
-import { EntryForm } from "@/components/entry/entry-form"
-import type { EntryFormData } from "@/components/entry/entry-form"
-import { useEntry } from "@/hooks/use-entries"
-import { useUpdateEntry } from "@/hooks/use-update-entry"
+import { createFileRoute } from "@tanstack/react-router"
 
-export const Route = createFileRoute("/_auth/edit/$id")({
-  component: EditEntryPage,
-})
-
-function EditEntryPage() {
-  const { id } = Route.useParams()
-  const navigate = useNavigate()
-  const { data: entry, isLoading } = useEntry(id)
-  const updateEntry = useUpdateEntry()
-
-  const handleSubmit = (data: EntryFormData) => {
-    updateEntry.mutate(
-      { id, body: data },
-      { onSuccess: () => navigate({ to: "/entry/$id", params: { id } }) }
-    )
-  }
-
-  if (isLoading) {
-    return (
-      <div className="flex flex-col gap-4 py-6">
-        <Skeleton className="h-8 w-32" />
-        <Skeleton className="h-40" />
-      </div>
-    )
-  }
-
-  if (!entry) {
-    return (
-      <div className="flex flex-col items-center gap-4 py-12">
-        <p className="text-muted-foreground">Entry not found</p>
-        <Button variant="outline" onClick={() => navigate({ to: "/" })}>
-          Go home
-        </Button>
-      </div>
-    )
-  }
-
-  return (
-    <div className="py-6">
-      <div className="mb-4 flex items-center gap-3">
-        <Button
-          variant="ghost"
-          size="icon"
-          onClick={() => navigate({ to: "/entry/$id", params: { id } })}
-        >
-          <ArrowLeft className="h-5 w-5" />
-        </Button>
-      </div>
-
-      <EntryForm
-        title="Edit entry"
-        submitLabel="Save changes"
-        isPending={updateEntry.isPending}
-        onSubmit={handleSubmit}
-        initial={{
-          mood: entry.mood,
-          loggedAt: entry.loggedAt,
-          content: contentOf(entry) ?? undefined,
-          activities: activitiesOf(entry),
-          photos: photosOf(entry),
-          voiceMemos: voiceMemosOf(entry),
-          location: locationOf(entry),
-          song: songOf(entry),
-        }}
-      />
-    </div>
-  )
-}
+export const Route = createFileRoute("/_auth/edit/$id")({})
diff --git a/spa/src/routes/_auth/entry.$id.lazy.tsx b/spa/src/routes/_auth/entry.$id.lazy.tsx
new file mode 100644
index 0000000..34465c9
--- /dev/null
+++ b/spa/src/routes/_auth/entry.$id.lazy.tsx
@@ -0,0 +1,196 @@
+import { createLazyFileRoute, Link, useRouter } from "@tanstack/react-router"
+import { buttonLook } from "@/lib/button-style"
+import { format } from "date-fns"
+import { ArrowLeft, Pencil, Trash2 } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Skeleton } from "@/components/ui/skeleton"
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+} from "@/components/ui/alert-dialog"
+import { MoodBadge } from "@/components/mood/mood-badge"
+import { AudioPlayer } from "@/components/media/audio-player"
+import { EntryWeather } from "@/components/entry/entry-weather"
+import { EntryPhotos } from "@/components/entry/detail/entry-photos"
+import { EntryActivities } from "@/components/entry/detail/entry-activities"
+import { EntryMissing } from "@/components/entry/entry-missing"
+import { useEntry, useDeleteEntry } from "@/hooks/use-entries"
+import { useActivities } from "@/hooks/use-activities"
+import { media } from "@/api/client"
+import {
+  activitiesOf,
+  contentOf,
+  locationOf,
+  photosOf,
+  songOf,
+  voiceMemosOf,
+} from "@/lib/dimensions"
+
+export const Route = createLazyFileRoute("/_auth/entry/$id")({
+  component: EntryDetailPage,
+})
+
+const COORDINATE_PRECISION = 4
+
+function EntryDetailPage() {
+  const { id } = Route.useParams()
+  const router = useRouter()
+  const { data: entry, isLoading } = useEntry(id)
+  const { data: activities } = useActivities()
+  const deleteEntry = useDeleteEntry()
+
+  if (isLoading) {
+    return (
+      <div className="flex flex-col gap-4 py-6">
+        <Skeleton className="h-8 w-32" />
+        <Skeleton className="h-40" />
+      </div>
+    )
+  }
+
+  if (!entry) return <EntryMissing />
+
+  const loggedAt = new Date(entry.loggedAt)
+  const note = contentOf(entry)
+  const song = songOf(entry)
+  const location = locationOf(entry)
+  const voiceMemos = voiceMemosOf(entry)
+
+  return (
+    <div className="flex flex-col gap-4 py-6">
+      <div className="flex items-center justify-between">
+        <Button
+          variant="ghost"
+          size="icon"
+          aria-label="Go back"
+          onClick={() => router.history.back()}
+        >
+          <ArrowLeft className="h-5 w-5" aria-hidden="true" />
+        </Button>
+
+        <div className="flex items-center gap-1">
+          <Link
+            to="/edit/$id"
+            params={{ id }}
+            aria-label="Edit entry"
+            className={buttonLook({ variant: "ghost", size: "icon" })}
+          >
+            <Pencil className="h-5 w-5" aria-hidden="true" />
+          </Link>
+
+          <AlertDialog>
+            <AlertDialogTrigger
+              aria-label="Delete entry"
+              className="inline-flex h-9 w-9 items-center justify-center rounded-md text-destructive hover:bg-muted"
+            >
+              <Trash2 className="h-5 w-5" aria-hidden="true" />
+            </AlertDialogTrigger>
+            <AlertDialogContent>
+              <AlertDialogHeader>
+                <AlertDialogTitle>Delete entry?</AlertDialogTitle>
+                <AlertDialogDescription>
+                  This action cannot be undone.
+                </AlertDialogDescription>
+              </AlertDialogHeader>
+              <AlertDialogFooter>
+                <AlertDialogCancel>Cancel</AlertDialogCancel>
+                <AlertDialogAction
+                  onClick={() =>
+                    deleteEntry.mutate(id, {
+                      onSuccess: () => router.history.back(),
+                    })
+                  }
+                >
+                  Delete
+                </AlertDialogAction>
+              </AlertDialogFooter>
+            </AlertDialogContent>
+          </AlertDialog>
+        </div>
+      </div>
+
+      <Card>
+        <CardContent className="flex flex-col items-center gap-2 py-6">
+          <MoodBadge value={entry.mood} showLabel className="text-3xl" />
+          <p className="text-sm text-muted-foreground">
+            <time dateTime={entry.loggedAt}>
+              {format(loggedAt, "EEEE, MMMM d, yyyy 'at' h:mm a")}
+            </time>
+          </p>
+        </CardContent>
+      </Card>
+
+      {note && (
+        <Card>
+          <CardHeader className="pb-2">
+            <CardTitle className="text-sm">Note</CardTitle>
+          </CardHeader>
+          <CardContent>
+            <p className="text-sm whitespace-pre-wrap">{note}</p>
+          </CardContent>
+        </Card>
+      )}
+
+      {song && (
+        <Card>
+          <CardHeader className="pb-2">
+            <CardTitle className="text-sm">Listening to</CardTitle>
+          </CardHeader>
+          <CardContent>
+            <p className="text-sm">
+              {song.title}
+              <span className="text-muted-foreground"> — {song.artist}</span>
+            </p>
+          </CardContent>
+        </Card>
+      )}
+
+      {location && (
+        <Card>
+          <CardHeader className="pb-2">
+            <CardTitle className="text-sm">Location</CardTitle>
+          </CardHeader>
+          <CardContent className="flex flex-col gap-1.5">
+            <p className="text-sm text-muted-foreground tabular-nums">
+              {location.latitude.toFixed(COORDINATE_PRECISION)},{" "}
+              {location.longitude.toFixed(COORDINATE_PRECISION)}
+            </p>
+            <EntryWeather entry={entry} />
+          </CardContent>
+        </Card>
+      )}
+
+      <EntryActivities
+        activityIds={activitiesOf(entry)}
+        catalogue={activities ?? []}
+      />
+
+      <EntryPhotos photoIds={photosOf(entry)} />
+
+      {voiceMemos.length > 0 && (
+        <Card>
+          <CardHeader className="pb-2">
+            <CardTitle className="text-sm">Voice memos</CardTitle>
+          </CardHeader>
+          <CardContent className="flex flex-col gap-2">
+            {voiceMemos.map((memoId, index) => (
+              <AudioPlayer
+                key={memoId}
+                src={media.voiceMemoUrl(memoId)}
+                label={`Voice memo ${index + 1}`}
+              />
+            ))}
+          </CardContent>
+        </Card>
+      )}
+    </div>
+  )
+}
diff --git a/spa/src/routes/_auth/entry.$id.tsx b/spa/src/routes/_auth/entry.$id.tsx
index c696f10..99c89e7 100644
--- a/spa/src/routes/_auth/entry.$id.tsx
+++ b/spa/src/routes/_auth/entry.$id.tsx
@@ -1,257 +1,3 @@
-import {
-  activitiesOf,
-  contentOf,
-  locationOf,
-  photosOf,
-  songOf,
-  voiceMemosOf,
-} from "@/lib/dimensions"
-import { createFileRoute, Link, useNavigate } from "@tanstack/react-router"
-import { format } from "date-fns"
-import { ArrowLeft, Pencil, Trash2 } from "lucide-react"
-import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
-import { EntryWeather } from "@/components/entry/entry-weather"
-import { Badge } from "@/components/ui/badge"
-import { Skeleton } from "@/components/ui/skeleton"
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-  AlertDialogTrigger,
-} from "@/components/ui/alert-dialog"
-import { MoodBadge } from "@/components/mood/mood-badge"
-import { AudioPlayer } from "@/components/media/audio-player"
-import { useEntry, useDeleteEntry } from "@/hooks/use-entries"
-import { useActivities } from "@/hooks/use-activities"
-import { media } from "@/api/client"
+import { createFileRoute } from "@tanstack/react-router"
 
-export const Route = createFileRoute("/_auth/entry/$id")({
-  component: EntryDetailPage,
-})
-
-function EntryDetailPage() {
-  const { id } = Route.useParams()
-  const navigate = useNavigate()
-  const { data: entry, isLoading } = useEntry(id)
-  const { data: activities } = useActivities()
-  const deleteEntry = useDeleteEntry()
-
-  const handleDelete = () => {
-    deleteEntry.mutate(id, {
-      onSuccess: () => navigate({ to: "/" }),
-    })
-  }
-
-  if (isLoading) {
-    return (
-      <div className="flex flex-col gap-4 py-6">
-        <Skeleton className="h-8 w-32" />
-        <Skeleton className="h-40" />
-      </div>
-    )
-  }
-
-  if (!entry) {
-    return (
-      <div className="flex flex-col items-center gap-4 py-12">
-        <p className="text-muted-foreground">Entry not found</p>
-        <Button variant="outline" onClick={() => navigate({ to: "/" })}>
-          Go home
-        </Button>
-      </div>
-    )
-  }
-
-  const date = new Date(entry.loggedAt)
-
-  return (
-    <div className="flex flex-col gap-4 py-6">
-      <div className="flex items-center justify-between">
-        <Button
-          variant="ghost"
-          size="icon"
-          onClick={() => navigate({ to: "/" })}
-        >
-          <ArrowLeft className="h-5 w-5" />
-        </Button>
-
-        <div className="flex items-center gap-1">
-          <Link to="/edit/$id" params={{ id }}>
-            <Button variant="ghost" size="icon">
-              <Pencil className="h-5 w-5" />
-            </Button>
-          </Link>
-
-          <AlertDialog>
-            <AlertDialogTrigger className="inline-flex h-9 w-9 items-center justify-center rounded-md text-destructive hover:bg-muted">
-              <Trash2 className="h-5 w-5" />
-            </AlertDialogTrigger>
-            <AlertDialogContent>
-              <AlertDialogHeader>
-                <AlertDialogTitle>Delete entry?</AlertDialogTitle>
-                <AlertDialogDescription>
-                  This action cannot be undone.
-                </AlertDialogDescription>
-              </AlertDialogHeader>
-              <AlertDialogFooter>
-                <AlertDialogCancel>Cancel</AlertDialogCancel>
-                <AlertDialogAction onClick={handleDelete}>
-                  Delete
-                </AlertDialogAction>
-              </AlertDialogFooter>
-            </AlertDialogContent>
-          </AlertDialog>
-        </div>
-      </div>
-
-      <Card>
-        <CardContent className="flex flex-col items-center gap-2 py-6">
-          <MoodBadge value={entry.mood} showLabel className="text-3xl" />
-          <p className="text-sm text-muted-foreground">
-            {format(date, "EEEE, MMMM d, yyyy")}
-          </p>
-          <p className="text-sm text-muted-foreground">
-            {format(date, "h:mm a")}
-          </p>
-        </CardContent>
-      </Card>
-
-      {contentOf(entry) && (
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm">Note</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <p className="text-sm whitespace-pre-wrap">{contentOf(entry)}</p>
-          </CardContent>
-        </Card>
-      )}
-
-      {songOf(entry) && (
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm">Listening to</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <p className="text-sm">
-              {songOf(entry)?.title}
-              <span className="text-muted-foreground">
-                {" "}
-                — {songOf(entry)?.artist}
-              </span>
-            </p>
-          </CardContent>
-        </Card>
-      )}
-
-      {locationOf(entry) && (
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm">Location</CardTitle>
-          </CardHeader>
-          <CardContent className="flex flex-col gap-1.5">
-            <p className="text-sm text-muted-foreground">
-              {locationOf(entry)?.latitude.toFixed(4)},{" "}
-              {locationOf(entry)?.longitude.toFixed(4)}
-            </p>
-            <EntryWeather entry={entry} />
-          </CardContent>
-        </Card>
-      )}
-
-      {activitiesOf(entry).length > 0 && (
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm">Activities</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <GroupedActivityBadges
-              activityIds={activitiesOf(entry)}
-              allActivities={activities ?? []}
-            />
-          </CardContent>
-        </Card>
-      )}
-
-      {photosOf(entry).length > 0 && (
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm">Photos</CardTitle>
-          </CardHeader>
-          <CardContent className="grid grid-cols-2 gap-2">
-            {photosOf(entry).map((photoId) => (
-              <img
-                key={photoId}
-                src={media.photoUrl(photoId)}
-                alt=""
-                className="aspect-square w-full rounded-lg object-cover"
-              />
-            ))}
-          </CardContent>
-        </Card>
-      )}
-
-      {voiceMemosOf(entry).length > 0 && (
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm">Voice memos</CardTitle>
-          </CardHeader>
-          <CardContent className="flex flex-col gap-2">
-            {voiceMemosOf(entry).map((memoId) => (
-              <AudioPlayer key={memoId} src={media.voiceMemoUrl(memoId)} />
-            ))}
-          </CardContent>
-        </Card>
-      )}
-    </div>
-  )
-}
-
-function GroupedActivityBadges({
-  activityIds,
-  allActivities,
-}: {
-  activityIds: string[]
-  allActivities: Array<{ id: string; name: string; category?: string | null }>
-}) {
-  const lookup = new Map(allActivities.map((a) => [a.id, a]))
-  const grouped = new Map<string, string[]>()
-
-  for (const id of activityIds) {
-    const activity = lookup.get(id)
-    const cat = activity?.category ?? "Other"
-    if (!grouped.has(cat)) grouped.set(cat, [])
-    grouped.get(cat)!.push(activity?.name ?? id.slice(0, 8))
-  }
-
-  const entries = Array.from(grouped.entries()).sort(([a], [b]) => {
-    if (a === "Other") return 1
-    if (b === "Other") return -1
-    return a.localeCompare(b)
-  })
-
-  return (
-    <div className="flex flex-col gap-3">
-      {entries.map(([category, names]) => (
-        <div key={category}>
-          <p className="mb-1.5 text-xs font-medium tracking-wide text-muted-foreground uppercase">
-            {category}
-          </p>
-          <div className="flex flex-wrap gap-2">
-            {names.map((name) => (
-              <Badge key={name} variant="outline" className="text-xs">
-                {name}
-              </Badge>
-            ))}
-          </div>
-        </div>
-      ))}
-    </div>
-  )
-}
+export const Route = createFileRoute("/_auth/entry/$id")({})
diff --git a/spa/src/routes/_auth/export.lazy.tsx b/spa/src/routes/_auth/export.lazy.tsx
new file mode 100644
index 0000000..403d5dd
--- /dev/null
+++ b/spa/src/routes/_auth/export.lazy.tsx
@@ -0,0 +1,100 @@
+import { createLazyFileRoute } from "@tanstack/react-router"
+import { AlertTriangle, Download, Share2 } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import {
+  useCompleteBackup,
+  useShareableExtract,
+} from "@/hooks/use-import-export"
+
+export const Route = createLazyFileRoute("/_auth/export")({
+  component: ExportPage,
+})
+
+function ExportPage() {
+  const backup = useCompleteBackup()
+  const extract = useShareableExtract()
+
+  return (
+    <div className="flex flex-col gap-6 py-6">
+      <h1 className="text-xl font-bold">Take your data out</h1>
+
+      <p className="text-sm text-muted-foreground">
+        Two different things, for two different reasons. One is for keeping, the
+        other is for handing to someone.
+      </p>
+
+      <Card className="border-destructive/40">
+        <CardHeader className="pb-2">
+          <CardTitle className="flex items-center gap-2 text-sm">
+            <AlertTriangle className="h-4 w-4 text-destructive" />
+            Complete backup — keep this private
+          </CardTitle>
+        </CardHeader>
+        <CardContent className="flex flex-col gap-3">
+          <p className="text-sm text-muted-foreground">
+            Everything this account knows about you, so that nothing is lost if
+            you need to restore it.
+          </p>
+          <ul className="list-inside list-disc space-y-0.5 text-xs text-muted-foreground">
+            <li>Every entry, with its notes, photos and voice memos</li>
+            <li>Where you were and what you were listening to</li>
+            <li>Steps, sleep, heart rate and every other daily metric</li>
+            <li>Cycle records, if you track them</li>
+            <li>Your activity catalogue, reminders and settings</li>
+          </ul>
+          <p className="text-xs text-destructive">
+            Do not send this to anyone. It is a copy of your whole journal.
+          </p>
+          <Button
+            size="lg"
+            variant="outline"
+            className="w-full"
+            disabled={backup.isPending}
+            onClick={() => backup.mutate()}
+          >
+            <Download className="mr-2 h-4 w-4" />
+            {backup.isPending
+              ? "Preparing backup…"
+              : "Download complete backup (.zip)"}
+          </Button>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader className="pb-2">
+          <CardTitle className="flex items-center gap-2 text-sm">
+            <Share2 className="h-4 w-4" />
+            Shareable journal — safe to send
+          </CardTitle>
+        </CardHeader>
+        <CardContent className="flex flex-col gap-3">
+          <p className="text-sm text-muted-foreground">
+            A readable document of how you have been feeling, for a therapist, a
+            doctor, or someone you trust.
+          </p>
+          <ul className="list-inside list-disc space-y-0.5 text-xs text-muted-foreground">
+            <li>Your mood, day by day</li>
+            <li>What you wrote</li>
+            <li>What you tagged</li>
+          </ul>
+          <p className="text-xs text-muted-foreground">
+            It carries no places, no health readings, no cycle records and no
+            photos. It cannot be used to restore your account.
+          </p>
+          <Button
+            size="lg"
+            className="w-full"
+            disabled={extract.isPending}
+            onClick={() => extract.mutate()}
+          >
+            <Share2 className="mr-2 h-4 w-4" />
+            {extract.isPending
+              ? "Preparing journal…"
+              : "Download shareable journal (.md)"}
+          </Button>
+        </CardContent>
+      </Card>
+    </div>
+  )
+}
diff --git a/spa/src/routes/_auth/export.tsx b/spa/src/routes/_auth/export.tsx
index b283517..32ce905 100644
--- a/spa/src/routes/_auth/export.tsx
+++ b/spa/src/routes/_auth/export.tsx
@@ -1,100 +1,3 @@
 import { createFileRoute } from "@tanstack/react-router"
-import { AlertTriangle, Download, Share2 } from "lucide-react"
-import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
-import {
-  useCompleteBackup,
-  useShareableExtract,
-} from "@/hooks/use-import-export"
 
-export const Route = createFileRoute("/_auth/export")({
-  component: ExportPage,
-})
-
-function ExportPage() {
-  const backup = useCompleteBackup()
-  const extract = useShareableExtract()
-
-  return (
-    <div className="flex flex-col gap-6 py-6">
-      <h1 className="text-xl font-bold">Take your data out</h1>
-
-      <p className="text-sm text-muted-foreground">
-        Two different things, for two different reasons. One is for keeping, the
-        other is for handing to someone.
-      </p>
-
-      <Card className="border-destructive/40">
-        <CardHeader className="pb-2">
-          <CardTitle className="flex items-center gap-2 text-sm">
-            <AlertTriangle className="h-4 w-4 text-destructive" />
-            Complete backup — keep this private
-          </CardTitle>
-        </CardHeader>
-        <CardContent className="flex flex-col gap-3">
-          <p className="text-sm text-muted-foreground">
-            Everything this account knows about you, so that nothing is lost if
-            you need to restore it.
-          </p>
-          <ul className="list-inside list-disc space-y-0.5 text-xs text-muted-foreground">
-            <li>Every entry, with its notes, photos and voice memos</li>
-            <li>Where you were and what you were listening to</li>
-            <li>Steps, sleep, heart rate and every other daily metric</li>
-            <li>Cycle records, if you track them</li>
-            <li>Your activity catalogue, reminders and settings</li>
-          </ul>
-          <p className="text-xs text-destructive">
-            Do not send this to anyone. It is a copy of your whole journal.
-          </p>
-          <Button
-            size="lg"
-            variant="outline"
-            className="w-full"
-            disabled={backup.isPending}
-            onClick={() => backup.mutate()}
-          >
-            <Download className="mr-2 h-4 w-4" />
-            {backup.isPending
-              ? "Preparing backup…"
-              : "Download complete backup (.zip)"}
-          </Button>
-        </CardContent>
-      </Card>
-
-      <Card>
-        <CardHeader className="pb-2">
-          <CardTitle className="flex items-center gap-2 text-sm">
-            <Share2 className="h-4 w-4" />
-            Shareable journal — safe to send
-          </CardTitle>
-        </CardHeader>
-        <CardContent className="flex flex-col gap-3">
-          <p className="text-sm text-muted-foreground">
-            A readable document of how you have been feeling, for a therapist, a
-            doctor, or someone you trust.
-          </p>
-          <ul className="list-inside list-disc space-y-0.5 text-xs text-muted-foreground">
-            <li>Your mood, day by day</li>
-            <li>What you wrote</li>
-            <li>What you tagged</li>
-          </ul>
-          <p className="text-xs text-muted-foreground">
-            It carries no places, no health readings, no cycle records and no
-            photos. It cannot be used to restore your account.
-          </p>
-          <Button
-            size="lg"
-            className="w-full"
-            disabled={extract.isPending}
-            onClick={() => extract.mutate()}
-          >
-            <Share2 className="mr-2 h-4 w-4" />
-            {extract.isPending
-              ? "Preparing journal…"
-              : "Download shareable journal (.md)"}
-          </Button>
-        </CardContent>
-      </Card>
-    </div>
-  )
-}
+export const Route = createFileRoute("/_auth/export")({})
diff --git a/spa/src/routes/_auth/import.lazy.tsx b/spa/src/routes/_auth/import.lazy.tsx
new file mode 100644
index 0000000..6ce4461
--- /dev/null
+++ b/spa/src/routes/_auth/import.lazy.tsx
@@ -0,0 +1,220 @@
+import { useState, useRef } from "react"
+import { createLazyFileRoute } from "@tanstack/react-router"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { useImport, useRestore } from "@/hooks/use-import-export"
+import { ImportWizard } from "@/components/import/import-wizard"
+import { WizardResult } from "@/components/import/wizard-result"
+import { Upload, FileUp } from "lucide-react"
+import type { ImportResultResponse, RestoreOutcomeResponse } from "@/api/schema"
+
+export const Route = createLazyFileRoute("/_auth/import")({
+  component: ImportPage,
+})
+
+type ImportSource = "daylio" | "kmood" | "csv"
+
+function ImportPage() {
+  const [source, setSource] = useState<ImportSource | null>(null)
+  const [file, setFile] = useState<File | null>(null)
+  const [result, setResult] = useState<ImportResultResponse | null>(null)
+  const [restored, setRestored] = useState<RestoreOutcomeResponse | null>(null)
+  const fileInputRef = useRef<HTMLInputElement>(null)
+  const importData = useImport()
+  const restoreBackup = useRestore()
+  const working = importData.isPending || restoreBackup.isPending
+
+  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const selected = e.target.files?.[0]
+    if (selected) {
+      setFile(selected)
+      setResult(null)
+      setRestored(null)
+    }
+  }
+
+  const handleImport = () => {
+    if (!file) return
+
+    if (source === "kmood") {
+      restoreBackup.mutate(file, { onSuccess: setRestored })
+      return
+    }
+
+    importData.mutate(file, { onSuccess: setResult })
+  }
+
+  return (
+    <div className="flex flex-col gap-6 py-6">
+      <h1 className="text-xl font-bold">Import data</h1>
+
+      {!source && (
+        <Card>
+          <CardHeader>
+            <CardTitle className="text-sm">Choose source</CardTitle>
+          </CardHeader>
+          <CardContent className="flex flex-col gap-2">
+            <SourceOption
+              label="Daylio"
+              description="Import from Daylio CSV export"
+              onClick={() => setSource("daylio")}
+            />
+            <SourceOption
+              label="k-mood backup"
+              description="Restore a complete backup, with everything in it"
+              onClick={() => setSource("kmood")}
+            />
+            <SourceOption
+              label="Generic CSV"
+              description="Import from any CSV/TSV with a mapping wizard"
+              onClick={() => setSource("csv")}
+            />
+          </CardContent>
+        </Card>
+      )}
+
+      {(source === "daylio" || source === "kmood") && !result && !restored && (
+        <Card>
+          <CardHeader>
+            <CardTitle className="text-sm">
+              {source === "daylio"
+                ? "Upload Daylio export"
+                : "Upload k-mood backup"}
+            </CardTitle>
+          </CardHeader>
+          <CardContent className="flex flex-col gap-4">
+            <p className="text-sm text-muted-foreground">
+              {source === "daylio"
+                ? "Export your data from Daylio (Settings → Export → CSV) and upload the file here. Daylio records the time you logged but not which timezone you were in, so times are read as your own — 8 PM in the file becomes 8 PM where you live. Set your timezone in settings first."
+                : "Upload a complete backup to restore it. Everything in it comes back: entries with every dimension, daily metrics, cycle records, activities, reminders and settings. A restore adds to this account rather than replacing it."}
+            </p>
+
+            <input
+              ref={fileInputRef}
+              type="file"
+              accept={source === "kmood" ? ".zip" : ".csv,.tsv,.txt"}
+              onChange={handleFileChange}
+              className="hidden"
+            />
+
+            <Button
+              variant="outline"
+              onClick={() => fileInputRef.current?.click()}
+              className="w-full"
+            >
+              <FileUp className="mr-2 h-4 w-4" />
+              {file ? file.name : "Choose file"}
+            </Button>
+
+            {file && (
+              <Button
+                size="lg"
+                onClick={handleImport}
+                disabled={working}
+                className="w-full"
+              >
+                {working ? (
+                  source === "kmood" ? (
+                    "Restoring..."
+                  ) : (
+                    "Importing..."
+                  )
+                ) : (
+                  <>
+                    <Upload className="mr-2 h-4 w-4" />
+                    {source === "kmood" ? "Restore" : "Import"}
+                  </>
+                )}
+              </Button>
+            )}
+          </CardContent>
+        </Card>
+      )}
+
+      {source === "csv" && !result && <ImportWizard />}
+
+      {result && <WizardResult result={result} />}
+
+      {restored && <RestoreSummary outcome={restored} />}
+
+      {source && !result && !restored && (
+        <Button
+          variant="ghost"
+          onClick={() => {
+            setSource(null)
+            setFile(null)
+          }}
+        >
+          ← Back to source selection
+        </Button>
+      )}
+    </div>
+  )
+}
+
+function SourceOption({
+  label,
+  description,
+  onClick,
+}: {
+  label: string
+  description: string
+  onClick: () => void
+}) {
+  return (
+    <Button
+      variant="ghost"
+      onClick={onClick}
+      className="flex h-auto flex-col items-start gap-0.5 p-4 text-left"
+    >
+      <span className="text-sm font-medium">{label}</span>
+      <span className="text-xs text-muted-foreground">{description}</span>
+    </Button>
+  )
+}
+
+function RestoreSummary({ outcome }: { outcome: RestoreOutcomeResponse }) {
+  const counts = [
+    ["Entries", outcome.entries],
+    ["Daily metrics", outcome.metrics],
+    ["Cycle records", outcome.cycleStarts],
+    ["Activities", outcome.activities],
+    ["Reminders", outcome.reminders],
+    ["Photos and voice memos", outcome.media],
+  ] as const
+
+  return (
+    <Card>
+      <CardHeader className="pb-2">
+        <CardTitle className="text-sm">Restored</CardTitle>
+      </CardHeader>
+      <CardContent className="flex flex-col gap-2">
+        {counts.map(([label, count]) => (
+          <div key={label} className="flex justify-between text-sm">
+            <span className="text-muted-foreground">{label}</span>
+            <span className="font-medium tabular-nums">{count}</span>
+          </div>
+        ))}
+
+        {outcome.skipped > 0 && (
+          <div className="mt-2 border-l-2 border-muted pl-2 text-xs text-muted-foreground">
+            {outcome.skipped} already in this account, so left as they were
+          </div>
+        )}
+
+        {outcome.unreadable.length > 0 && (
+          <div className="mt-2 flex flex-col gap-1 border-l-2 border-destructive/40 pl-2">
+            <span className="text-xs font-medium">
+              Could not be read, and was not restored:
+            </span>
+            {outcome.unreadable.map((reason) => (
+              <span key={reason} className="text-[10px] text-muted-foreground">
+                {reason}
+              </span>
+            ))}
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  )
+}
diff --git a/spa/src/routes/_auth/import.tsx b/spa/src/routes/_auth/import.tsx
index 39e6d0a..0d79ab5 100644
--- a/spa/src/routes/_auth/import.tsx
+++ b/spa/src/routes/_auth/import.tsx
@@ -1,214 +1,3 @@
-import { useState, useRef } from "react"
 import { createFileRoute } from "@tanstack/react-router"
-import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
-import { useImport, useRestore } from "@/hooks/use-import-export"
-import { ImportWizard } from "@/components/import/import-wizard"
-import { WizardResult } from "@/components/import/wizard-result"
-import { Upload, FileUp } from "lucide-react"
-import type { ImportResultResponse, RestoreOutcomeResponse } from "@/api/schema"
 
-export const Route = createFileRoute("/_auth/import")({
-  component: ImportPage,
-})
-
-type ImportSource = "daylio" | "kmood" | "csv"
-
-function ImportPage() {
-  const [source, setSource] = useState<ImportSource | null>(null)
-  const [file, setFile] = useState<File | null>(null)
-  const [result, setResult] = useState<ImportResultResponse | null>(null)
-  const [restored, setRestored] = useState<RestoreOutcomeResponse | null>(null)
-  const fileInputRef = useRef<HTMLInputElement>(null)
-  const importData = useImport()
-  const restoreBackup = useRestore()
-  const working = importData.isPending || restoreBackup.isPending
-
-  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
-    const selected = e.target.files?.[0]
-    if (selected) {
-      setFile(selected)
-      setResult(null)
-      setRestored(null)
-    }
-  }
-
-  const handleImport = () => {
-    if (!file) return
-
-    if (source === "kmood") {
-      restoreBackup.mutate(file, { onSuccess: setRestored })
-      return
-    }
-
-    importData.mutate(file, { onSuccess: setResult })
-  }
-
-  return (
-    <div className="flex flex-col gap-6 py-6">
-      <h1 className="text-xl font-bold">Import data</h1>
-
-      {!source && (
-        <Card>
-          <CardHeader>
-            <CardTitle className="text-sm">Choose source</CardTitle>
-          </CardHeader>
-          <CardContent className="flex flex-col gap-2">
-            <SourceOption
-              label="Daylio"
-              description="Import from Daylio CSV export"
-              onClick={() => setSource("daylio")}
-            />
-            <SourceOption
-              label="k-mood backup"
-              description="Restore a complete backup, with everything in it"
-              onClick={() => setSource("kmood")}
-            />
-            <SourceOption
-              label="Generic CSV"
-              description="Import from any CSV/TSV with a mapping wizard"
-              onClick={() => setSource("csv")}
-            />
-          </CardContent>
-        </Card>
-      )}
-
-      {(source === "daylio" || source === "kmood") && !result && !restored && (
-        <Card>
-          <CardHeader>
-            <CardTitle className="text-sm">
-              {source === "daylio"
-                ? "Upload Daylio export"
-                : "Upload k-mood backup"}
-            </CardTitle>
-          </CardHeader>
-          <CardContent className="flex flex-col gap-4">
-            <p className="text-sm text-muted-foreground">
-              {source === "daylio"
-                ? "Export your data from Daylio (Settings → Export → CSV) and upload the file here. Daylio records the time you logged but not which timezone you were in, so times are read as your own — 8 PM in the file becomes 8 PM where you live. Set your timezone in settings first."
-                : "Upload a complete backup to restore it. Everything in it comes back: entries with every dimension, daily metrics, cycle records, activities, reminders and settings. A restore adds to this account rather than replacing it."}
-            </p>
-
-            <input
-              ref={fileInputRef}
-              type="file"
-              accept={source === "kmood" ? ".zip" : ".csv,.tsv,.txt"}
-              onChange={handleFileChange}
-              className="hidden"
-            />
-
-            <Button
-              variant="outline"
-              onClick={() => fileInputRef.current?.click()}
-              className="w-full"
-            >
-              <FileUp className="mr-2 h-4 w-4" />
-              {file ? file.name : "Choose file"}
-            </Button>
-
-            {file && (
-              <Button
-                size="lg"
-                onClick={handleImport}
-                disabled={working}
-                className="w-full"
-              >
-                {working ? (
-                  source === "kmood" ? (
-                    "Restoring..."
-                  ) : (
-                    "Importing..."
-                  )
-                ) : (
-                  <>
-                    <Upload className="mr-2 h-4 w-4" />
-                    {source === "kmood" ? "Restore" : "Import"}
-                  </>
-                )}
-              </Button>
-            )}
-          </CardContent>
-        </Card>
-      )}
-
-      {source === "csv" && !result && <ImportWizard />}
-
-      {result && <WizardResult result={result} />}
-
-      {restored && <RestoreSummary outcome={restored} />}
-
-      {source && !result && !restored && (
-        <Button
-          variant="ghost"
-          onClick={() => {
-            setSource(null)
-            setFile(null)
-          }}
-        >
-          ← Back to source selection
-        </Button>
-      )}
-    </div>
-  )
-}
-
-function SourceOption({
-  label,
-  description,
-  onClick,
-}: {
-  label: string
-  description: string
-  onClick: () => void
-}) {
-  return (
-    <Button
-      variant="ghost"
-      onClick={onClick}
-      className="flex h-auto flex-col items-start gap-0.5 p-4 text-left"
-    >
-      <span className="text-sm font-medium">{label}</span>
-      <span className="text-xs text-muted-foreground">{description}</span>
-    </Button>
-  )
-}
-
-function RestoreSummary({ outcome }: { outcome: RestoreOutcomeResponse }) {
-  const counts = [
-    ["Entries", outcome.entries],
-    ["Daily metrics", outcome.metrics],
-    ["Cycle records", outcome.cycleStarts],
-    ["Activities", outcome.activities],
-    ["Reminders", outcome.reminders],
-    ["Photos and voice memos", outcome.media],
-  ] as const
-
-  return (
-    <Card>
-      <CardHeader className="pb-2">
-        <CardTitle className="text-sm">Restored</CardTitle>
-      </CardHeader>
-      <CardContent className="flex flex-col gap-2">
-        {counts.map(([label, count]) => (
-          <div key={label} className="flex justify-between text-sm">
-            <span className="text-muted-foreground">{label}</span>
-            <span className="font-medium tabular-nums">{count}</span>
-          </div>
-        ))}
-
-        {outcome.unreadable.length > 0 && (
-          <div className="mt-2 flex flex-col gap-1 border-l-2 border-destructive/40 pl-2">
-            <span className="text-xs font-medium">
-              Could not be read, and was not restored:
-            </span>
-            {outcome.unreadable.map((reason) => (
-              <span key={reason} className="text-[10px] text-muted-foreground">
-                {reason}
-              </span>
-            ))}
-          </div>
-        )}
-      </CardContent>
-    </Card>
-  )
-}
+export const Route = createFileRoute("/_auth/import")({})
diff --git a/spa/src/routes/_auth/index.tsx b/spa/src/routes/_auth/index.tsx
index 6019d35..5ce9a33 100644
--- a/spa/src/routes/_auth/index.tsx
+++ b/spa/src/routes/_auth/index.tsx
@@ -1,70 +1,52 @@
 import { createFileRoute, Link } from "@tanstack/react-router"
 import { format } from "date-fns"
 import { Card, CardContent } from "@/components/ui/card"
-import { Footprints } from "lucide-react"
-import { MoodBadge } from "@/components/mood/mood-badge"
-import { EntryList } from "@/components/entry/entry-list"
-import { useEntries, useMoodStats } from "@/hooks/use-entries"
-import { byKind, useDailyMetrics } from "@/hooks/use-metrics"
-import { useAuth } from "@/hooks/use-auth"
 import { Skeleton } from "@/components/ui/skeleton"
+import { EntryList } from "@/components/entry/entry-list"
+import { PendingEntries } from "@/components/entry/pending-entries"
+import { MoodSummary } from "@/components/stats/mood-summary"
+import { TodayCard } from "@/components/dashboard/today-card"
+import { MetricsCard } from "@/components/dashboard/metrics-card"
+import { SetupCard } from "@/components/dashboard/setup-card"
+import { useRecentEntries } from "@/hooks/use-entries"
+import { useMoodStats } from "@/hooks/use-stats"
+import { useAuth } from "@/hooks/use-auth"
 
 export const Route = createFileRoute("/_auth/")({ component: DashboardPage })
 
+const RECENT_SHOWN = 10
+
 function DashboardPage() {
   const { user } = useAuth()
-  const { data: entries, isLoading: entriesLoading } = useEntries({ limit: 10 })
-  const { data: stats, isLoading: statsLoading } = useMoodStats()
+  const { data: recent, isLoading: entriesLoading } =
+    useRecentEntries(RECENT_SHOWN)
+  const { data: stats, isLoading: statsLoading } = useMoodStats("all")
 
-  const today = format(new Date(), "EEEE, MMMM d")
-  const todaysDate = format(new Date(), "yyyy-MM-dd")
-  const { data: todaysMetrics } = useDailyMetrics(todaysDate, todaysDate)
-  const steps = byKind(todaysMetrics).get("steps")
-  const latestMood = entries?.[0]?.mood
+  const entries = recent?.items ?? []
 
   return (
     <div className="flex flex-col gap-6 py-6">
       <header>
-        <p className="text-sm text-muted-foreground">{today}</p>
+        <p className="text-sm text-muted-foreground">
+          {format(new Date(), "EEEE, MMMM d")}
+        </p>
         <h1 className="text-2xl font-bold">
           Hey{user ? `, ${user.displayName ?? user.username}` : ""}
         </h1>
       </header>
 
-      {latestMood && (
-        <Card>
-          <CardContent className="flex flex-col items-center gap-2 py-6">
-            <p className="text-sm text-muted-foreground">Current mood</p>
-            <MoodBadge value={latestMood} showLabel className="text-2xl" />
-          </CardContent>
-        </Card>
-      )}
+      <PendingEntries />
 
-      <Link to="/metrics">
-        <Card>
-          <CardContent className="flex items-center justify-between py-4">
-            <div className="flex items-center gap-2">
-              <Footprints className="h-4 w-4 text-muted-foreground" />
-              <span className="text-sm">Steps today</span>
-            </div>
-            <span className="text-sm font-semibold">
-              {steps ? steps.value.toLocaleString() : "Add"}
-            </span>
-          </CardContent>
-        </Card>
-      </Link>
+      <TodayCard latest={entries[0]} />
+
+      <MetricsCard />
+
+      {stats && <SetupCard totalEntries={stats.totalEntries} />}
 
       {statsLoading ? (
         <Skeleton className="h-24" />
       ) : stats ? (
-        <div className="grid grid-cols-3 gap-3">
-          <StatCard
-            label="Average"
-            value={stats.average ? stats.average.toFixed(1) : "—"}
-          />
-          <StatCard label="Streak" value={`${stats.currentStreak}d`} />
-          <StatCard label="Entries" value={String(stats.totalEntries)} />
-        </div>
+        <MoodSummary stats={stats} />
       ) : null}
 
       <section>
@@ -79,12 +61,12 @@ function DashboardPage() {
             <Skeleton className="h-20" />
             <Skeleton className="h-20" />
           </div>
-        ) : entries?.length ? (
-          <EntryList entries={entries} limit={10} />
+        ) : entries.length ? (
+          <EntryList entries={entries} />
         ) : (
           <Card>
             <CardContent className="py-8 text-center text-sm text-muted-foreground">
-              No entries yet. Tap + to log your first mood!
+              No entries yet. Tap ＋ to log your first mood.
             </CardContent>
           </Card>
         )}
@@ -92,14 +74,3 @@ function DashboardPage() {
     </div>
   )
 }
-
-function StatCard({ label, value }: { label: string; value: string }) {
-  return (
-    <Card>
-      <CardContent className="flex flex-col items-center py-4">
-        <span className="text-2xl font-bold">{value}</span>
-        <span className="text-xs text-muted-foreground">{label}</span>
-      </CardContent>
-    </Card>
-  )
-}
diff --git a/spa/src/routes/_auth/metrics.lazy.tsx b/spa/src/routes/_auth/metrics.lazy.tsx
new file mode 100644
index 0000000..b66172a
--- /dev/null
+++ b/spa/src/routes/_auth/metrics.lazy.tsx
@@ -0,0 +1,54 @@
+import { useState } from "react"
+import { createLazyFileRoute, useRouter } from "@tanstack/react-router"
+import { ArrowLeft } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Skeleton } from "@/components/ui/skeleton"
+import { DayStepper } from "@/components/metric/day-stepper"
+import { MetricsEditor } from "@/components/metric/metrics-editor"
+import { useDailyMetrics } from "@/hooks/use-metrics"
+import { today } from "@/lib/day"
+
+export const Route = createLazyFileRoute("/_auth/metrics")({
+  component: MetricsPage,
+})
+
+function MetricsPage() {
+  const router = useRouter()
+  const [date, setDate] = useState(today)
+
+  return (
+    <div className="flex flex-col gap-6 py-6">
+      <header className="flex items-center gap-2">
+        <Button
+          variant="ghost"
+          size="icon"
+          aria-label="Go back"
+          onClick={() => router.history.back()}
+        >
+          <ArrowLeft className="h-5 w-5" aria-hidden="true" />
+        </Button>
+        <h1 className="text-2xl font-bold">Daily metrics</h1>
+      </header>
+
+      <DayStepper value={date} onChange={setDate} />
+
+      <DayMetrics key={date} date={date} />
+    </div>
+  )
+}
+
+function DayMetrics({ date }: { date: string }) {
+  const { data: stored, isLoading } = useDailyMetrics(date, date)
+
+  if (isLoading || !stored) {
+    return (
+      <div className="flex flex-col gap-4">
+        <Skeleton className="h-14" />
+        <Skeleton className="h-14" />
+        <Skeleton className="h-14" />
+      </div>
+    )
+  }
+
+  return <MetricsEditor date={date} stored={stored} />
+}
diff --git a/spa/src/routes/_auth/metrics.tsx b/spa/src/routes/_auth/metrics.tsx
index 99d5b00..f3efb21 100644
--- a/spa/src/routes/_auth/metrics.tsx
+++ b/spa/src/routes/_auth/metrics.tsx
@@ -1,156 +1,3 @@
-import { useEffect, useState } from "react"
-import { createFileRoute, Link } from "@tanstack/react-router"
-import { format } from "date-fns"
-import { ArrowLeft } from "lucide-react"
-import { Button } from "@/components/ui/button"
-import { Card, CardContent } from "@/components/ui/card"
-import { Input } from "@/components/ui/input"
-import { Label } from "@/components/ui/label"
-import { Skeleton } from "@/components/ui/skeleton"
-import { METRIC_FIELDS } from "@/components/metric/metric-fields"
-import { MetricRow } from "@/components/metric/metric-row"
-import {
-  byKind,
-  useDailyMetrics,
-  useSetDailyMetrics,
-} from "@/hooks/use-metrics"
-import type { MetricKind, MetricPayload } from "@/api/schema"
+import { createFileRoute } from "@tanstack/react-router"
 
-export const Route = createFileRoute("/_auth/metrics")({
-  component: MetricsPage,
-})
-
-type Drafts = Record<string, string>
-
-function storedDrafts(stored: Map<MetricKind, { value: number }>): Drafts {
-  return Object.fromEntries(
-    METRIC_FIELDS.map((field) => [
-      field.kind,
-      stored.has(field.kind) ? String(stored.get(field.kind)?.value) : "",
-    ])
-  )
-}
-
-function saveLabel(changes: number, cleared: number): string {
-  if (changes === 0) return "Nothing to save"
-
-  const plural = changes === 1 ? "" : "s"
-  if (cleared === 0) return `Save ${changes} change${plural}`
-  if (cleared === changes)
-    return `Clear ${cleared} reading${cleared === 1 ? "" : "s"}`
-
-  return `Save ${changes} change${plural}, ${cleared} cleared`
-}
-
-function MetricsPage() {
-  const today = format(new Date(), "yyyy-MM-dd")
-  const [date, setDate] = useState(today)
-  const { data: stored, isLoading } = useDailyMetrics(date, date)
-  const save = useSetDailyMetrics()
-
-  const recorded = byKind(stored)
-  const [drafts, setDrafts] = useState<Drafts>({})
-  const [syncedFor, setSyncedFor] = useState<string | null>(null)
-
-  useEffect(() => {
-    if (!stored || syncedFor === date) return
-    setDrafts(storedDrafts(byKind(stored)))
-    setSyncedFor(date)
-  }, [stored, date, syncedFor])
-
-  const edited = METRIC_FIELDS.filter((field) => {
-    const draft = drafts[field.kind] ?? ""
-    const current = recorded.get(field.kind)
-    return draft !== (current ? String(current.value) : "")
-  })
-
-  const invalid = edited.filter((field) => {
-    const draft = drafts[field.kind] ?? ""
-    if (draft === "") return false
-
-    const count = Number(draft)
-    return !Number.isInteger(count) || count < field.min || count > field.max
-  })
-
-  const changes: MetricPayload[] = edited
-    .filter((field) => !invalid.includes(field))
-    .map((field) => ({
-      kind: field.kind,
-      value: drafts[field.kind] === "" ? null : Number(drafts[field.kind]),
-    }))
-
-  const cleared = changes.filter((change) => change.value === null).length
-
-  return (
-    <div className="flex flex-col gap-6 py-6">
-      <header className="flex items-center gap-2">
-        <Link to="/">
-          <Button variant="ghost" size="icon">
-            <ArrowLeft className="h-5 w-5" />
-          </Button>
-        </Link>
-        <h1 className="text-2xl font-bold">Daily metrics</h1>
-      </header>
-
-      <div className="flex flex-col gap-1.5">
-        <Label className="text-xs">Day</Label>
-        <Input
-          type="date"
-          value={date}
-          max={today}
-          onChange={(event) => setDate(event.target.value)}
-        />
-      </div>
-
-      <Card>
-        <CardContent className="flex flex-col gap-4 py-4">
-          {isLoading ? (
-            <>
-              <Skeleton className="h-14" />
-              <Skeleton className="h-14" />
-              <Skeleton className="h-14" />
-            </>
-          ) : (
-            METRIC_FIELDS.map((field) => (
-              <MetricRow
-                key={field.kind}
-                field={field}
-                stored={recorded.get(field.kind)}
-                draft={drafts[field.kind] ?? ""}
-                onChange={(draft) =>
-                  setDrafts((current) => ({ ...current, [field.kind]: draft }))
-                }
-              />
-            ))
-          )}
-        </CardContent>
-      </Card>
-
-      {invalid.length > 0 && (
-        <p className="text-xs text-destructive">
-          {invalid.map((field) => field.label).join(", ")}:{" "}
-          {invalid.length === 1 ? "value is" : "values are"} outside the allowed
-          range.
-        </p>
-      )}
-
-      <Button
-        disabled={changes.length === 0 || save.isPending}
-        onClick={() =>
-          save.mutate(
-            { date, values: changes },
-            { onSuccess: () => setSyncedFor(null) }
-          )
-        }
-      >
-        {save.isPending ? "Saving…" : saveLabel(changes.length, cleared)}
-      </Button>
-
-      {save.isError && (
-        <p className="text-xs text-destructive">
-          {save.error instanceof Error ? save.error.message : "Could not save"}
-        </p>
-      )}
-    </div>
-  )
-}
+export const Route = createFileRoute("/_auth/metrics")({})
diff --git a/spa/src/routes/_auth/reminders.lazy.tsx b/spa/src/routes/_auth/reminders.lazy.tsx
new file mode 100644
index 0000000..70be077
--- /dev/null
+++ b/spa/src/routes/_auth/reminders.lazy.tsx
@@ -0,0 +1,322 @@
+import { useState } from "react"
+import { createLazyFileRoute, Link } from "@tanstack/react-router"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Switch } from "@/components/ui/switch"
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+} from "@/components/ui/alert-dialog"
+import {
+  useReminders,
+  useCreateReminder,
+  useUpdateReminder,
+  useDeleteReminder,
+} from "@/hooks/use-reminders"
+import type { ReminderResponse, CreateReminderRequest } from "@/api/schema"
+import { Plus, Trash2, ArrowLeft } from "lucide-react"
+
+export const Route = createLazyFileRoute("/_auth/reminders")({
+  component: RemindersPage,
+})
+
+const DAYS = [
+  { key: "monday", label: "Mon" },
+  { key: "tuesday", label: "Tue" },
+  { key: "wednesday", label: "Wed" },
+  { key: "thursday", label: "Thu" },
+  { key: "friday", label: "Fri" },
+  { key: "saturday", label: "Sat" },
+  { key: "sunday", label: "Sun" },
+] as const
+
+type DayKey = (typeof DAYS)[number]["key"]
+
+function RemindersPage() {
+  const { data: reminders, isLoading } = useReminders()
+  const createReminder = useCreateReminder()
+  const [showForm, setShowForm] = useState(false)
+
+  const handleCreate = (schedule: CreateReminderRequest) => {
+    createReminder.mutate(schedule, {
+      onSuccess: () => setShowForm(false),
+    })
+  }
+
+  return (
+    <div className="flex flex-col gap-6 py-6">
+      <div className="flex items-center gap-3">
+        <Link to="/settings">
+          <Button variant="ghost" size="icon">
+            <ArrowLeft className="h-5 w-5" />
+          </Button>
+        </Link>
+        <h1 className="text-xl font-bold">Reminders</h1>
+      </div>
+
+      {isLoading && <p className="text-sm text-muted-foreground">Loading...</p>}
+
+      {reminders?.map((reminder) => (
+        <ReminderCard key={reminder.id} reminder={reminder} />
+      ))}
+
+      {reminders?.length === 0 && !showForm && (
+        <p className="text-center text-sm text-muted-foreground">
+          No reminders yet. Create one to get notified.
+        </p>
+      )}
+
+      {showForm ? (
+        <ReminderForm
+          onSave={handleCreate}
+          onCancel={() => setShowForm(false)}
+          isPending={createReminder.isPending}
+        />
+      ) : (
+        <Button onClick={() => setShowForm(true)}>
+          <Plus className="mr-2 h-4 w-4" />
+          Add reminder
+        </Button>
+      )}
+    </div>
+  )
+}
+
+function ReminderCard({ reminder }: { reminder: ReminderResponse }) {
+  const updateReminder = useUpdateReminder()
+  const deleteReminder = useDeleteReminder()
+  const [editing, setEditing] = useState(false)
+
+  const handleToggle = (enabled: boolean) => {
+    updateReminder.mutate({ id: reminder.id, body: { enabled } })
+  }
+
+  const handleUpdate = (schedule: CreateReminderRequest) => {
+    updateReminder.mutate(
+      { id: reminder.id, body: { schedule } },
+      { onSuccess: () => setEditing(false) }
+    )
+  }
+
+  if (editing) {
+    return (
+      <ReminderForm
+        initial={reminder.schedule}
+        onSave={handleUpdate}
+        onCancel={() => setEditing(false)}
+        isPending={updateReminder.isPending}
+      />
+    )
+  }
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-center justify-between pb-2">
+        <CardTitle className="text-sm">
+          {reminder.enabled ? "Active" : "Disabled"}
+        </CardTitle>
+        <Switch
+          checked={reminder.enabled}
+          onCheckedChange={handleToggle}
+          disabled={updateReminder.isPending}
+        />
+      </CardHeader>
+      <CardContent className="flex flex-col gap-3">
+        <div className="flex flex-wrap gap-2">
+          {DAYS.map(({ key, label }) => {
+            const time = reminder.schedule[key]
+            return <DayPill key={key} label={label} time={time} />
+          })}
+        </div>
+
+        <div className="flex gap-2">
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => setEditing(true)}
+            className="flex-1"
+          >
+            Edit
+          </Button>
+          <AlertDialog>
+            <AlertDialogTrigger
+              render={
+                <Button
+                  variant="outline"
+                  size="sm"
+                  className="text-destructive"
+                />
+              }
+            >
+              <Trash2 className="h-4 w-4" />
+            </AlertDialogTrigger>
+            <AlertDialogContent>
+              <AlertDialogHeader>
+                <AlertDialogTitle>Delete reminder?</AlertDialogTitle>
+                <AlertDialogDescription>
+                  This reminder will be permanently removed.
+                </AlertDialogDescription>
+              </AlertDialogHeader>
+              <AlertDialogFooter>
+                <AlertDialogCancel>Cancel</AlertDialogCancel>
+                <AlertDialogAction
+                  onClick={(e) => {
+                    e.preventDefault()
+                    deleteReminder.mutate(reminder.id)
+                  }}
+                >
+                  Delete
+                </AlertDialogAction>
+              </AlertDialogFooter>
+            </AlertDialogContent>
+          </AlertDialog>
+        </div>
+      </CardContent>
+    </Card>
+  )
+}
+
+function DayPill({ label, time }: { label: string; time: string | null }) {
+  return (
+    <div
+      className={`flex flex-col items-center rounded-lg border px-3 py-2 text-xs ${
+        time
+          ? "border-primary/30 bg-primary/10 text-foreground"
+          : "border-transparent bg-muted/50 text-muted-foreground"
+      }`}
+    >
+      <span className="font-medium">{label}</span>
+      <span>{time ? formatTime(time) : "—"}</span>
+    </div>
+  )
+}
+
+function formatTime(time: string): string {
+  const [h, m] = time.split(":")
+  const hour = parseInt(h)
+  const ampm = hour >= 12 ? "PM" : "AM"
+  const h12 = hour % 12 || 12
+  return `${h12}:${m} ${ampm}`
+}
+
+function ReminderForm({
+  initial,
+  onSave,
+  onCancel,
+  isPending,
+}: {
+  initial?: Record<DayKey, string | null>
+  onSave: (schedule: CreateReminderRequest) => void
+  onCancel: () => void
+  isPending: boolean
+}) {
+  const defaultTime = "20:00"
+  const [schedule, setSchedule] = useState<Record<DayKey, string | null>>(
+    () => {
+      if (initial) return { ...initial }
+      return {
+        monday: null,
+        tuesday: null,
+        wednesday: null,
+        thursday: null,
+        friday: null,
+        saturday: null,
+        sunday: null,
+      }
+    }
+  )
+
+  const toggleDay = (day: DayKey) => {
+    setSchedule((prev) => ({
+      ...prev,
+      [day]: prev[day] ? null : defaultTime,
+    }))
+  }
+
+  const setTime = (day: DayKey, time: string) => {
+    setSchedule((prev) => ({ ...prev, [day]: time }))
+  }
+
+  const selectAll = () => {
+    const allSet = DAYS.every(({ key }) => schedule[key])
+    const newSchedule = { ...schedule }
+    for (const { key } of DAYS) {
+      newSchedule[key] = allSet ? null : defaultTime
+    }
+    setSchedule(newSchedule)
+  }
+
+  const hasAnyDay = DAYS.some(({ key }) => schedule[key])
+
+  return (
+    <Card>
+      <CardHeader className="pb-2">
+        <CardTitle className="text-sm">
+          {initial ? "Edit reminder" : "New reminder"}
+        </CardTitle>
+      </CardHeader>
+      <CardContent className="flex flex-col gap-4">
+        <div className="flex items-center justify-between">
+          <span className="text-xs text-muted-foreground">Select days</span>
+          <Button
+            variant="ghost"
+            size="sm"
+            onClick={selectAll}
+            className="text-xs"
+          >
+            {DAYS.every(({ key }) => schedule[key]) ? "Clear all" : "Every day"}
+          </Button>
+        </div>
+
+        <div className="flex flex-col gap-2">
+          {DAYS.map(({ key, label }) => (
+            <div key={key} className="flex items-center justify-between gap-3">
+              <button
+                type="button"
+                onClick={() => toggleDay(key)}
+                className={`w-12 rounded-md py-1.5 text-center text-xs font-medium transition-colors ${
+                  schedule[key]
+                    ? "bg-primary text-primary-foreground"
+                    : "bg-muted text-muted-foreground"
+                }`}
+              >
+                {label}
+              </button>
+              {schedule[key] && (
+                <input
+                  type="time"
+                  value={schedule[key]}
+                  onChange={(e) => setTime(key, e.target.value)}
+                  className="h-9 rounded-md border bg-transparent px-3 text-sm"
+                />
+              )}
+              {!schedule[key] && (
+                <span className="text-xs text-muted-foreground">Off</span>
+              )}
+            </div>
+          ))}
+        </div>
+
+        <div className="flex gap-2">
+          <Button variant="outline" onClick={onCancel} className="flex-1">
+            Cancel
+          </Button>
+          <Button
+            onClick={() => onSave(schedule)}
+            disabled={!hasAnyDay || isPending}
+            className="flex-1"
+          >
+            {isPending ? "Saving..." : "Save"}
+          </Button>
+        </div>
+      </CardContent>
+    </Card>
+  )
+}
diff --git a/spa/src/routes/_auth/reminders.tsx b/spa/src/routes/_auth/reminders.tsx
index cdc8d93..bd1e6b0 100644
--- a/spa/src/routes/_auth/reminders.tsx
+++ b/spa/src/routes/_auth/reminders.tsx
@@ -1,322 +1,3 @@
-import { useState } from "react"
-import { createFileRoute, Link } from "@tanstack/react-router"
-import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
-import { Switch } from "@/components/ui/switch"
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-  AlertDialogTrigger,
-} from "@/components/ui/alert-dialog"
-import {
-  useReminders,
-  useCreateReminder,
-  useUpdateReminder,
-  useDeleteReminder,
-} from "@/hooks/use-reminders"
-import type { ReminderResponse, CreateReminderRequest } from "@/api/schema"
-import { Plus, Trash2, ArrowLeft } from "lucide-react"
+import { createFileRoute } from "@tanstack/react-router"
 
-export const Route = createFileRoute("/_auth/reminders")({
-  component: RemindersPage,
-})
-
-const DAYS = [
-  { key: "monday", label: "Mon" },
-  { key: "tuesday", label: "Tue" },
-  { key: "wednesday", label: "Wed" },
-  { key: "thursday", label: "Thu" },
-  { key: "friday", label: "Fri" },
-  { key: "saturday", label: "Sat" },
-  { key: "sunday", label: "Sun" },
-] as const
-
-type DayKey = (typeof DAYS)[number]["key"]
-
-function RemindersPage() {
-  const { data: reminders, isLoading } = useReminders()
-  const createReminder = useCreateReminder()
-  const [showForm, setShowForm] = useState(false)
-
-  const handleCreate = (schedule: CreateReminderRequest) => {
-    createReminder.mutate(schedule, {
-      onSuccess: () => setShowForm(false),
-    })
-  }
-
-  return (
-    <div className="flex flex-col gap-6 py-6">
-      <div className="flex items-center gap-3">
-        <Link to="/settings">
-          <Button variant="ghost" size="icon">
-            <ArrowLeft className="h-5 w-5" />
-          </Button>
-        </Link>
-        <h1 className="text-xl font-bold">Reminders</h1>
-      </div>
-
-      {isLoading && <p className="text-sm text-muted-foreground">Loading...</p>}
-
-      {reminders?.map((reminder) => (
-        <ReminderCard key={reminder.id} reminder={reminder} />
-      ))}
-
-      {reminders?.length === 0 && !showForm && (
-        <p className="text-center text-sm text-muted-foreground">
-          No reminders yet. Create one to get notified.
-        </p>
-      )}
-
-      {showForm ? (
-        <ReminderForm
-          onSave={handleCreate}
-          onCancel={() => setShowForm(false)}
-          isPending={createReminder.isPending}
-        />
-      ) : (
-        <Button onClick={() => setShowForm(true)}>
-          <Plus className="mr-2 h-4 w-4" />
-          Add reminder
-        </Button>
-      )}
-    </div>
-  )
-}
-
-function ReminderCard({ reminder }: { reminder: ReminderResponse }) {
-  const updateReminder = useUpdateReminder()
-  const deleteReminder = useDeleteReminder()
-  const [editing, setEditing] = useState(false)
-
-  const handleToggle = (enabled: boolean) => {
-    updateReminder.mutate({ id: reminder.id, body: { enabled } })
-  }
-
-  const handleUpdate = (schedule: CreateReminderRequest) => {
-    updateReminder.mutate(
-      { id: reminder.id, body: { schedule } },
-      { onSuccess: () => setEditing(false) }
-    )
-  }
-
-  if (editing) {
-    return (
-      <ReminderForm
-        initial={reminder.schedule}
-        onSave={handleUpdate}
-        onCancel={() => setEditing(false)}
-        isPending={updateReminder.isPending}
-      />
-    )
-  }
-
-  return (
-    <Card>
-      <CardHeader className="flex flex-row items-center justify-between pb-2">
-        <CardTitle className="text-sm">
-          {reminder.enabled ? "Active" : "Disabled"}
-        </CardTitle>
-        <Switch
-          checked={reminder.enabled}
-          onCheckedChange={handleToggle}
-          disabled={updateReminder.isPending}
-        />
-      </CardHeader>
-      <CardContent className="flex flex-col gap-3">
-        <div className="flex flex-wrap gap-2">
-          {DAYS.map(({ key, label }) => {
-            const time = reminder.schedule[key]
-            return <DayPill key={key} label={label} time={time} />
-          })}
-        </div>
-
-        <div className="flex gap-2">
-          <Button
-            variant="outline"
-            size="sm"
-            onClick={() => setEditing(true)}
-            className="flex-1"
-          >
-            Edit
-          </Button>
-          <AlertDialog>
-            <AlertDialogTrigger
-              render={
-                <Button
-                  variant="outline"
-                  size="sm"
-                  className="text-destructive"
-                />
-              }
-            >
-              <Trash2 className="h-4 w-4" />
-            </AlertDialogTrigger>
-            <AlertDialogContent>
-              <AlertDialogHeader>
-                <AlertDialogTitle>Delete reminder?</AlertDialogTitle>
-                <AlertDialogDescription>
-                  This reminder will be permanently removed.
-                </AlertDialogDescription>
-              </AlertDialogHeader>
-              <AlertDialogFooter>
-                <AlertDialogCancel>Cancel</AlertDialogCancel>
-                <AlertDialogAction
-                  onClick={(e) => {
-                    e.preventDefault()
-                    deleteReminder.mutate(reminder.id)
-                  }}
-                >
-                  Delete
-                </AlertDialogAction>
-              </AlertDialogFooter>
-            </AlertDialogContent>
-          </AlertDialog>
-        </div>
-      </CardContent>
-    </Card>
-  )
-}
-
-function DayPill({ label, time }: { label: string; time: string | null }) {
-  return (
-    <div
-      className={`flex flex-col items-center rounded-lg border px-3 py-2 text-xs ${
-        time
-          ? "border-primary/30 bg-primary/10 text-foreground"
-          : "border-transparent bg-muted/50 text-muted-foreground"
-      }`}
-    >
-      <span className="font-medium">{label}</span>
-      <span>{time ? formatTime(time) : "—"}</span>
-    </div>
-  )
-}
-
-function formatTime(time: string): string {
-  const [h, m] = time.split(":")
-  const hour = parseInt(h)
-  const ampm = hour >= 12 ? "PM" : "AM"
-  const h12 = hour % 12 || 12
-  return `${h12}:${m} ${ampm}`
-}
-
-function ReminderForm({
-  initial,
-  onSave,
-  onCancel,
-  isPending,
-}: {
-  initial?: Record<DayKey, string | null>
-  onSave: (schedule: CreateReminderRequest) => void
-  onCancel: () => void
-  isPending: boolean
-}) {
-  const defaultTime = "20:00"
-  const [schedule, setSchedule] = useState<Record<DayKey, string | null>>(
-    () => {
-      if (initial) return { ...initial }
-      return {
-        monday: null,
-        tuesday: null,
-        wednesday: null,
-        thursday: null,
-        friday: null,
-        saturday: null,
-        sunday: null,
-      }
-    }
-  )
-
-  const toggleDay = (day: DayKey) => {
-    setSchedule((prev) => ({
-      ...prev,
-      [day]: prev[day] ? null : defaultTime,
-    }))
-  }
-
-  const setTime = (day: DayKey, time: string) => {
-    setSchedule((prev) => ({ ...prev, [day]: time }))
-  }
-
-  const selectAll = () => {
-    const allSet = DAYS.every(({ key }) => schedule[key])
-    const newSchedule = { ...schedule }
-    for (const { key } of DAYS) {
-      newSchedule[key] = allSet ? null : defaultTime
-    }
-    setSchedule(newSchedule)
-  }
-
-  const hasAnyDay = DAYS.some(({ key }) => schedule[key])
-
-  return (
-    <Card>
-      <CardHeader className="pb-2">
-        <CardTitle className="text-sm">
-          {initial ? "Edit reminder" : "New reminder"}
-        </CardTitle>
-      </CardHeader>
-      <CardContent className="flex flex-col gap-4">
-        <div className="flex items-center justify-between">
-          <span className="text-xs text-muted-foreground">Select days</span>
-          <Button
-            variant="ghost"
-            size="sm"
-            onClick={selectAll}
-            className="text-xs"
-          >
-            {DAYS.every(({ key }) => schedule[key]) ? "Clear all" : "Every day"}
-          </Button>
-        </div>
-
-        <div className="flex flex-col gap-2">
-          {DAYS.map(({ key, label }) => (
-            <div key={key} className="flex items-center justify-between gap-3">
-              <button
-                type="button"
-                onClick={() => toggleDay(key)}
-                className={`w-12 rounded-md py-1.5 text-center text-xs font-medium transition-colors ${
-                  schedule[key]
-                    ? "bg-primary text-primary-foreground"
-                    : "bg-muted text-muted-foreground"
-                }`}
-              >
-                {label}
-              </button>
-              {schedule[key] && (
-                <input
-                  type="time"
-                  value={schedule[key]}
-                  onChange={(e) => setTime(key, e.target.value)}
-                  className="h-9 rounded-md border bg-transparent px-3 text-sm"
-                />
-              )}
-              {!schedule[key] && (
-                <span className="text-xs text-muted-foreground">Off</span>
-              )}
-            </div>
-          ))}
-        </div>
-
-        <div className="flex gap-2">
-          <Button variant="outline" onClick={onCancel} className="flex-1">
-            Cancel
-          </Button>
-          <Button
-            onClick={() => onSave(schedule)}
-            disabled={!hasAnyDay || isPending}
-            className="flex-1"
-          >
-            {isPending ? "Saving..." : "Save"}
-          </Button>
-        </div>
-      </CardContent>
-    </Card>
-  )
-}
+export const Route = createFileRoute("/_auth/reminders")({})
diff --git a/spa/src/routes/_auth/settings.lazy.tsx b/spa/src/routes/_auth/settings.lazy.tsx
new file mode 100644
index 0000000..ce7c358
--- /dev/null
+++ b/spa/src/routes/_auth/settings.lazy.tsx
@@ -0,0 +1,562 @@
+import { useState } from "react"
+import { createLazyFileRoute, Link } from "@tanstack/react-router"
+import { useMutation, useQueryClient } from "@tanstack/react-query"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { SubsonicCard } from "@/components/settings/subsonic-card"
+import { ApiTokensCard } from "@/components/settings/api-tokens-card"
+import { ServerCard } from "@/components/settings/server-card"
+import { RejectionsCard } from "@/components/settings/rejections-card"
+import { CycleCard } from "@/components/settings/cycle-card"
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+} from "@/components/ui/alert-dialog"
+import { useAuth, useLogout } from "@/hooks/use-auth"
+import { usePushNotifications } from "@/hooks/use-push"
+import { users, entries } from "@/api/client"
+import { forgetSession } from "@/api/session"
+import { toast } from "@/components/ui/toast"
+import {
+  Bell,
+  CalendarMinus,
+  Clock,
+  Download,
+  ListChecks,
+  LogOut,
+  Pencil,
+  Trash2,
+  Upload,
+  ChevronRight,
+} from "lucide-react"
+
+export const Route = createLazyFileRoute("/_auth/settings")({
+  component: SettingsPage,
+})
+
+function SettingsPage() {
+  const { user } = useAuth()
+  const logout = useLogout()
+  const pushNotifications = usePushNotifications()
+  const queryClient = useQueryClient()
+  const [dialogOpen, setDialogOpen] = useState(false)
+  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false)
+
+  const clearData = useMutation({
+    mutationFn: () => users.clearData(),
+    onSuccess: () => {
+      queryClient.invalidateQueries()
+      setDialogOpen(false)
+      toast.add({ title: "All data cleared", type: "success" })
+    },
+    onError: () => {
+      toast.add({ title: "Failed to clear data", type: "error" })
+    },
+  })
+
+  const deleteAccount = useMutation({
+    mutationFn: () => users.deleteAccount(),
+    onSuccess: () => {
+      forgetSession()
+      queryClient.clear()
+      window.location.href = "/login"
+    },
+    onError: () => {
+      toast.add({ title: "Failed to delete account", type: "error" })
+    },
+  })
+
+  return (
+    <div className="flex flex-col gap-6 py-6">
+      <h1 className="text-xl font-bold">Settings</h1>
+
+      <ProfileCard
+        username={user?.username ?? ""}
+        email={user?.email ?? ""}
+        displayName={user?.displayName ?? null}
+        timezone={user?.timezone ?? null}
+      />
+
+      <SubsonicCard />
+
+      <CycleCard />
+
+      <ApiTokensCard />
+
+      <ServerCard />
+
+      <RejectionsCard />
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-sm">Personalization</CardTitle>
+        </CardHeader>
+        <CardContent className="flex flex-col gap-1 p-0">
+          <Link to="/activities">
+            <SettingsRow
+              icon={<ListChecks className="h-4 w-4" />}
+              label="Manage activities"
+            />
+          </Link>
+          {pushNotifications.isSupported && pushNotifications.hasVapidKey && (
+            <Link to="/reminders">
+              <SettingsRow
+                icon={<Clock className="h-4 w-4" />}
+                label="Reminders"
+              />
+            </Link>
+          )}
+        </CardContent>
+      </Card>
+
+      {pushNotifications.isSupported && pushNotifications.hasVapidKey && (
+        <Card>
+          <CardHeader>
+            <CardTitle className="text-sm">Notifications</CardTitle>
+          </CardHeader>
+          <CardContent className="flex flex-col gap-2">
+            <div className="flex items-center justify-between">
+              <div className="flex items-center gap-3">
+                <Bell className="h-4 w-4 text-muted-foreground" />
+                <span className="text-sm">Push notifications</span>
+              </div>
+              <Button
+                variant={pushNotifications.isSubscribed ? "outline" : "default"}
+                size="sm"
+                onClick={pushNotifications.toggle}
+                disabled={pushNotifications.isLoading}
+              >
+                {pushNotifications.isLoading
+                  ? "..."
+                  : pushNotifications.isSubscribed
+                    ? "Disable"
+                    : "Enable"}
+              </Button>
+            </div>
+            {pushNotifications.isSubscribed && (
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={pushNotifications.sendTest}
+                disabled={pushNotifications.isTesting}
+              >
+                {pushNotifications.isTesting
+                  ? "Sending..."
+                  : "Send test notification"}
+              </Button>
+            )}
+          </CardContent>
+        </Card>
+      )}
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-sm">Data</CardTitle>
+        </CardHeader>
+        <CardContent className="flex flex-col gap-1 p-0">
+          <Link to="/export">
+            <SettingsRow
+              icon={<Download className="h-4 w-4" />}
+              label="Export data"
+            />
+          </Link>
+          <Link to="/import">
+            <SettingsRow
+              icon={<Upload className="h-4 w-4" />}
+              label="Import data"
+            />
+          </Link>
+        </CardContent>
+      </Card>
+
+      <ChangePasswordCard />
+
+      <BulkDeleteCard />
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-sm">Danger zone</CardTitle>
+        </CardHeader>
+        <CardContent className="flex flex-col gap-2">
+          <AlertDialog open={dialogOpen} onOpenChange={setDialogOpen}>
+            <AlertDialogTrigger
+              render={
+                <Button
+                  variant="outline"
+                  className="w-full border-destructive/50 text-destructive"
+                />
+              }
+            >
+              <Trash2 className="mr-2 h-4 w-4" />
+              Clear all data
+            </AlertDialogTrigger>
+            <AlertDialogContent>
+              <AlertDialogHeader>
+                <AlertDialogTitle>Clear all data?</AlertDialogTitle>
+                <AlertDialogDescription>
+                  This will permanently delete all your mood entries,
+                  activities, and reminders. Your account will remain. This
+                  cannot be undone.
+                </AlertDialogDescription>
+              </AlertDialogHeader>
+              <AlertDialogFooter>
+                <AlertDialogCancel>Cancel</AlertDialogCancel>
+                <AlertDialogAction
+                  onClick={(e) => {
+                    e.preventDefault()
+                    clearData.mutate()
+                  }}
+                >
+                  {clearData.isPending ? "Deleting..." : "Delete everything"}
+                </AlertDialogAction>
+              </AlertDialogFooter>
+            </AlertDialogContent>
+          </AlertDialog>
+
+          <AlertDialog
+            open={deleteDialogOpen}
+            onOpenChange={setDeleteDialogOpen}
+          >
+            <AlertDialogTrigger
+              render={<Button variant="destructive" className="w-full" />}
+            >
+              <Trash2 className="mr-2 h-4 w-4" />
+              Delete account
+            </AlertDialogTrigger>
+            <AlertDialogContent>
+              <AlertDialogHeader>
+                <AlertDialogTitle>Delete your account?</AlertDialogTitle>
+                <AlertDialogDescription>
+                  This will permanently delete your account and all associated
+                  data including entries, activities, photos, and voice memos.
+                  This cannot be undone.
+                </AlertDialogDescription>
+              </AlertDialogHeader>
+              <AlertDialogFooter>
+                <AlertDialogCancel>Cancel</AlertDialogCancel>
+                <AlertDialogAction
+                  onClick={(e) => {
+                    e.preventDefault()
+                    deleteAccount.mutate()
+                  }}
+                >
+                  {deleteAccount.isPending
+                    ? "Deleting..."
+                    : "Delete my account"}
+                </AlertDialogAction>
+              </AlertDialogFooter>
+            </AlertDialogContent>
+          </AlertDialog>
+        </CardContent>
+      </Card>
+
+      <Button
+        variant="destructive"
+        onClick={() => logout.mutate()}
+        disabled={logout.isPending}
+        className="w-full"
+      >
+        <LogOut className="mr-2 h-4 w-4" />
+        {logout.isPending ? "Signing out..." : "Sign out"}
+      </Button>
+    </div>
+  )
+}
+
+function ProfileCard({
+  username,
+  email,
+  displayName,
+  timezone,
+}: {
+  username: string
+  email: string
+  displayName: string | null
+  timezone: string | null
+}) {
+  const queryClient = useQueryClient()
+  const [editing, setEditing] = useState(false)
+  const [name, setName] = useState(displayName ?? "")
+  const [tz, setTz] = useState(timezone ?? "")
+
+  const updateProfile = useMutation({
+    mutationFn: () =>
+      users.updateProfile({
+        displayName: name || null,
+        timezone: tz || null,
+      }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["auth"] })
+      setEditing(false)
+      toast.add({ title: "Profile updated", type: "success" })
+    },
+  })
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-center justify-between">
+        <CardTitle className="text-sm">Account</CardTitle>
+        {!editing && (
+          <Button
+            variant="ghost"
+            size="sm"
+            onClick={() => {
+              setName(displayName ?? "")
+              setTz(timezone ?? "")
+              setEditing(true)
+            }}
+          >
+            <Pencil className="mr-1 h-3 w-3" />
+            Edit
+          </Button>
+        )}
+      </CardHeader>
+      <CardContent className="flex flex-col gap-3 text-sm">
+        <div className="flex justify-between">
+          <span className="text-muted-foreground">Username</span>
+          <span>{username}</span>
+        </div>
+        <div className="flex justify-between">
+          <span className="text-muted-foreground">Email</span>
+          <span>{email}</span>
+        </div>
+
+        {editing ? (
+          <>
+            <div className="flex flex-col gap-1.5">
+              <Label className="text-xs">Display name</Label>
+              <Input
+                value={name}
+                onChange={(e) => setName(e.target.value)}
+                placeholder="Your name"
+              />
+            </div>
+            <div className="flex flex-col gap-1.5">
+              <Label className="text-xs">Timezone</Label>
+              <Input
+                value={tz}
+                onChange={(e) => setTz(e.target.value)}
+                placeholder="e.g. Europe/Warsaw"
+              />
+              <p className="text-xs text-muted-foreground">
+                Required for reminders to fire at the correct time
+              </p>
+            </div>
+            <div className="flex gap-2">
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => setEditing(false)}
+                className="flex-1"
+              >
+                Cancel
+              </Button>
+              <Button
+                size="sm"
+                onClick={() => updateProfile.mutate()}
+                disabled={updateProfile.isPending}
+                className="flex-1"
+              >
+                {updateProfile.isPending ? "Saving..." : "Save"}
+              </Button>
+            </div>
+          </>
+        ) : (
+          <>
+            <div className="flex justify-between">
+              <span className="text-muted-foreground">Display name</span>
+              <span>{displayName ?? "—"}</span>
+            </div>
+            <div className="flex justify-between">
+              <span className="text-muted-foreground">Timezone</span>
+              <span>{timezone ?? "—"}</span>
+            </div>
+          </>
+        )}
+      </CardContent>
+    </Card>
+  )
+}
+
+function ChangePasswordCard() {
+  const [open, setOpen] = useState(false)
+  const [currentPassword, setCurrentPassword] = useState("")
+  const [newPassword, setNewPassword] = useState("")
+
+  const changePassword = useMutation({
+    mutationFn: () => users.changePassword({ currentPassword, newPassword }),
+    onSuccess: () => {
+      setOpen(false)
+      setCurrentPassword("")
+      setNewPassword("")
+      toast.add({ title: "Password changed", type: "success" })
+    },
+  })
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-center justify-between">
+        <CardTitle className="text-sm">Security</CardTitle>
+        {!open && (
+          <Button variant="ghost" size="sm" onClick={() => setOpen(true)}>
+            Change password
+          </Button>
+        )}
+      </CardHeader>
+      {open && (
+        <CardContent className="flex flex-col gap-3">
+          <div className="flex flex-col gap-1.5">
+            <Label className="text-xs">Current password</Label>
+            <Input
+              type="password"
+              value={currentPassword}
+              onChange={(e) => setCurrentPassword(e.target.value)}
+            />
+          </div>
+          <div className="flex flex-col gap-1.5">
+            <Label className="text-xs">New password</Label>
+            <Input
+              type="password"
+              value={newPassword}
+              onChange={(e) => setNewPassword(e.target.value)}
+            />
+          </div>
+          <div className="flex gap-2">
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => {
+                setOpen(false)
+                setCurrentPassword("")
+                setNewPassword("")
+              }}
+              className="flex-1"
+            >
+              Cancel
+            </Button>
+            <Button
+              size="sm"
+              onClick={() => changePassword.mutate()}
+              disabled={
+                changePassword.isPending || !currentPassword || !newPassword
+              }
+              className="flex-1"
+            >
+              {changePassword.isPending ? "Changing..." : "Change password"}
+            </Button>
+          </div>
+        </CardContent>
+      )}
+    </Card>
+  )
+}
+
+function BulkDeleteCard() {
+  const queryClient = useQueryClient()
+  const [open, setOpen] = useState(false)
+  const [from, setFrom] = useState("")
+  const [to, setTo] = useState("")
+
+  const bulkDelete = useMutation({
+    mutationFn: () => entries.deleteByDateRange({ from, to }),
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({ queryKey: ["entries"] })
+      setOpen(false)
+      setFrom("")
+      setTo("")
+      toast.add({
+        title: `${data.affectedCount} entries deleted`,
+        type: "success",
+      })
+    },
+  })
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-center justify-between">
+        <CardTitle className="text-sm">Bulk actions</CardTitle>
+        {!open && (
+          <Button variant="ghost" size="sm" onClick={() => setOpen(true)}>
+            <CalendarMinus className="mr-1 h-3 w-3" />
+            Delete by date
+          </Button>
+        )}
+      </CardHeader>
+      {open && (
+        <CardContent className="flex flex-col gap-3">
+          <p className="text-xs text-muted-foreground">
+            Delete all entries within a date range. This cannot be undone.
+          </p>
+          <div className="flex gap-2">
+            <div className="flex flex-1 flex-col gap-1.5">
+              <Label className="text-xs">From</Label>
+              <Input
+                type="date"
+                value={from}
+                onChange={(e) => setFrom(e.target.value)}
+              />
+            </div>
+            <div className="flex flex-1 flex-col gap-1.5">
+              <Label className="text-xs">To</Label>
+              <Input
+                type="date"
+                value={to}
+                onChange={(e) => setTo(e.target.value)}
+              />
+            </div>
+          </div>
+          <div className="flex gap-2">
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => {
+                setOpen(false)
+                setFrom("")
+                setTo("")
+              }}
+              className="flex-1"
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="destructive"
+              size="sm"
+              onClick={() => bulkDelete.mutate()}
+              disabled={!from || !to || bulkDelete.isPending}
+              className="flex-1"
+            >
+              {bulkDelete.isPending ? "Deleting..." : "Delete entries"}
+            </Button>
+          </div>
+        </CardContent>
+      )}
+    </Card>
+  )
+}
+
+function SettingsRow({
+  icon,
+  label,
+}: {
+  icon: React.ReactNode
+  label: string
+}) {
+  return (
+    <div className="flex items-center justify-between px-6 py-3 transition-colors hover:bg-muted/50">
+      <div className="flex items-center gap-3">
+        <span className="text-muted-foreground">{icon}</span>
+        <span className="text-sm">{label}</span>
+      </div>
+      <ChevronRight className="h-4 w-4 text-muted-foreground" />
+    </div>
+  )
+}
diff --git a/spa/src/routes/_auth/settings.tsx b/spa/src/routes/_auth/settings.tsx
index c96de6b..a51aaf8 100644
--- a/spa/src/routes/_auth/settings.tsx
+++ b/spa/src/routes/_auth/settings.tsx
@@ -1,558 +1,3 @@
-import { useState } from "react"
-import { createFileRoute, Link } from "@tanstack/react-router"
-import { useMutation, useQueryClient } from "@tanstack/react-query"
-import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
-import { SubsonicCard } from "@/components/settings/subsonic-card"
-import { ApiTokensCard } from "@/components/settings/api-tokens-card"
-import { RejectionsCard } from "@/components/settings/rejections-card"
-import { CycleCard } from "@/components/settings/cycle-card"
-import { Input } from "@/components/ui/input"
-import { Label } from "@/components/ui/label"
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-  AlertDialogTrigger,
-} from "@/components/ui/alert-dialog"
-import { useAuth, useLogout } from "@/hooks/use-auth"
-import { usePushNotifications } from "@/hooks/use-push"
-import { users, entries } from "@/api/client"
-import { toast } from "@/components/ui/toast"
-import {
-  Bell,
-  CalendarMinus,
-  Clock,
-  Download,
-  ListChecks,
-  LogOut,
-  Pencil,
-  Trash2,
-  Upload,
-  ChevronRight,
-} from "lucide-react"
+import { createFileRoute } from "@tanstack/react-router"
 
-export const Route = createFileRoute("/_auth/settings")({
-  component: SettingsPage,
-})
-
-function SettingsPage() {
-  const { user } = useAuth()
-  const logout = useLogout()
-  const pushNotifications = usePushNotifications()
-  const queryClient = useQueryClient()
-  const [dialogOpen, setDialogOpen] = useState(false)
-  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false)
-
-  const clearData = useMutation({
-    mutationFn: () => users.clearData(),
-    onSuccess: () => {
-      queryClient.invalidateQueries()
-      setDialogOpen(false)
-      toast.add({ title: "All data cleared", type: "success" })
-    },
-    onError: () => {
-      toast.add({ title: "Failed to clear data", type: "error" })
-    },
-  })
-
-  const deleteAccount = useMutation({
-    mutationFn: () => users.deleteAccount(),
-    onSuccess: () => {
-      localStorage.removeItem("access_token")
-      localStorage.removeItem("refresh_token")
-      window.location.href = "/login"
-    },
-    onError: () => {
-      toast.add({ title: "Failed to delete account", type: "error" })
-    },
-  })
-
-  return (
-    <div className="flex flex-col gap-6 py-6">
-      <h1 className="text-xl font-bold">Settings</h1>
-
-      <ProfileCard
-        username={user?.username ?? ""}
-        email={user?.email ?? ""}
-        displayName={user?.displayName ?? null}
-        timezone={user?.timezone ?? null}
-      />
-
-      <SubsonicCard />
-
-      <CycleCard />
-
-      <ApiTokensCard />
-
-      <RejectionsCard />
-
-      <Card>
-        <CardHeader>
-          <CardTitle className="text-sm">Personalization</CardTitle>
-        </CardHeader>
-        <CardContent className="flex flex-col gap-1 p-0">
-          <Link to="/activities">
-            <SettingsRow
-              icon={<ListChecks className="h-4 w-4" />}
-              label="Manage activities"
-            />
-          </Link>
-          {pushNotifications.isSupported && pushNotifications.hasVapidKey && (
-            <Link to="/reminders">
-              <SettingsRow
-                icon={<Clock className="h-4 w-4" />}
-                label="Reminders"
-              />
-            </Link>
-          )}
-        </CardContent>
-      </Card>
-
-      {pushNotifications.isSupported && pushNotifications.hasVapidKey && (
-        <Card>
-          <CardHeader>
-            <CardTitle className="text-sm">Notifications</CardTitle>
-          </CardHeader>
-          <CardContent className="flex flex-col gap-2">
-            <div className="flex items-center justify-between">
-              <div className="flex items-center gap-3">
-                <Bell className="h-4 w-4 text-muted-foreground" />
-                <span className="text-sm">Push notifications</span>
-              </div>
-              <Button
-                variant={pushNotifications.isSubscribed ? "outline" : "default"}
-                size="sm"
-                onClick={pushNotifications.toggle}
-                disabled={pushNotifications.isLoading}
-              >
-                {pushNotifications.isLoading
-                  ? "..."
-                  : pushNotifications.isSubscribed
-                    ? "Disable"
-                    : "Enable"}
-              </Button>
-            </div>
-            {pushNotifications.isSubscribed && (
-              <Button
-                variant="outline"
-                size="sm"
-                onClick={pushNotifications.sendTest}
-                disabled={pushNotifications.isTesting}
-              >
-                {pushNotifications.isTesting
-                  ? "Sending..."
-                  : "Send test notification"}
-              </Button>
-            )}
-          </CardContent>
-        </Card>
-      )}
-
-      <Card>
-        <CardHeader>
-          <CardTitle className="text-sm">Data</CardTitle>
-        </CardHeader>
-        <CardContent className="flex flex-col gap-1 p-0">
-          <Link to="/export">
-            <SettingsRow
-              icon={<Download className="h-4 w-4" />}
-              label="Export data"
-            />
-          </Link>
-          <Link to="/import">
-            <SettingsRow
-              icon={<Upload className="h-4 w-4" />}
-              label="Import data"
-            />
-          </Link>
-        </CardContent>
-      </Card>
-
-      <ChangePasswordCard />
-
-      <BulkDeleteCard />
-
-      <Card>
-        <CardHeader>
-          <CardTitle className="text-sm">Danger zone</CardTitle>
-        </CardHeader>
-        <CardContent className="flex flex-col gap-2">
-          <AlertDialog open={dialogOpen} onOpenChange={setDialogOpen}>
-            <AlertDialogTrigger
-              render={
-                <Button
-                  variant="outline"
-                  className="w-full border-destructive/50 text-destructive"
-                />
-              }
-            >
-              <Trash2 className="mr-2 h-4 w-4" />
-              Clear all data
-            </AlertDialogTrigger>
-            <AlertDialogContent>
-              <AlertDialogHeader>
-                <AlertDialogTitle>Clear all data?</AlertDialogTitle>
-                <AlertDialogDescription>
-                  This will permanently delete all your mood entries,
-                  activities, and reminders. Your account will remain. This
-                  cannot be undone.
-                </AlertDialogDescription>
-              </AlertDialogHeader>
-              <AlertDialogFooter>
-                <AlertDialogCancel>Cancel</AlertDialogCancel>
-                <AlertDialogAction
-                  onClick={(e) => {
-                    e.preventDefault()
-                    clearData.mutate()
-                  }}
-                >
-                  {clearData.isPending ? "Deleting..." : "Delete everything"}
-                </AlertDialogAction>
-              </AlertDialogFooter>
-            </AlertDialogContent>
-          </AlertDialog>
-
-          <AlertDialog
-            open={deleteDialogOpen}
-            onOpenChange={setDeleteDialogOpen}
-          >
-            <AlertDialogTrigger
-              render={<Button variant="destructive" className="w-full" />}
-            >
-              <Trash2 className="mr-2 h-4 w-4" />
-              Delete account
-            </AlertDialogTrigger>
-            <AlertDialogContent>
-              <AlertDialogHeader>
-                <AlertDialogTitle>Delete your account?</AlertDialogTitle>
-                <AlertDialogDescription>
-                  This will permanently delete your account and all associated
-                  data including entries, activities, photos, and voice memos.
-                  This cannot be undone.
-                </AlertDialogDescription>
-              </AlertDialogHeader>
-              <AlertDialogFooter>
-                <AlertDialogCancel>Cancel</AlertDialogCancel>
-                <AlertDialogAction
-                  onClick={(e) => {
-                    e.preventDefault()
-                    deleteAccount.mutate()
-                  }}
-                >
-                  {deleteAccount.isPending
-                    ? "Deleting..."
-                    : "Delete my account"}
-                </AlertDialogAction>
-              </AlertDialogFooter>
-            </AlertDialogContent>
-          </AlertDialog>
-        </CardContent>
-      </Card>
-
-      <Button
-        variant="destructive"
-        onClick={() => logout.mutate()}
-        disabled={logout.isPending}
-        className="w-full"
-      >
-        <LogOut className="mr-2 h-4 w-4" />
-        {logout.isPending ? "Signing out..." : "Sign out"}
-      </Button>
-    </div>
-  )
-}
-
-function ProfileCard({
-  username,
-  email,
-  displayName,
-  timezone,
-}: {
-  username: string
-  email: string
-  displayName: string | null
-  timezone: string | null
-}) {
-  const queryClient = useQueryClient()
-  const [editing, setEditing] = useState(false)
-  const [name, setName] = useState(displayName ?? "")
-  const [tz, setTz] = useState(timezone ?? "")
-
-  const updateProfile = useMutation({
-    mutationFn: () =>
-      users.updateProfile({
-        displayName: name || null,
-        timezone: tz || null,
-      }),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["auth"] })
-      setEditing(false)
-      toast.add({ title: "Profile updated", type: "success" })
-    },
-  })
-
-  return (
-    <Card>
-      <CardHeader className="flex flex-row items-center justify-between">
-        <CardTitle className="text-sm">Account</CardTitle>
-        {!editing && (
-          <Button
-            variant="ghost"
-            size="sm"
-            onClick={() => {
-              setName(displayName ?? "")
-              setTz(timezone ?? "")
-              setEditing(true)
-            }}
-          >
-            <Pencil className="mr-1 h-3 w-3" />
-            Edit
-          </Button>
-        )}
-      </CardHeader>
-      <CardContent className="flex flex-col gap-3 text-sm">
-        <div className="flex justify-between">
-          <span className="text-muted-foreground">Username</span>
-          <span>{username}</span>
-        </div>
-        <div className="flex justify-between">
-          <span className="text-muted-foreground">Email</span>
-          <span>{email}</span>
-        </div>
-
-        {editing ? (
-          <>
-            <div className="flex flex-col gap-1.5">
-              <Label className="text-xs">Display name</Label>
-              <Input
-                value={name}
-                onChange={(e) => setName(e.target.value)}
-                placeholder="Your name"
-              />
-            </div>
-            <div className="flex flex-col gap-1.5">
-              <Label className="text-xs">Timezone</Label>
-              <Input
-                value={tz}
-                onChange={(e) => setTz(e.target.value)}
-                placeholder="e.g. Europe/Warsaw"
-              />
-              <p className="text-xs text-muted-foreground">
-                Required for reminders to fire at the correct time
-              </p>
-            </div>
-            <div className="flex gap-2">
-              <Button
-                variant="outline"
-                size="sm"
-                onClick={() => setEditing(false)}
-                className="flex-1"
-              >
-                Cancel
-              </Button>
-              <Button
-                size="sm"
-                onClick={() => updateProfile.mutate()}
-                disabled={updateProfile.isPending}
-                className="flex-1"
-              >
-                {updateProfile.isPending ? "Saving..." : "Save"}
-              </Button>
-            </div>
-          </>
-        ) : (
-          <>
-            <div className="flex justify-between">
-              <span className="text-muted-foreground">Display name</span>
-              <span>{displayName ?? "—"}</span>
-            </div>
-            <div className="flex justify-between">
-              <span className="text-muted-foreground">Timezone</span>
-              <span>{timezone ?? "—"}</span>
-            </div>
-          </>
-        )}
-      </CardContent>
-    </Card>
-  )
-}
-
-function ChangePasswordCard() {
-  const [open, setOpen] = useState(false)
-  const [currentPassword, setCurrentPassword] = useState("")
-  const [newPassword, setNewPassword] = useState("")
-
-  const changePassword = useMutation({
-    mutationFn: () => users.changePassword({ currentPassword, newPassword }),
-    onSuccess: () => {
-      setOpen(false)
-      setCurrentPassword("")
-      setNewPassword("")
-      toast.add({ title: "Password changed", type: "success" })
-    },
-  })
-
-  return (
-    <Card>
-      <CardHeader className="flex flex-row items-center justify-between">
-        <CardTitle className="text-sm">Security</CardTitle>
-        {!open && (
-          <Button variant="ghost" size="sm" onClick={() => setOpen(true)}>
-            Change password
-          </Button>
-        )}
-      </CardHeader>
-      {open && (
-        <CardContent className="flex flex-col gap-3">
-          <div className="flex flex-col gap-1.5">
-            <Label className="text-xs">Current password</Label>
-            <Input
-              type="password"
-              value={currentPassword}
-              onChange={(e) => setCurrentPassword(e.target.value)}
-            />
-          </div>
-          <div className="flex flex-col gap-1.5">
-            <Label className="text-xs">New password</Label>
-            <Input
-              type="password"
-              value={newPassword}
-              onChange={(e) => setNewPassword(e.target.value)}
-            />
-          </div>
-          <div className="flex gap-2">
-            <Button
-              variant="outline"
-              size="sm"
-              onClick={() => {
-                setOpen(false)
-                setCurrentPassword("")
-                setNewPassword("")
-              }}
-              className="flex-1"
-            >
-              Cancel
-            </Button>
-            <Button
-              size="sm"
-              onClick={() => changePassword.mutate()}
-              disabled={
-                changePassword.isPending || !currentPassword || !newPassword
-              }
-              className="flex-1"
-            >
-              {changePassword.isPending ? "Changing..." : "Change password"}
-            </Button>
-          </div>
-        </CardContent>
-      )}
-    </Card>
-  )
-}
-
-function BulkDeleteCard() {
-  const queryClient = useQueryClient()
-  const [open, setOpen] = useState(false)
-  const [from, setFrom] = useState("")
-  const [to, setTo] = useState("")
-
-  const bulkDelete = useMutation({
-    mutationFn: () => entries.deleteByDateRange({ from, to }),
-    onSuccess: (data) => {
-      queryClient.invalidateQueries({ queryKey: ["entries"] })
-      setOpen(false)
-      setFrom("")
-      setTo("")
-      toast.add({
-        title: `${data.affectedCount} entries deleted`,
-        type: "success",
-      })
-    },
-  })
-
-  return (
-    <Card>
-      <CardHeader className="flex flex-row items-center justify-between">
-        <CardTitle className="text-sm">Bulk actions</CardTitle>
-        {!open && (
-          <Button variant="ghost" size="sm" onClick={() => setOpen(true)}>
-            <CalendarMinus className="mr-1 h-3 w-3" />
-            Delete by date
-          </Button>
-        )}
-      </CardHeader>
-      {open && (
-        <CardContent className="flex flex-col gap-3">
-          <p className="text-xs text-muted-foreground">
-            Delete all entries within a date range. This cannot be undone.
-          </p>
-          <div className="flex gap-2">
-            <div className="flex flex-1 flex-col gap-1.5">
-              <Label className="text-xs">From</Label>
-              <Input
-                type="date"
-                value={from}
-                onChange={(e) => setFrom(e.target.value)}
-              />
-            </div>
-            <div className="flex flex-1 flex-col gap-1.5">
-              <Label className="text-xs">To</Label>
-              <Input
-                type="date"
-                value={to}
-                onChange={(e) => setTo(e.target.value)}
-              />
-            </div>
-          </div>
-          <div className="flex gap-2">
-            <Button
-              variant="outline"
-              size="sm"
-              onClick={() => {
-                setOpen(false)
-                setFrom("")
-                setTo("")
-              }}
-              className="flex-1"
-            >
-              Cancel
-            </Button>
-            <Button
-              variant="destructive"
-              size="sm"
-              onClick={() => bulkDelete.mutate()}
-              disabled={!from || !to || bulkDelete.isPending}
-              className="flex-1"
-            >
-              {bulkDelete.isPending ? "Deleting..." : "Delete entries"}
-            </Button>
-          </div>
-        </CardContent>
-      )}
-    </Card>
-  )
-}
-
-function SettingsRow({
-  icon,
-  label,
-}: {
-  icon: React.ReactNode
-  label: string
-}) {
-  return (
-    <div className="flex items-center justify-between px-6 py-3 transition-colors hover:bg-muted/50">
-      <div className="flex items-center gap-3">
-        <span className="text-muted-foreground">{icon}</span>
-        <span className="text-sm">{label}</span>
-      </div>
-      <ChevronRight className="h-4 w-4 text-muted-foreground" />
-    </div>
-  )
-}
+export const Route = createFileRoute("/_auth/settings")({})
diff --git a/spa/src/routes/_auth/stats.lazy.tsx b/spa/src/routes/_auth/stats.lazy.tsx
index 5643a7b..cce17d4 100644
--- a/spa/src/routes/_auth/stats.lazy.tsx
+++ b/spa/src/routes/_auth/stats.lazy.tsx
@@ -1,67 +1,54 @@
 import { useState } from "react"
 import { createLazyFileRoute } from "@tanstack/react-router"
-import { ChevronLeft, ChevronRight } from "lucide-react"
-import { getMoodEmoji } from "@/lib/mood"
-import { Button } from "@/components/ui/button"
 import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs"
 import { Skeleton } from "@/components/ui/skeleton"
 import { MoodTrendChart } from "@/components/stats/mood-trend-chart"
 import { MoodDistribution } from "@/components/stats/mood-distribution"
-import { MoodHeatmap } from "@/components/stats/mood-heatmap"
 import { MoodCorrelations } from "@/components/stats/mood-correlations"
-import { StatCard } from "@/components/stats/stat-card"
-import { useMoodStats, usePeriodEntries } from "@/hooks/use-stats"
-import { useYearCalendar } from "@/hooks/use-year-calendar"
+import { MoodSummary } from "@/components/stats/mood-summary"
+import { HeatmapSection } from "@/components/stats/heatmap-section"
+import { useMoodStats } from "@/hooks/use-stats"
+import { useTrend } from "@/hooks/use-trend"
+import { PERIODS, PERIOD_LABELS } from "@/lib/period"
+import type { Period } from "@/lib/period"
 
 export const Route = createLazyFileRoute("/_auth/stats")({
   component: StatsPage,
 })
 
-type Period = "week" | "month" | "year" | "all"
-
 function StatsPage() {
   const [period, setPeriod] = useState<Period>("month")
-  const [heatmapYear, setHeatmapYear] = useState(new Date().getFullYear())
-  const { data: stats, isLoading: statsLoading } = useMoodStats(period)
-  const { data: trendEntries } = usePeriodEntries(period)
-  const { data: yearDays, isLoading: heatmapLoading } =
-    useYearCalendar(heatmapYear)
+  const { data: stats, isLoading } = useMoodStats(period)
+  const { data: trend } = useTrend(period)
 
   return (
     <div className="flex flex-col gap-4 py-6">
       <h1 className="text-xl font-bold">Statistics</h1>
 
-      <Tabs value={period} onValueChange={(v) => setPeriod(v as Period)}>
+      <Tabs
+        value={period}
+        onValueChange={(value) => setPeriod(value as Period)}
+      >
         <TabsList className="grid w-full grid-cols-4">
-          <TabsTrigger value="week">Week</TabsTrigger>
-          <TabsTrigger value="month">Month</TabsTrigger>
-          <TabsTrigger value="year">Year</TabsTrigger>
-          <TabsTrigger value="all">All</TabsTrigger>
+          {PERIODS.map((option) => (
+            <TabsTrigger key={option} value={option}>
+              {PERIOD_LABELS[option]}
+            </TabsTrigger>
+          ))}
         </TabsList>
       </Tabs>
 
-      {statsLoading ? (
+      {isLoading ? (
         <div className="flex flex-col gap-4">
           <Skeleton className="h-24" />
           <Skeleton className="h-48" />
         </div>
       ) : stats ? (
         <>
-          <div className="grid grid-cols-3 gap-3">
-            <StatCard
-              label="Average"
-              value={
-                stats.average
-                  ? getMoodEmoji(Math.round(Number(stats.average)))
-                  : "—"
-              }
-            />
-            <StatCard label="Streak" value={`${stats.currentStreak}d`} />
-            <StatCard label="Entries" value={stats.totalEntries} />
-          </div>
+          <MoodSummary stats={stats} />
 
-          {trendEntries?.length ? (
-            <MoodTrendChart entries={trendEntries} period={period} />
+          {trend?.length ? (
+            <MoodTrendChart points={trend} period={period} />
           ) : null}
 
           {stats.frequency.length ? (
@@ -72,30 +59,7 @@ function StatsPage() {
         </>
       ) : null}
 
-      <div className="flex items-center justify-between">
-        <Button
-          variant="ghost"
-          size="icon"
-          onClick={() => setHeatmapYear((y) => y - 1)}
-        >
-          <ChevronLeft className="h-5 w-5" />
-        </Button>
-        <span className="text-sm font-medium">{heatmapYear}</span>
-        <Button
-          variant="ghost"
-          size="icon"
-          onClick={() => setHeatmapYear((y) => y + 1)}
-          disabled={heatmapYear >= new Date().getFullYear()}
-        >
-          <ChevronRight className="h-5 w-5" />
-        </Button>
-      </div>
-
-      {heatmapLoading ? (
-        <Skeleton className="h-32" />
-      ) : yearDays ? (
-        <MoodHeatmap year={heatmapYear} days={yearDays} />
-      ) : null}
+      <HeatmapSection />
     </div>
   )
 }
diff --git a/spa/src/routes/login.tsx b/spa/src/routes/login.tsx
index 3da1741..a637e94 100644
--- a/spa/src/routes/login.tsx
+++ b/spa/src/routes/login.tsx
@@ -1,10 +1,21 @@
 import { useState } from "react"
 import { createFileRoute, Link } from "@tanstack/react-router"
 import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader } from "@/components/ui/card"
 import { Input } from "@/components/ui/input"
 import { Label } from "@/components/ui/label"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "@/components/ui/dialog"
+import { AuthCard } from "@/components/auth/auth-card"
+import { FormError } from "@/components/auth/form-error"
+import { ServerPicker } from "@/components/settings/server-picker"
 import { useLogin } from "@/hooks/use-auth"
+import { useServerInfo } from "@/hooks/use-server"
 
 export const Route = createFileRoute("/login")({ component: LoginPage })
 
@@ -12,59 +23,80 @@ function LoginPage() {
   const [identifier, setIdentifier] = useState("")
   const [password, setPassword] = useState("")
   const login = useLogin()
-
-  const handleSubmit = (e: React.FormEvent) => {
-    e.preventDefault()
-    login.mutate({ identifier, password })
-  }
+  const { data: serverInfo } = useServerInfo()
 
   return (
-    <div className="flex min-h-svh items-center justify-center p-4">
-      <Card className="w-full max-w-sm">
-        <CardHeader className="text-center">
-          <h1 className="text-2xl font-bold">K-Mood</h1>
-          <p className="text-sm text-muted-foreground">
-            Track your mood, understand yourself
+    <AuthCard title="K-Mood" subtitle="Track your mood, understand yourself">
+      <form
+        onSubmit={(event) => {
+          event.preventDefault()
+          login.mutate({ identifier, password })
+        }}
+        className="flex flex-col gap-4"
+      >
+        <div className="flex flex-col gap-2">
+          <Label htmlFor="identifier">Username or email</Label>
+          <Input
+            id="identifier"
+            value={identifier}
+            onChange={(event) => setIdentifier(event.target.value)}
+            autoComplete="username"
+            required
+          />
+        </div>
+
+        <div className="flex flex-col gap-2">
+          <Label htmlFor="password">Password</Label>
+          <Input
+            id="password"
+            type="password"
+            value={password}
+            onChange={(event) => setPassword(event.target.value)}
+            autoComplete="current-password"
+            required
+          />
+        </div>
+
+        <FormError error={login.error} />
+
+        <Button type="submit" disabled={login.isPending} className="w-full">
+          {login.isPending ? "Signing in…" : "Sign in"}
+        </Button>
+
+        <Dialog>
+          <DialogTrigger
+            render={
+              <Button
+                variant="link"
+                size="sm"
+                type="button"
+                className="w-full"
+              />
+            }
+          >
+            Connect to a different server
+          </DialogTrigger>
+          <DialogContent>
+            <DialogHeader>
+              <DialogTitle>Choose a server</DialogTitle>
+              <DialogDescription>
+                This app is not tied to one k-mood server. Point it at whichever
+                one holds your journal.
+              </DialogDescription>
+            </DialogHeader>
+            <ServerPicker version={serverInfo?.version} />
+          </DialogContent>
+        </Dialog>
+
+        {serverInfo?.registrationOpen && (
+          <p className="text-center text-sm text-muted-foreground">
+            Don&apos;t have an account?{" "}
+            <Link to="/register" className="text-primary underline">
+              Register
+            </Link>
           </p>
-        </CardHeader>
-        <CardContent>
-          <form onSubmit={handleSubmit} className="flex flex-col gap-4">
-            <div className="flex flex-col gap-2">
-              <Label htmlFor="identifier">Username or email</Label>
-              <Input
-                id="identifier"
-                value={identifier}
-                onChange={(e) => setIdentifier(e.target.value)}
-                autoComplete="username"
-                required
-              />
-            </div>
-            <div className="flex flex-col gap-2">
-              <Label htmlFor="password">Password</Label>
-              <Input
-                id="password"
-                type="password"
-                value={password}
-                onChange={(e) => setPassword(e.target.value)}
-                autoComplete="current-password"
-                required
-              />
-            </div>
-            {login.isError && (
-              <p className="text-sm text-destructive">Invalid credentials</p>
-            )}
-            <Button type="submit" disabled={login.isPending} className="w-full">
-              {login.isPending ? "Signing in..." : "Sign in"}
-            </Button>
-            <p className="text-center text-sm text-muted-foreground">
-              Don&apos;t have an account?{" "}
-              <Link to="/register" className="text-primary underline">
-                Register
-              </Link>
-            </p>
-          </form>
-        </CardContent>
-      </Card>
-    </div>
+        )}
+      </form>
+    </AuthCard>
   )
 }
diff --git a/spa/src/routes/register.tsx b/spa/src/routes/register.tsx
index fc4655b..e924988 100644
--- a/spa/src/routes/register.tsx
+++ b/spa/src/routes/register.tsx
@@ -1,10 +1,25 @@
 import { useState } from "react"
 import { createFileRoute, Link } from "@tanstack/react-router"
 import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader } from "@/components/ui/card"
+import { buttonLook } from "@/lib/button-style"
+import { Card, CardContent } from "@/components/ui/card"
 import { Input } from "@/components/ui/input"
 import { Label } from "@/components/ui/label"
+import {
+  Empty,
+  EmptyContent,
+  EmptyDescription,
+  EmptyHeader,
+  EmptyTitle,
+} from "@/components/ui/empty"
+import { AuthCard } from "@/components/auth/auth-card"
+import { FormError } from "@/components/auth/form-error"
+import {
+  PasswordStrength,
+  isStrongEnough,
+} from "@/components/auth/password-strength"
 import { useRegister } from "@/hooks/use-auth"
+import { useServerInfo } from "@/hooks/use-server"
 
 export const Route = createFileRoute("/register")({ component: RegisterPage })
 
@@ -13,74 +28,100 @@ function RegisterPage() {
   const [email, setEmail] = useState("")
   const [password, setPassword] = useState("")
   const register = useRegister()
+  const { data: serverInfo } = useServerInfo()
 
-  const handleSubmit = (e: React.FormEvent) => {
-    e.preventDefault()
-    register.mutate({ username, email, password })
+  if (serverInfo && !serverInfo.registrationOpen) {
+    return <RegistrationClosed />
   }
 
   return (
-    <div className="flex min-h-svh items-center justify-center p-4">
-      <Card className="w-full max-w-sm">
-        <CardHeader className="text-center">
-          <h1 className="text-2xl font-bold">Create account</h1>
-          <p className="text-sm text-muted-foreground">
-            Start tracking your mood
-          </p>
-        </CardHeader>
-        <CardContent>
-          <form onSubmit={handleSubmit} className="flex flex-col gap-4">
-            <div className="flex flex-col gap-2">
-              <Label htmlFor="username">Username</Label>
-              <Input
-                id="username"
-                value={username}
-                onChange={(e) => setUsername(e.target.value)}
-                autoComplete="username"
-                required
-              />
-            </div>
-            <div className="flex flex-col gap-2">
-              <Label htmlFor="email">Email</Label>
-              <Input
-                id="email"
-                type="email"
-                value={email}
-                onChange={(e) => setEmail(e.target.value)}
-                autoComplete="email"
-                required
-              />
-            </div>
-            <div className="flex flex-col gap-2">
-              <Label htmlFor="password">Password</Label>
-              <Input
-                id="password"
-                type="password"
-                value={password}
-                onChange={(e) => setPassword(e.target.value)}
-                autoComplete="new-password"
-                required
-              />
-            </div>
-            {register.isError && (
-              <p className="text-sm text-destructive">Registration failed</p>
-            )}
-            <Button
-              type="submit"
-              disabled={register.isPending}
-              className="w-full"
-            >
-              {register.isPending ? "Creating..." : "Create account"}
-            </Button>
-            <p className="text-center text-sm text-muted-foreground">
-              Already have an account?{" "}
-              <Link to="/login" className="text-primary underline">
-                Sign in
-              </Link>
-            </p>
-          </form>
-        </CardContent>
-      </Card>
-    </div>
+    <AuthCard title="Create account" subtitle="Start tracking your mood">
+      <form
+        onSubmit={(event) => {
+          event.preventDefault()
+          register.mutate({ username, email, password })
+        }}
+        className="flex flex-col gap-4"
+      >
+        <div className="flex flex-col gap-2">
+          <Label htmlFor="username">Username</Label>
+          <Input
+            id="username"
+            value={username}
+            onChange={(event) => setUsername(event.target.value)}
+            autoComplete="username"
+            required
+          />
+        </div>
+
+        <div className="flex flex-col gap-2">
+          <Label htmlFor="email">Email</Label>
+          <Input
+            id="email"
+            type="email"
+            value={email}
+            onChange={(event) => setEmail(event.target.value)}
+            autoComplete="email"
+            required
+          />
+        </div>
+
+        <div className="flex flex-col gap-2">
+          <Label htmlFor="password">Password</Label>
+          <Input
+            id="password"
+            type="password"
+            value={password}
+            onChange={(event) => setPassword(event.target.value)}
+            autoComplete="new-password"
+            aria-describedby="password-strength"
+            required
+          />
+          <PasswordStrength password={password} />
+        </div>
+
+        <FormError error={register.error} />
+
+        <Button
+          type="submit"
+          disabled={register.isPending || !isStrongEnough(password)}
+          className="w-full"
+        >
+          {register.isPending ? "Creating…" : "Create account"}
+        </Button>
+
+        <p className="text-center text-sm text-muted-foreground">
+          Already have an account?{" "}
+          <Link to="/login" className="text-primary underline">
+            Sign in
+          </Link>
+        </p>
+      </form>
+    </AuthCard>
+  )
+}
+
+function RegistrationClosed() {
+  return (
+    <main className="flex min-h-svh items-center justify-center p-4">
+      <Card className="w-full max-w-sm">
+        <CardContent>
+          <Empty>
+            <EmptyHeader>
+              <EmptyTitle>Registration is closed</EmptyTitle>
+              <EmptyDescription>
+                This server is not taking new accounts. Ask whoever runs it for
+                an invitation.
+              </EmptyDescription>
+            </EmptyHeader>
+            <EmptyContent>
+              <Link to="/login" className={buttonLook({ variant: "outline" })}>
+                Back to sign in
+              </Link>
+            </EmptyContent>
+          </Empty>
+        </CardContent>
+      </Card>
+    </main>
   )
 }
diff --git a/spa/src/styles.css b/spa/src/styles.css
index cc4a580..3ed742f 100644
--- a/spa/src/styles.css
+++ b/spa/src/styles.css
@@ -1,69 +1,88 @@
 @import "tailwindcss";
 @import "tw-animate-css";
 @import "shadcn/tailwind.css";
-@import "@fontsource-variable/inter";
+@import "./fonts.css";
 @import "./aero-theme.css";
 
 @custom-variant dark (&:is(.dark *));
 
 @theme inline {
-    --font-heading: var(--font-sans);
-    --font-sans: 'Inter Variable', sans-serif;
-    --color-sidebar-ring: var(--sidebar-ring);
-    --color-sidebar-border: var(--sidebar-border);
-    --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
-    --color-sidebar-accent: var(--sidebar-accent);
-    --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
-    --color-sidebar-primary: var(--sidebar-primary);
-    --color-sidebar-foreground: var(--sidebar-foreground);
-    --color-sidebar: var(--sidebar);
-    --color-chart-5: var(--chart-5);
-    --color-chart-4: var(--chart-4);
-    --color-chart-3: var(--chart-3);
-    --color-chart-2: var(--chart-2);
-    --color-chart-1: var(--chart-1);
-    --color-ring: var(--ring);
-    --color-input: var(--input);
-    --color-border: var(--border);
-    --color-destructive: var(--destructive);
-    --color-accent-foreground: var(--accent-foreground);
-    --color-accent: var(--accent);
-    --color-muted-foreground: var(--muted-foreground);
-    --color-muted: var(--muted);
-    --color-secondary-foreground: var(--secondary-foreground);
-    --color-secondary: var(--secondary);
-    --color-primary-foreground: var(--primary-foreground);
-    --color-primary: var(--primary);
-    --color-popover-foreground: var(--popover-foreground);
-    --color-popover: var(--popover);
-    --color-card-foreground: var(--card-foreground);
-    --color-card: var(--card);
-    --color-foreground: var(--foreground);
-    --color-background: var(--background);
-    --radius-sm: calc(var(--radius) * 0.6);
-    --radius-md: calc(var(--radius) * 0.8);
-    --radius-lg: var(--radius);
-    --radius-xl: calc(var(--radius) * 1.4);
-    --radius-2xl: calc(var(--radius) * 1.8);
-    --radius-3xl: calc(var(--radius) * 2.2);
-    --radius-4xl: calc(var(--radius) * 2.6);
+  --font-heading: var(--font-sans);
+  --font-sans: "Inter Variable", sans-serif;
+  --color-sidebar-ring: var(--sidebar-ring);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar: var(--sidebar);
+  --color-chart-5: var(--chart-5);
+  --color-chart-4: var(--chart-4);
+  --color-chart-3: var(--chart-3);
+  --color-chart-2: var(--chart-2);
+  --color-chart-1: var(--chart-1);
+  --color-ring: var(--ring);
+  --color-input: var(--input);
+  --color-border: var(--border);
+  --color-destructive: var(--destructive);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-accent: var(--accent);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-muted: var(--muted);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-secondary: var(--secondary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-primary: var(--primary);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-popover: var(--popover);
+  --color-card-foreground: var(--card-foreground);
+  --color-card: var(--card);
+  --color-foreground: var(--foreground);
+  --color-background: var(--background);
+  --radius-sm: calc(var(--radius) * 0.6);
+  --radius-md: calc(var(--radius) * 0.8);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) * 1.4);
+  --radius-2xl: calc(var(--radius) * 1.8);
+  --radius-3xl: calc(var(--radius) * 2.2);
+  --radius-4xl: calc(var(--radius) * 2.6);
 }
 
 :root {
-    --radius: 0.625rem;
+  --radius: 0.625rem;
 }
 
 @layer base {
   * {
     @apply border-border outline-ring/50;
-    }
+  }
   body {
     @apply text-foreground;
-    }
-  button:not(:disabled), [role="button"]:not(:disabled) {
+  }
+  button:not(:disabled),
+  [role="button"]:not(:disabled) {
     cursor: pointer;
-    }
+  }
   html {
     @apply font-sans;
-    }
-}
\ No newline at end of file
+  }
+}
+/* ── Safe area ────────────────────────────────────────────────────
+ * The viewport is `viewport-fit=cover`, so on a notched phone the top of
+ * the page sits under the status bar and the bottom under the home
+ * indicator. These carry the insets Tailwind has no built-in for.
+ */
+
+@utility pt-safe {
+  padding-top: env(safe-area-inset-top, 0px);
+}
+
+@utility pb-safe {
+  padding-bottom: env(safe-area-inset-bottom, 0px);
+}
+
+/* Clearance for the fixed bottom navigation, plus whatever sits beneath it. */
+@utility pb-nav {
+  padding-bottom: calc(5rem + env(safe-area-inset-bottom, 0px));
+}
diff --git a/spa/tests/api/session.test.ts b/spa/tests/api/session.test.ts
new file mode 100644
index 0000000..53fabdd
--- /dev/null
+++ b/spa/tests/api/session.test.ts
@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, it } from "vitest"
+import {
+  accessToken,
+  forgetSession,
+  hasSession,
+  refreshToken,
+  rememberSession,
+} from "@/api/session"
+
+const TOKENS = { accessToken: "access-1", refreshToken: "refresh-1" }
+
+describe("session", () => {
+  beforeEach(() => localStorage.clear())
+
+  it("has no session before anything is remembered", () => {
+    expect(hasSession()).toBe(false)
+    expect(accessToken()).toBeNull()
+  })
+
+  it("remembers and reads back both tokens", () => {
+    rememberSession(TOKENS)
+
+    expect(hasSession()).toBe(true)
+    expect(accessToken()).toBe("access-1")
+    expect(refreshToken()).toBe("refresh-1")
+  })
+
+  it("forgets every key it wrote", () => {
+    rememberSession(TOKENS)
+    forgetSession()
+
+    expect(hasSession()).toBe(false)
+    expect(accessToken()).toBeNull()
+    expect(refreshToken()).toBeNull()
+    // The bug this guards: deleting an account cleared snake_case keys that
+    // were never written, leaving a live token behind.
+    expect(localStorage.length).toBe(0)
+  })
+})
diff --git a/spa/tests/lib/activity-groups.test.ts b/spa/tests/lib/activity-groups.test.ts
new file mode 100644
index 0000000..153d8e5
--- /dev/null
+++ b/spa/tests/lib/activity-groups.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest"
+import { UNCATEGORISED, groupByCategory } from "@/lib/activity-groups"
+
+const activity = (name: string, category: string | null) => ({ name, category })
+
+describe("grouping activities", () => {
+  it("sorts categories alphabetically", () => {
+    const groups = groupByCategory([
+      activity("run", "sport"),
+      activity("read", "hobby"),
+    ])
+
+    expect(groups.map((group) => group.category)).toEqual(["hobby", "sport"])
+  })
+
+  it("puts activities with no category last", () => {
+    const groups = groupByCategory([
+      activity("nap", null),
+      activity("run", "sport"),
+      activity("read", "hobby"),
+    ])
+
+    expect(groups.map((group) => group.category)).toEqual([
+      "hobby",
+      "sport",
+      UNCATEGORISED,
+    ])
+  })
+
+  it("keeps activities within a category in the order given", () => {
+    const groups = groupByCategory([
+      activity("run", "sport"),
+      activity("swim", "sport"),
+    ])
+
+    expect(groups[0].items.map((item) => item.name)).toEqual(["run", "swim"])
+  })
+
+  it("has no groups for no activities", () => {
+    expect(groupByCategory([])).toEqual([])
+  })
+})
diff --git a/spa/tests/lib/entry-draft.test.ts b/spa/tests/lib/entry-draft.test.ts
new file mode 100644
index 0000000..145f454
--- /dev/null
+++ b/spa/tests/lib/entry-draft.test.ts
@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest"
+import {
+  emptyDraft,
+  hasExtras,
+  isWorthKeeping,
+  toCreateRequest,
+} from "@/lib/entry-draft"
+import type { EntryDraft } from "@/lib/entry-draft"
+
+const NOTHING_UPLOADED = { photoIds: [], voiceMemoIds: [] }
+
+function draftWith(changes: Partial<EntryDraft>): EntryDraft {
+  return { ...emptyDraft(), mood: 4, ...changes }
+}
+
+describe("entry drafts", () => {
+  it("is not worth keeping when nothing has been entered", () => {
+    expect(isWorthKeeping(emptyDraft())).toBe(false)
+  })
+
+  it("is worth keeping once a mood is picked", () => {
+    expect(isWorthKeeping(draftWith({}))).toBe(true)
+  })
+
+  it("is worth keeping for a note with no mood", () => {
+    const draft = { ...emptyDraft(), content: "a rough morning" }
+
+    expect(isWorthKeeping(draft)).toBe(true)
+  })
+
+  it("does not count whitespace as a note", () => {
+    expect(hasExtras(draftWith({ content: "   " }))).toBe(false)
+  })
+
+  it("does not treat a tagged activity as an extra", () => {
+    // Activities live in the always-visible part of the form; counting them
+    // sprang the "add more" section open the moment one was tapped.
+    expect(hasExtras(draftWith({ activityIds: ["reading"] }))).toBe(false)
+  })
+
+  it("still keeps a draft that only has activities on it", () => {
+    const draft = { ...emptyDraft(), activityIds: ["reading"] }
+
+    expect(isWorthKeeping(draft)).toBe(true)
+  })
+
+  it("refuses to build a request without a mood", () => {
+    expect(() => toCreateRequest(emptyDraft(), NOTHING_UPLOADED)).toThrowError(
+      /without a mood/
+    )
+  })
+
+  it("omits dimensions that hold nothing", () => {
+    const request = toCreateRequest(draftWith({}), NOTHING_UPLOADED)
+
+    expect(request.dimensions).toEqual([])
+    expect(request.mood).toBe(4)
+  })
+
+  it("trims the note and keeps it as a content dimension", () => {
+    const request = toCreateRequest(
+      draftWith({ content: "  tired  " }),
+      NOTHING_UPLOADED
+    )
+
+    expect(request.dimensions).toContainEqual({
+      kind: "content",
+      text: "tired",
+    })
+  })
+
+  it("keeps a song only when both title and artist are given", () => {
+    const halfNamed = toCreateRequest(
+      draftWith({ song: { title: "Teardrop", artist: "" } }),
+      NOTHING_UPLOADED
+    )
+    expect(halfNamed.dimensions).toEqual([])
+
+    const named = toCreateRequest(
+      draftWith({ song: { title: "Teardrop", artist: "Massive Attack" } }),
+      NOTHING_UPLOADED
+    )
+    expect(named.dimensions).toContainEqual({
+      kind: "song",
+      title: "Teardrop",
+      artist: "Massive Attack",
+    })
+  })
+
+  it("uses the ids the upload returned, not the local media", () => {
+    const request = toCreateRequest(draftWith({}), {
+      photoIds: ["photo-a", "photo-b"],
+      voiceMemoIds: ["memo-a"],
+    })
+
+    expect(request.dimensions).toContainEqual({
+      kind: "photos",
+      ids: ["photo-a", "photo-b"],
+    })
+    expect(request.dimensions).toContainEqual({
+      kind: "voiceMemos",
+      ids: ["memo-a"],
+    })
+  })
+
+  it("carries coordinates through as a location dimension", () => {
+    const request = toCreateRequest(
+      draftWith({ location: { latitude: 52.23, longitude: 21.01 } }),
+      NOTHING_UPLOADED
+    )
+
+    expect(request.dimensions).toContainEqual({
+      kind: "location",
+      latitude: 52.23,
+      longitude: 21.01,
+    })
+  })
+})
diff --git a/spa/tests/lib/instant-range.test.ts b/spa/tests/lib/instant-range.test.ts
new file mode 100644
index 0000000..9dc8bc3
--- /dev/null
+++ b/spa/tests/lib/instant-range.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest"
+import { rangeOfDays, rangeOfMonth, rangeOfYear } from "@/lib/instant-range"
+
+const OFFSET = /[+-]\d{2}:\d{2}$/
+
+describe("instant ranges", () => {
+  it("carries the reader's own offset rather than assuming UTC", () => {
+    const { from, to } = rangeOfMonth(new Date(2026, 7, 15))
+
+    expect(from).toMatch(OFFSET)
+    expect(to).toMatch(OFFSET)
+  })
+
+  it("starts a month at local midnight on the first", () => {
+    const { from } = rangeOfMonth(new Date(2026, 7, 15))
+
+    expect(from.startsWith("2026-08-01T00:00:00")).toBe(true)
+  })
+
+  it("ends a month on the last day, not the first of the next", () => {
+    const { to } = rangeOfMonth(new Date(2026, 7, 15))
+
+    expect(to.startsWith("2026-08-31T23:59:59")).toBe(true)
+  })
+
+  it("covers a whole year", () => {
+    const { from, to } = rangeOfYear(2025)
+
+    expect(from.startsWith("2025-01-01T00:00:00")).toBe(true)
+    expect(to.startsWith("2025-12-31T23:59:59")).toBe(true)
+  })
+
+  it("widens a span to whole days at both ends", () => {
+    const { from, to } = rangeOfDays(
+      new Date(2026, 0, 5, 13, 30),
+      new Date(2026, 0, 7, 9, 15)
+    )
+
+    expect(from.startsWith("2026-01-05T00:00:00")).toBe(true)
+    expect(to.startsWith("2026-01-07T23:59:59")).toBe(true)
+  })
+})
diff --git a/spa/tests/lib/media.test.ts b/spa/tests/lib/media.test.ts
new file mode 100644
index 0000000..a021830
--- /dev/null
+++ b/spa/tests/lib/media.test.ts
@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest"
+import {
+  existingIds,
+  existingItem,
+  keyOf,
+  newPendingItem,
+  pendingFiles,
+} from "@/lib/media"
+
+const file = (name: string) => new File(["x"], name, { type: "image/jpeg" })
+
+describe("media items", () => {
+  it("separates what the server holds from what is still local", () => {
+    const items = [existingItem("on-server"), newPendingItem(file("new.jpg"))]
+
+    expect(existingIds(items)).toEqual(["on-server"])
+    expect(pendingFiles(items).map((each) => each.name)).toEqual(["new.jpg"])
+  })
+
+  it("gives every pending item its own key", () => {
+    const first = newPendingItem(file("a.jpg"))
+    const second = newPendingItem(file("a.jpg"))
+
+    expect(keyOf(first)).not.toBe(keyOf(second))
+  })
+
+  it("keys an existing item by its server id", () => {
+    expect(keyOf(existingItem("photo-7"))).toBe("photo-7")
+  })
+})
diff --git a/spa/tests/lib/outbox-sync.test.ts b/spa/tests/lib/outbox-sync.test.ts
new file mode 100644
index 0000000..d70c35d
--- /dev/null
+++ b/spa/tests/lib/outbox-sync.test.ts
@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import type * as ApiClient from "@/api/client"
+import { ApiError } from "@/api/client"
+import { emptyDraft } from "@/lib/entry-draft"
+import type { QueuedEntry } from "@/lib/store/outbox"
+
+// Hoisted alongside vi.mock, which runs before the imports above.
+const { entries, media, store } = vi.hoisted(() => ({
+  entries: { create: vi.fn() },
+  media: {
+    uploadPhoto: vi.fn(),
+    uploadVoiceMemo: vi.fn(),
+    deletePhoto: vi.fn(),
+    deleteVoiceMemo: vi.fn(),
+  },
+  store: {
+    queued: [] as unknown[],
+    dequeued: [] as string[],
+    attempts: [] as Array<{ id: string; error: string; counted: boolean }>,
+  },
+}))
+
+vi.mock("@/api/client", async () => {
+  const actual = await vi.importActual<typeof ApiClient>("@/api/client")
+
+  return { ApiError: actual.ApiError, entries, media }
+})
+
+vi.mock("@/lib/store/outbox", () => ({
+  queuedEntries: async () => store.queued,
+  dequeue: async (id: string) => {
+    store.dequeued.push(id)
+  },
+  noteAttempt: async (id: string, error: string, counted: boolean) => {
+    store.attempts.push({ id, error, counted })
+  },
+}))
+
+const { flushOutbox, MAX_AUTOMATIC_ATTEMPTS } =
+  await import("@/lib/outbox-sync")
+
+function queued(id: string, changes: Partial<QueuedEntry> = {}): QueuedEntry {
+  return {
+    id,
+    draft: { ...emptyDraft(), mood: 3 },
+    queuedAt: `2026-01-0${id}T10:00:00.000Z`,
+    attempts: 0,
+    ...changes,
+  }
+}
+
+describe("flushing the outbox", () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    store.queued = []
+    store.dequeued = []
+    store.attempts = []
+    entries.create.mockResolvedValue({ id: "server-id" })
+  })
+
+  it("sends the oldest entry first", async () => {
+    store.queued = [queued("1"), queued("2"), queued("3")]
+
+    await flushOutbox()
+
+    expect(store.dequeued).toEqual(["1", "2", "3"])
+  })
+
+  it("reports how many it sent", async () => {
+    store.queued = [queued("1"), queued("2")]
+
+    await expect(flushOutbox()).resolves.toEqual({ sent: 2, failed: 0 })
+  })
+
+  it("counts a refusal against the entry and records why", async () => {
+    store.queued = [queued("1")]
+    entries.create.mockRejectedValue(
+      new ApiError(422, "UNPROCESSABLE", "That activity is not yours")
+    )
+
+    await expect(flushOutbox()).resolves.toEqual({ sent: 0, failed: 1 })
+    expect(store.dequeued).toEqual([])
+    expect(store.attempts).toEqual([
+      { id: "1", error: "That activity is not yours", counted: true },
+    ])
+  })
+
+  it("does not count a failure that never reached the server", async () => {
+    // A connection that is down says nothing about whether the entry is good,
+    // so it must not burn through the entry's attempts.
+    store.queued = [queued("1")]
+    entries.create.mockRejectedValue(new Error("Network Error"))
+
+    await flushOutbox()
+
+    expect(store.attempts).toEqual([
+      { id: "1", error: "No connection to the server", counted: false },
+    ])
+  })
+
+  it("keeps sending the rest after one fails", async () => {
+    store.queued = [queued("1"), queued("2")]
+    entries.create
+      .mockRejectedValueOnce(new ApiError(422, "NOPE", "refused"))
+      .mockResolvedValueOnce({ id: "server-id" })
+
+    await expect(flushOutbox()).resolves.toEqual({ sent: 1, failed: 1 })
+    expect(store.dequeued).toEqual(["2"])
+  })
+
+  it("takes back media it uploaded when the entry never lands", async () => {
+    const withPhoto = queued("1")
+    withPhoto.draft.photos = [
+      { kind: "pending", localId: "local-1", file: new File([""], "a.jpg") },
+    ]
+    store.queued = [withPhoto]
+
+    media.uploadPhoto.mockResolvedValue({ id: "uploaded-photo" })
+    entries.create.mockRejectedValue(new ApiError(500, "BOOM", "server broke"))
+
+    await flushOutbox()
+
+    expect(media.uploadPhoto).toHaveBeenCalledOnce()
+    expect(media.deletePhoto).toHaveBeenCalledWith("uploaded-photo")
+  })
+
+  it("leaves alone an entry the server has refused too many times", async () => {
+    store.queued = [queued("1", { attempts: MAX_AUTOMATIC_ATTEMPTS })]
+
+    await expect(flushOutbox()).resolves.toEqual({ sent: 0, failed: 0 })
+    expect(entries.create).not.toHaveBeenCalled()
+  })
+})
diff --git a/spa/tests/lib/trend-buckets.test.ts b/spa/tests/lib/trend-buckets.test.ts
new file mode 100644
index 0000000..bbb5b37
--- /dev/null
+++ b/spa/tests/lib/trend-buckets.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest"
+import { aggregateTrend, bucketFor } from "@/lib/trend-buckets"
+import type { TrendPoint } from "@/hooks/use-trend"
+
+function day(date: string, mood: number, entryCount = 1): TrendPoint {
+  return { date, mood, entryCount }
+}
+
+describe("trend buckets", () => {
+  it("plots a day at a time over a week or a month", () => {
+    expect(bucketFor("week", 7)).toBe("day")
+    expect(bucketFor("month", 30)).toBe("day")
+  })
+
+  it("widens to weeks for a year and months beyond one", () => {
+    expect(bucketFor("year", 300)).toBe("week")
+    expect(bucketFor("all", 900)).toBe("month")
+  })
+
+  it("averages the days inside a bucket", () => {
+    const bars = aggregateTrend(
+      [day("2026-03-01", 2), day("2026-03-15", 4)],
+      "month"
+    )
+
+    expect(bars).toHaveLength(1)
+    expect(bars[0].average).toBe(3)
+  })
+
+  it("sums the entries behind a bucket, not the days", () => {
+    const bars = aggregateTrend(
+      [day("2026-03-01", 2, 3), day("2026-03-15", 4, 2)],
+      "month"
+    )
+
+    expect(bars[0].entryCount).toBe(5)
+  })
+
+  it("orders buckets oldest first", () => {
+    const bars = aggregateTrend(
+      [day("2026-05-02", 3), day("2026-01-02", 5), day("2026-03-02", 1)],
+      "month"
+    )
+
+    expect(bars.map((bar) => bar.average)).toEqual([5, 1, 3])
+  })
+
+  it("has nothing to plot for no days", () => {
+    expect(aggregateTrend([], "day")).toEqual([])
+  })
+})
diff --git a/spa/tests/lib/week.test.ts b/spa/tests/lib/week.test.ts
new file mode 100644
index 0000000..790124b
--- /dev/null
+++ b/spa/tests/lib/week.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest"
+import { rowOfWeek, weekStartsOn, weekdayInitials } from "@/lib/week"
+
+describe("week start", () => {
+  it("names seven weekdays beginning with the first day", () => {
+    const initials = weekdayInitials()
+
+    expect(initials).toHaveLength(7)
+    expect(new Set(initials).size).toBe(7)
+  })
+
+  it("puts the week's first day in the first row", () => {
+    expect(rowOfWeek(weekStartsOn())).toBe(0)
+  })
+
+  it("maps every weekday to a distinct row", () => {
+    const rows = [0, 1, 2, 3, 4, 5, 6].map(rowOfWeek)
+
+    expect(new Set(rows)).toEqual(new Set([0, 1, 2, 3, 4, 5, 6]))
+  })
+})
diff --git a/spa/tsconfig.json b/spa/tsconfig.json
index 23df526..5f75a4d 100644
--- a/spa/tsconfig.json
+++ b/spa/tsconfig.json
@@ -4,7 +4,8 @@
     "**/*.tsx",
     "eslint.config.js",
     "prettier.config.js",
-    "vite.config.ts"
+    "vite.config.ts",
+    "vitest.config.ts"
   ],
   "compilerOptions": {
     "target": "ES2022",
diff --git a/spa/vite.config.ts b/spa/vite.config.ts
index 390cd29..5cf5f30 100644
--- a/spa/vite.config.ts
+++ b/spa/vite.config.ts
@@ -4,9 +4,37 @@ import { TanStackRouterVite } from "@tanstack/router-plugin/vite"
 import viteReact from "@vitejs/plugin-react"
 import tailwindcss from "@tailwindcss/vite"
 
+/**
+ * The three dependencies every screen needs, each in one chunk. Left to itself
+ * the splitter emits dozens of sub-kilobyte files, where the request costs
+ * more than the code.
+ *
+ * Deliberately not a catch-all: a `node_modules` group would sweep the chart
+ * library and the date picker — which only two screens want — into a chunk
+ * that loads on first paint.
+ */
+const VENDOR_GROUPS = [
+  { name: "react", test: /node_modules[/\\](react|react-dom|scheduler)[/\\]/ },
+  { name: "base-ui", test: /node_modules[/\\]@base-ui[/\\]/ },
+  { name: "tanstack", test: /node_modules[/\\]@tanstack[/\\]/ },
+]
+
 const config = defineConfig({
   resolve: { tsconfigPaths: true },
   plugins: [devtools(), tailwindcss(), TanStackRouterVite(), viteReact()],
+  build: {
+    rolldownOptions: {
+      output: {
+        advancedChunks: {
+          minSize: 12_000,
+          groups: VENDOR_GROUPS.map((group, index) => ({
+            ...group,
+            priority: VENDOR_GROUPS.length - index,
+          })),
+        },
+      },
+    },
+  },
 })
 
 export default config
diff --git a/spa/vitest.config.ts b/spa/vitest.config.ts
new file mode 100644
index 0000000..4fa6bd2
--- /dev/null
+++ b/spa/vitest.config.ts
@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config"
+import { fileURLToPath } from "node:url"
+
+export default defineConfig({
+  resolve: {
+    alias: { "@": fileURLToPath(new URL("./src", import.meta.url)) },
+  },
+  test: {
+    environment: "jsdom",
+    include: ["tests/**/*.test.ts"],
+  },
+})