diff --git a/.gitignore b/.gitignore
index 38f082c..017aceb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,4 +7,5 @@
 config.toml
 .DS_Store
 spa/node_modules/
-spa/dist/
\ No newline at end of file
+spa/dist/
+.claude/
\ No newline at end of file
diff --git a/CODE_STYLE.md b/CODE_STYLE.md
index 48e4f72..a751c34 100644
--- a/CODE_STYLE.md
+++ b/CODE_STYLE.md
@@ -215,20 +215,15 @@ Constants are only for true invariants that never change. Tunable values belong
 
 ## Comments
 
-Zero comments unless explaining **why** something non-obvious is done.
+No comments. Not even to explain why — a comment is noise that drifts out of date while the code moves on.
 
-```rust
-// YES — explains a non-obvious constraint
-// BLAKE3 hash, not SHA-256, because iroh uses BLAKE3 for content addressing
-let hash = blake3::hash(&audio_data);
+When something non-obvious needs saying, put it somewhere that cannot rot silently:
 
-// NO — restates what the code does
-// Create a new track with the given metadata
-let track = Track::new(title, artist_id, duration, hash);
+- **A name.** Rename the function, the variable, or the type until the reason is visible in the code.
+- **A test.** A constraint worth a comment is worth a test that fails when someone breaks it. `media_is_resolved_before_the_cascade_runs` outlives any note explaining why the order matters.
+- **An ADR.** Architectural reasoning belongs in `docs/adr/`, where it is versioned and discoverable.
 
-// NO — references the task/ticket
-// Added for thesis requirement §3.2
-```
+This applies to doc comments too.
 
 ## Dependencies
 
@@ -240,24 +235,19 @@ let track = Track::new(title, artist_id, duration, hash);
 - Adapters: free to pull in platform crates (`axum`, `sqlx`, `iroh`, `nats`, etc.)
 - Bootstrap: wiring only
 
-## Generics Over Trait Objects
+## Trait Objects for Ports
 
-Use generics (static dispatch) for ports, not `dyn Trait`:
+Ports are `dyn` behind `Arc`. Static dispatch is not worth the ergonomic cost here — use cases hold their dependencies as trait objects:
 
 ```rust
-// YES — zero-cost, monomorphized
-pub struct StreamTrackUseCase<T: P2pTransportPort, R: TrackRepositoryPort> {
-    transport: T,
-    repository: R,
-}
-
-// NO — heap allocation, dynamic dispatch overhead
-pub struct StreamTrackUseCase {
-    transport: Box<dyn P2pTransportPort>,
-    repository: Box<dyn TrackRepositoryPort>,
+pub struct Deps {
+    pub entries: Arc<dyn MoodEntryCommandPort>,
+    pub events: Arc<dyn EventPublisherPort>,
 }
 ```
 
+Prefer a closed enum over `dyn` only where exhaustiveness is the point — when adding a variant must force every consumer to handle it (`MetricKind`, `CorrelationStrategy`). That is a decision about compiler-enforced coverage, not about dispatch cost.
+
 ## Testing
 
 ### Coverage Targets
@@ -283,6 +273,16 @@ crates/domain/
         └── track_test.rs
 ```
 
+### Fakes Must Not Be Kinder Than Production
+
+A fake that is more forgiving than the real adapter turns a test into a lie: it passes whichever way the code is written, which is worse than having no test. Two rules follow.
+
+**A fake must reproduce the constraints the database enforces.** SQLite removes dimension rows through `ON DELETE CASCADE`, so `InMemoryStore`'s cascade clears the dimension stores registered with it via `cascades_to`. Without that, the ordering requirement in `delete_entries_by_date_range` — resolve media *before* the cascade, or every blob is orphaned — could not be tested at all.
+
+**A fake must be able to fail.** Every port whose failure is meant to degrade rather than propagate needs a fake that refuses: `FakeMediaStorage::refusing_to_delete`, `FakeNowPlaying::failing`, `FakeRecordingLookup::failing`, `FakeWeatherLookup::failing`, `RefusingRejectionTrace`, `RefusingApiTokenStore`. A best-effort path with no failing test is a path that has never run.
+
+When a claim cannot be observed through the fake, move the test to where the real thing runs rather than asserting it against the fake's own behaviour.
+
 ### Test Naming
 
 Tests read as specifications:
diff --git a/CONTEXT.md b/CONTEXT.md
index d5825b2..52b2290 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -7,9 +7,13 @@ A personal mood tracking journal. Users log how they feel throughout the day, ta
 ### Core
 
 **MoodEntry**:
-A single mood record — the aggregate root. Every MoodEntry has exactly one Mood and belongs to exactly one User. May optionally include Activities, Content, photos, and voice memos. Multiple MoodEntries per day are allowed.
+A single mood record — the aggregate root. Carries exactly one Mood, the instant it was logged, and nothing else. Belongs to exactly one User. Everything else attaches as EntryDimensions. Multiple MoodEntries per Date are allowed.
 _Avoid_: Log, journal entry, record, mood log
 
+**EntryDimension**:
+An optional aspect of a MoodEntry, stored independently of it — Content, Activities, photos, voice memos, weather, location, song. Each kind is self-contained: it owns its own type, its own storage, and its own validation, and knows nothing about the others. A MoodEntry is complete without any of them.
+_Avoid_: Facet, attribute, extra, metadata, attachment
+
 **Mood**:
 One of five discrete states representing how the user feels, mapped to a 1–5 ordinal scale: Awful (1), Bad (2), Meh (3), Good (4), Rad (5). The ordering is a domain truth — Rad is better than Good. Required on every MoodEntry.
 _Avoid_: Feeling, emotion, state, score
@@ -29,11 +33,131 @@ _Avoid_: Group, section, type
 ### People
 
 **User**:
-A registered account identified by username and email. Has a role (Admin or User) and an optional timezone for analytics display. Owns their own Activity catalog, MoodEntries, and Reminders.
+A registered account identified by username and email. Has a role (Admin or User) and a Timezone. Owns their own Activity catalog, MoodEntries, and Reminders.
 _Avoid_: Account, member, profile
 
+**Timezone**:
+The IANA zone a User lives their days in. It is what turns an instant into a Date, so anything day-shaped — the calendar, a streak, a DailyMetric — is unanswerable without it. Clients set it from the platform; a User who somehow has none is told to set one rather than being given a silently wrong answer.
+_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.
 _Avoid_: Notification, alert, alarm, push
+
+### Measurement
+
+**DailyMetric**:
+A single measured or self-reported value for one User on one Date — a MetricKind plus its value. Not an aggregate; uniqueness of (User, Date, MetricKind) is a structural guarantee, not an invariant. Independent of MoodEntry: a Date may carry DailyMetrics with no MoodEntries and vice versa.
+_Avoid_: Health data, daily record, day log, stat, data point
+
+**Source**:
+Where a DailyMetric's value came from — either Manual, meaning the User stated it, or a Provider, meaning something else did. A DailyMetric sourced Manual is never overwritten by an import; a manual write always supersedes a Provider's.
+_Avoid_: Origin, author, integration
+
+**Provider**:
+An external system that supplies data. Identified only by name — the domain knows a Provider exists and what it claimed, never how it is reached, authenticated, or parsed. Which Providers exist is a deployment concern, not a domain one.
+_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.
+_Avoid_: API key, secret, personal access token, integration key
+
+**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
+
+**MetricKind**:
+The closed set of things a DailyMetric can measure: steps, sleep minutes, awake minutes, resting heart rate, HRV, exercise minutes, screen time minutes, alcoholic drinks. Each MetricKind owns its unit and its valid range — the unit is never carried alongside the value. Membership is earned: a MetricKind must have real day-to-day variance, be measured well enough to trust, and not restate one already present. Extending the set is the only way to support a new measurement.
+_Avoid_: Metric type, field, measurement name
+
+**Date**:
+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
+
+**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
+
+**RejectedMetric**:
+A reading that could not be used, kept where the account holder can read it — what arrived, from which Provider, on which Date, and why it was refused. Receives both readings that arrive broken from an importer and stored rows a later build can no longer read. Nothing in it was stored as a DailyMetric; it is a record of absence, not of data. Only the most recent are kept.
+_Avoid_: Error log, failed import, invalid metric, audit trail
+
+**CompleteBackup**:
+Everything an account knows, written so that nothing is lost if it has to be restored — every MoodEntry with every EntryDimension, every DailyMetric, every CycleStart, the Activity catalogue, Reminders, UserPreferences and all media. Restores through its own path, never through the importer that reads foreign formats. Carries no credentials and no RejectedMetrics.
+_Avoid_: Export, dump, archive, snapshot
+
+**ShareableExtract**:
+A readable document of mood, Content and Activities, for handing to another person. Carries nothing else — no Location, no Song, no DailyMetric, no CycleStart, no media — and cannot be restored from. Distinct from a CompleteBackup by intent, not by configuration: a single artifact with options would produce files that look like backups and are not.
+_Avoid_: Partial export, filtered export, share link
+
+### Ambient
+
+**Weather**:
+The conditions at the place and instant a MoodEntry was logged — a Condition and a temperature in celsius — expressed in one canonical vocabulary so that any two MoodEntries' Weather are comparable. Always attributed to a Provider, never to the User: Weather is observed, not stated, so a User editing an entry cannot remove it and absence from an edit is not a request to delete it. Resolved after the entry is saved, never during it.
+_Avoid_: Forecast, conditions, temperature
+
+**Condition**:
+The closed vocabulary Weather is expressed in — clear, cloudy, fog, drizzle, rain, snow, thunderstorm. The domain's words, not a Provider's: every Provider's own codes are mapped onto these at the boundary, because correlating across inconsistent labels means nothing. Deliberately coarse; a Provider distinguishing light from heavy rain reports rain.
+_Avoid_: Weather code, description, icon, summary
+
+**Location**:
+The coordinates a MoodEntry was logged at. Supplied by the client, optional, and the prerequisite for Weather.
+_Avoid_: GPS, position, place, geo
+
+**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
+
+**CyclePosition**:
+Where a Date sits in its cycle — the cycle day, counting from one, and the progress through the cycle from 0 at its start to 1 at its end. Both are derived. Progress is measured against the next CycleStart where one exists and against the median observed length where the cycle is still running, so a late cycle sits at its end rather than beyond it. A Date more than ninety days after the last CycleStart has no position: that is a missed record, not a long cycle.
+_Avoid_: Cycle phase, day number, cycle stage
+
+**UserPreferences**:
+The optional features a User has turned on. Separate from User, which carries identity and credentials — a preference is not a fact about who someone is. Absent until something is turned on, and every preference is off when absent.
+_Avoid_: Settings, options, config, flags
+
+**Song**:
+What a User was listening to when a MoodEntry was logged, held as its own title, artist, and album rather than as a pointer elsewhere — a MoodEntry stays readable with nothing else reachable. Carries an external recording identity when one is known, which is what makes two MoodEntries about the same recording comparable. Captured at the moment of logging only; a MoodEntry never acquires a Song later.
+_Avoid_: Track, music, now playing, recording
+
+**MoonPhase**:
+The lunar phase on a given Date. Derived from the Date on read and never stored — it is a function of the calendar, not an observation, so there is nothing to persist and no value that can go stale.
+_Avoid_: Lunar phase, moon
+
+### Background work
+
+**Job**:
+A record that some background work is wanted, carrying its kind, the thing it is about, its status, how many times it has been attempted and why the last attempt failed. Never the source of truth: no Job may be enqueued unless a query over stored data can independently rediscover the same work, so losing one costs promptness and never data. A Job that has used every attempt stops being retried and stays visible instead of vanishing.
+_Avoid_: Task, message, event, queue item
+
+**Sweep**:
+The query that rediscovers work from stored data — "songs with no recording identity" — and enqueues whatever it finds. What makes the queue safe to lose. Every Job kind owes one, and work that cannot be expressed as such a query does not belong on the queue.
+_Avoid_: Scan, reconciler, cron, catch-up
+
+### Analysis
+
+**DayMood**:
+The mean of every MoodEntry mood on one Date. The single mood value used wherever a Date needs one — analysis and calendar alike. A Date with no MoodEntries has no DayMood.
+_Avoid_: Dominant mood, average mood, daily mood, overall mood
+
+**CorrelationInput**:
+Anything a CorrelationStrategy can score against DayMood — every MetricKind, every Activity, plus MoonPhase, which is not a MetricKind because it is never stored. Each input's series has one shape: a MetricKind and MoonPhase are continuous, an Activity is presence, and a Strategy scores one shape, so an incompatible pairing cannot be constructed. Extending the set is deliberate: each input added costs an expected false positive across the whole result set.
+_Avoid_: Variable, factor, feature, predictor
+
+**Agreement**:
+How many of the Strategies that can score an input point the same way, out of how many apply. The headline for a result, in place of any single coefficient. An Activity has one applicable Strategy, so its agreement is one of one — which is a statement about the measurement, not a claim of corroboration.
+_Avoid_: Consensus, confidence, score, robustness
+
+**CorrelationStrategy**:
+A named method for scoring the relationship between a MetricKind and DayMood — Pearson, Spearman, Kendall, mean difference. Several are computed over the same data and every one returns the same shape, so they are directly comparable. Agreement among Strategies is the signal; no single Strategy's value is authoritative.
+_Avoid_: Algorithm, correlation method, analyzer, engine
+
+**Adjustment**:
+A correction applied across a whole set of CorrelationStrategy results to account for how many were tested at once. Operates on a set, never on a single result, and is therefore never itself a CorrelationStrategy. It marks results; it never hides them. Benjamini-Hochberg, controlling false discovery rate, at a configured threshold. A marked result held up once the number of comparisons in its Family was accounted for — a second axis of robustness beside Agreement, never a verdict.
+_Avoid_: Correction, p-value adjustment, filter, significance
+
+**Family**:
+The set of results one Adjustment is computed over. A Family is a question, not a screen: MetricKinds form one, Activities another, because how many Activities a User keeps has nothing to do with whether their sleep tracks their mood. Adjustment is computed per Family within a single CorrelationStrategy.
+_Avoid_: Group, test set, batch, comparison set
diff --git a/Cargo.lock b/Cargo.lock
index 650df82..b67ea2a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8,6 +8,16 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common 0.1.7",
+ "generic-array",
+]
+
 [[package]]
 name = "aead"
 version = "0.6.1"
@@ -15,7 +25,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1973cfbc1a2daf9cf550e74e1f088c28e7f7d8c1e1418fb6c9dc5184b7e84c99"
 dependencies = [
  "crypto-common 0.2.2",
- "inout",
+ "inout 0.2.2",
 ]
 
 [[package]]
@@ -24,7 +34,7 @@ version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8eb277bec05f56a0e0591f155a484cbd0f4f07ff2905051a48c72f004f7ed58"
 dependencies = [
- "cipher",
+ "cipher 0.5.2",
  "cpubits",
  "cpufeatures 0.3.0",
 ]
@@ -35,9 +45,9 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f2b8006a0c83f52b62ba44a97b58bf76fe2f70a329e588f67f89691d93d498f"
 dependencies = [
- "aead",
+ "aead 0.6.1",
  "aes",
- "cipher",
+ "cipher 0.5.2",
  "ctr",
  "ctutils",
  "ghash",
@@ -92,6 +102,7 @@ dependencies = [
  "config",
  "domain",
  "serde",
+ "serde_json",
  "thiserror 2.0.20",
  "utoipa",
  "uuid",
@@ -106,6 +117,8 @@ dependencies = [
  "chrono-tz",
  "config",
  "domain",
+ "exporter",
+ "importer",
  "thiserror 2.0.20",
  "tokio",
  "tracing",
@@ -150,6 +163,15 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "atomic"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89cbf775b137e9b968e67227ef7f775587cde3fd31b0d8599dbd0f598a48340"
+dependencies = [
+ "bytemuck",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -162,11 +184,14 @@ version = "0.1.0"
 dependencies = [
  "argon2",
  "async-trait",
+ "base64 0.23.1",
  "chrono",
  "config",
  "domain",
  "jsonwebtoken",
+ "rand 0.9.5",
  "serde",
+ "sha2 0.10.9",
  "uuid",
 ]
 
@@ -353,12 +378,42 @@ dependencies = [
  "hybrid-array",
 ]
 
+[[package]]
+name = "bootstrap"
+version = "0.1.0"
+dependencies = [
+ "application",
+ "auth",
+ "config",
+ "crypto",
+ "domain",
+ "event-publisher",
+ "exporter",
+ "http-axum",
+ "importer",
+ "music",
+ "reqwest",
+ "sqlite",
+ "storage",
+ "tokio",
+ "tracing",
+ "tracing-subscriber",
+ "weather",
+ "web-push-adapter",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
+[[package]]
+name = "bytemuck"
+version = "1.25.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797"
+
 [[package]]
 name = "byteorder"
 version = "1.5.0"
@@ -395,6 +450,17 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
 
+[[package]]
+name = "chacha20"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
+dependencies = [
+ "cfg-if",
+ "cipher 0.4.4",
+ "cpufeatures 0.2.17",
+]
+
 [[package]]
 name = "chacha20"
 version = "0.10.1"
@@ -406,6 +472,19 @@ dependencies = [
  "rand_core 0.10.1",
 ]
 
+[[package]]
+name = "chacha20poly1305"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
+dependencies = [
+ "aead 0.5.2",
+ "chacha20 0.9.1",
+ "cipher 0.4.4",
+ "poly1305",
+ "zeroize",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.45"
@@ -428,6 +507,18 @@ checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"
 dependencies = [
  "chrono",
  "phf",
+ "serde",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common 0.1.7",
+ "inout 0.1.4",
+ "zeroize",
 ]
 
 [[package]]
@@ -438,7 +529,7 @@ checksum = "e8cf2a2c93cd704877c0858356ed03480ff301ee950b43f1cbe4573b088bfa6c"
 dependencies = [
  "block-buffer 0.12.1",
  "crypto-common 0.2.2",
- "inout",
+ "inout 0.2.2",
 ]
 
 [[package]]
@@ -481,8 +572,10 @@ dependencies = [
 name = "config"
 version = "0.1.0"
 dependencies = [
+ "figment",
  "serde",
  "thiserror 2.0.20",
+ "tracing",
 ]
 
 [[package]]
@@ -598,6 +691,19 @@ version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
 
+[[package]]
+name = "crypto"
+version = "0.1.0"
+dependencies = [
+ "async-trait",
+ "base64 0.23.1",
+ "chacha20poly1305",
+ "config",
+ "domain",
+ "rand 0.9.5",
+ "tokio",
+]
+
 [[package]]
 name = "crypto-bigint"
 version = "0.5.5"
@@ -617,6 +723,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
+ "rand_core 0.6.4",
  "typenum",
 ]
 
@@ -664,7 +771,7 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baaca1c4b237092596f64d571e9db6ce4109c4ef9742e27590f1709594461f21"
 dependencies = [
- "cipher",
+ "cipher 0.5.2",
 ]
 
 [[package]]
@@ -765,6 +872,7 @@ version = "0.1.0"
 dependencies = [
  "async-trait",
  "chrono",
+ "chrono-tz",
  "email_address",
  "serde",
  "thiserror 2.0.20",
@@ -924,13 +1032,22 @@ dependencies = [
 name = "exporter"
 version = "0.1.0"
 dependencies = [
+ "api-types",
  "async-trait",
+ "chrono",
  "domain",
  "serde",
  "serde_json",
+ "tokio",
  "zip",
 ]
 
+[[package]]
+name = "fastrand"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
+
 [[package]]
 name = "ff"
 version = "0.13.1"
@@ -941,6 +1058,22 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "figment"
+version = "0.10.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cb01cd46b0cf372153850f4c6c272d9cbea2da513e07538405148f95bd789f3"
+dependencies = [
+ "atomic",
+ "parking_lot",
+ "pear",
+ "serde",
+ "tempfile",
+ "toml",
+ "uncased",
+ "version_check",
+]
+
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.11"
@@ -1117,6 +1250,18 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.4.3"
@@ -1126,7 +1271,7 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "r-efi",
+ "r-efi 6.0.0",
  "rand_core 0.10.1",
  "wasm-bindgen",
 ]
@@ -1558,11 +1703,14 @@ dependencies = [
 name = "importer"
 version = "0.1.0"
 dependencies = [
+ "api-types",
  "async-trait",
  "csv",
  "domain",
+ "exporter",
  "serde",
  "serde_json",
+ "tokio",
  "tracing",
  "zip",
 ]
@@ -1579,6 +1727,21 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "inlinable_string"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "inout"
 version = "0.2.2"
@@ -1779,6 +1942,12 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
 [[package]]
 name = "litemap"
 version = "0.8.3"
@@ -1821,6 +1990,16 @@ version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
 
+[[package]]
+name = "md-5"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
+dependencies = [
+ "cfg-if",
+ "digest 0.10.7",
+]
+
 [[package]]
 name = "md-5"
 version = "0.11.0"
@@ -1918,6 +2097,21 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "music"
+version = "0.1.0"
+dependencies = [
+ "async-trait",
+ "domain",
+ "md-5 0.10.6",
+ "rand 0.9.5",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "nix"
 version = "0.31.3"
@@ -2021,7 +2215,7 @@ dependencies = [
  "humantime",
  "hyper",
  "itertools",
- "md-5",
+ "md-5 0.11.0",
  "nix",
  "parking_lot",
  "percent-encoding",
@@ -2048,6 +2242,12 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
 [[package]]
 name = "openssl"
 version = "0.10.81"
@@ -2155,6 +2355,29 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "pear"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdeeaa00ce488657faba8ebf44ab9361f9365a97bd39ffb8a60663f57ff4b467"
+dependencies = [
+ "inlinable_string",
+ "pear_codegen",
+ "yansi",
+]
+
+[[package]]
+name = "pear_codegen"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bab5b985dc082b345f812b7df84e1bef27e7207b39e448439ba8bd69c93f147"
+dependencies = [
+ "proc-macro2",
+ "proc-macro2-diagnostics",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "pem"
 version = "0.8.3"
@@ -2252,6 +2475,17 @@ version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
 
+[[package]]
+name = "poly1305"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
+dependencies = [
+ "cpufeatures 0.2.17",
+ "opaque-debug",
+ "universal-hash 0.5.1",
+]
+
 [[package]]
 name = "polyval"
 version = "0.7.3"
@@ -2260,7 +2494,7 @@ checksum = "f0fa31d631f2b2cb2a544d0aa321ce847a94764d701ca2becc411138b93d49cd"
 dependencies = [
  "cpubits",
  "cpufeatures 0.3.0",
- "universal-hash",
+ "universal-hash 0.6.1",
 ]
 
 [[package]]
@@ -2305,6 +2539,19 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "proc-macro2-diagnostics"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "version_check",
+ "yansi",
+]
+
 [[package]]
 name = "quick-xml"
 version = "0.41.0"
@@ -2381,6 +2628,12 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
 [[package]]
 name = "r-efi"
 version = "6.0.0"
@@ -2394,17 +2647,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c"
 dependencies = [
  "libc",
- "rand_chacha",
+ "rand_chacha 0.3.1",
  "rand_core 0.6.4",
 ]
 
+[[package]]
+name = "rand"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
 [[package]]
 name = "rand"
 version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
 dependencies = [
- "chacha20",
+ "chacha20 0.10.1",
  "getrandom 0.4.3",
  "rand_core 0.10.1",
 ]
@@ -2419,6 +2682,16 @@ dependencies = [
  "rand_core 0.6.4",
 ]
 
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
 [[package]]
 name = "rand_core"
 version = "0.6.4"
@@ -2428,6 +2701,15 @@ dependencies = [
  "getrandom 0.2.17",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
 [[package]]
 name = "rand_core"
 version = "0.10.1"
@@ -2489,6 +2771,7 @@ checksum = "219c5811de6525e5416c7d5d53bb656d3afdbc6c5af816e0802bcfa42dbdc1c3"
 dependencies = [
  "base64 0.22.1",
  "bytes",
+ "encoding_rs",
  "futures-core",
  "futures-util",
  "h2",
@@ -2500,12 +2783,16 @@ dependencies = [
  "hyper-util",
  "js-sys",
  "log",
+ "mime",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
  "rustls",
  "rustls-pki-types",
  "rustls-platform-verifier",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
  "sync_wrapper",
  "tokio",
  "tokio-rustls",
@@ -2580,6 +2867,19 @@ dependencies = [
  "semver",
 ]
 
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "rustls"
 version = "0.23.43"
@@ -2827,12 +3127,16 @@ dependencies = [
  "application",
  "auth",
  "axum",
+ "bootstrap",
  "config",
+ "crypto",
  "domain",
  "event-publisher",
  "exporter",
  "http-axum",
  "importer",
+ "music",
+ "reqwest",
  "serde",
  "serde_json",
  "sqlite",
@@ -3048,6 +3352,7 @@ dependencies = [
  "config",
  "domain",
  "sqlx",
+ "tokio",
  "tracing",
  "uuid",
 ]
@@ -3185,7 +3490,7 @@ dependencies = [
  "hmac 0.13.0",
  "itoa",
  "log",
- "md-5",
+ "md-5 0.11.0",
  "memchr",
  "rand 0.10.2",
  "serde",
@@ -3342,6 +3647,19 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.3",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -3701,6 +4019,15 @@ version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
+[[package]]
+name = "uncased"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1b88fcfe09e89d3866a5c11019378088af2d24c3fbd4f0543f96b479ec90697"
+dependencies = [
+ "version_check",
+]
+
 [[package]]
 name = "unicase"
 version = "2.9.0"
@@ -3740,6 +4067,16 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common 0.1.7",
+ "subtle",
+]
+
 [[package]]
 name = "universal-hash"
 version = "0.6.1"
@@ -3872,6 +4209,15 @@ version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
+[[package]]
+name = "wasip2"
+version = "1.0.4+wasi-0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
+dependencies = [
+ "wit-bindgen",
+]
+
 [[package]]
 name = "wasix"
 version = "0.13.2"
@@ -3949,6 +4295,19 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "weather"
+version = "0.1.0"
+dependencies = [
+ "async-trait",
+ "chrono",
+ "domain",
+ "reqwest",
+ "serde",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "web-push"
 version = "0.11.0"
@@ -4177,12 +4536,36 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "worker"
+version = "0.1.0"
+dependencies = [
+ "application",
+ "bootstrap",
+ "config",
+ "domain",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
+[[package]]
+name = "yansi"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
+
 [[package]]
 name = "yoke"
 version = "0.8.3"
diff --git a/Cargo.toml b/Cargo.toml
index 5c9f498..74fe2d9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,11 +11,16 @@ members = [
     "crates/adapters/storage",
     "crates/adapters/event-publisher",
     "crates/adapters/importer",
+    "crates/adapters/crypto",
+    "crates/adapters/music",
     "crates/adapters/exporter",
+    "crates/adapters/weather",
     "crates/adapters/web-push",
+    "crates/bootstrap",
     "crates/server",
+    "crates/worker",
 ]
-default-members = ["crates/server"]
+default-members = ["crates/server", "crates/worker"]
 
 [workspace.package]
 edition = "2024"
@@ -32,8 +37,12 @@ auth = { path = "crates/adapters/auth" }
 storage = { path = "crates/adapters/storage" }
 event-publisher = { path = "crates/adapters/event-publisher" }
 importer = { path = "crates/adapters/importer" }
+crypto = { path = "crates/adapters/crypto" }
+music = { path = "crates/adapters/music" }
 exporter = { path = "crates/adapters/exporter" }
+weather = { path = "crates/adapters/weather" }
 web-push-adapter = { path = "crates/adapters/web-push" }
+bootstrap = { path = "crates/bootstrap" }
 csv = "1"
 zip = { version = "8", default-features = false, features = ["deflate"] }
 
@@ -42,6 +51,7 @@ async-trait = "0.1"
 uuid = { version = "1", features = ["v4", "serde"] }
 chrono = { version = "0.4", features = ["serde"] }
 serde = { version = "1", features = ["derive"] }
+figment = { version = "0.10", features = ["toml", "env"] }
 serde_json = "1"
 tokio = { version = "1", features = ["rt-multi-thread", "macros", "signal"] }
 tracing = "0.1"
@@ -50,13 +60,17 @@ axum = { version = "0.8", features = ["macros", "multipart"] }
 tower-http = { version = "0.7", features = ["cors", "trace", "fs"] }
 sqlx = { version = "0.9", features = ["runtime-tokio", "sqlite"] }
 email_address = "0.2"
-chrono-tz = "0.10"
+chrono-tz = { version = "0.10", features = ["serde"] }
 jsonwebtoken = { version = "11", features = ["aws_lc_rs"] }
 argon2 = { version = "0.5", features = ["std"] }
 object_store = { version = "0.14", features = ["aws"] }
 bytes = "1"
 base64 = "0.23"
-reqwest = { version = "0.13", default-features = false, features = ["rustls"] }
+chacha20poly1305 = "0.10"
+md-5 = "0.10"
+sha2 = "0.10"
+rand = "0.9"
+reqwest = { version = "0.13", default-features = false, features = ["rustls", "charset", "json", "query"] }
 utoipa = { version = "5", features = ["axum_extras", "chrono", "uuid"] }
 utoipa-scalar = { version = "0.3", features = ["axum"] }
 
diff --git a/Dockerfile b/Dockerfile
index 93ab819..d00a051 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -12,16 +12,20 @@ RUN apt-get update && apt-get install -y pkg-config libssl-dev && rm -rf /var/li
 COPY Cargo.toml Cargo.lock ./
 COPY crates/ ./crates/
 
-RUN cargo build --release --bin k-mood
+RUN cargo build --release --bin k-mood --bin k-mood-worker
 
 FROM debian:bookworm-slim
 RUN apt-get update && apt-get install -y ca-certificates wget libssl3 && rm -rf /var/lib/apt/lists/*
 COPY --from=builder /app/target/release/k-mood /usr/local/bin/k-mood
+COPY --from=builder /app/target/release/k-mood-worker /usr/local/bin/k-mood-worker
 COPY --from=frontend /app/spa/dist /spa/dist
 
 RUN mkdir -p /data
 VOLUME /data
 WORKDIR /data
 
+ENV KMOOD_STORAGE__DATA_DIR=/data
+ENV KMOOD_SERVER__SPA_DIR=/spa/dist
+
 EXPOSE 3000
 ENTRYPOINT ["k-mood"]
diff --git a/Makefile b/Makefile
index f285865..c62cc4d 100644
--- a/Makefile
+++ b/Makefile
@@ -1,25 +1,51 @@
-.PHONY: build dev check check-all test fmt run clean fix spa
+.PHONY: build dev dev-server dev-worker check check-all test fmt run run-server run-worker clean fix spa
+
+SERVER := k-mood
+WORKER := k-mood-worker
 
 build: spa
 	cargo build --release
 
-dev:
-	RUST_LOG=debug cargo run
-
 spa:
 	cd spa && bun install && bun run build
 
+# Runs the server with the worker beside it, which is how k-mood is meant to run:
+# reminders, session cleanup and enrichment all live in the worker. Stopping the
+# server stops both.
+run: build
+	@./target/release/$(WORKER) & \
+	WORKER_PID=$$!; \
+	trap "kill $$WORKER_PID 2>/dev/null || true" EXIT INT TERM; \
+	./target/release/$(SERVER)
+
+run-server: build
+	./target/release/$(SERVER)
+
+run-worker: build
+	./target/release/$(WORKER)
+
+dev:
+	@cargo build --bin $(SERVER) --bin $(WORKER)
+	@RUST_LOG=debug ./target/debug/$(WORKER) & \
+	WORKER_PID=$$!; \
+	trap "kill $$WORKER_PID 2>/dev/null || true" EXIT INT TERM; \
+	RUST_LOG=debug ./target/debug/$(SERVER)
+
+dev-server:
+	RUST_LOG=debug cargo run --bin $(SERVER)
+
+dev-worker:
+	RUST_LOG=debug cargo run --bin $(WORKER)
+
+# Lints tests and benches as well as the crates themselves: a warning in test
+# code is still a warning, and half the codebase is tests.
 check:
 	cargo fmt --all -- --check
-	cargo clippy -- -D warnings
-	cargo test
-	cd spa && bun run check && bun run typecheck
-
-check-all:
-	cargo fmt --all -- --check
-	cargo clippy --workspace -- -D warnings
+	cargo clippy --workspace --all-targets -- -D warnings
 	cargo test --workspace
-	cd spa && bun run check && bun run typecheck
+	cd spa && bun run check && bun run lint && bun run typecheck
+
+check-all: check
 
 test:
 	cargo test --workspace
@@ -28,12 +54,9 @@ fmt:
 	cargo fmt --all
 	cd spa && bun run format
 
-run: spa
-	cargo run --release
-
 fix:
 	cargo fmt --all
-	cargo clippy --fix --allow-dirty --allow-staged
+	cargo clippy --fix --workspace --all-targets --allow-dirty --allow-staged
 
 clean:
 	cargo clean
diff --git a/README.md b/README.md
index 01d1827..6ffc74a 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,19 @@
 # K-Mood
 
-Self-hosted mood tracking journal. Log your mood, activities, photos, and voice memos. Track trends, streaks, and correlations over time.
+Self-hosted mood tracking journal. Log how you feel, then find out what actually moves it.
 
 ## Features
 
 - **Mood tracking** with 5 discrete states (Awful, Bad, Meh, Good, Rad)
 - **Activities** with custom categories
-- **Rich entries** with markdown notes, photos, and voice memos
-- **Analytics** including mood trends, streaks, distribution, activity correlations, and calendar heatmap
-- **Import/Export** with Daylio CSV preset, generic CSV wizard, and full ZIP backup
+- **Rich entries** with markdown notes, photos, voice memos, location, and what you were listening to
+- **Daily metrics** — steps, sleep, resting heart rate, HRV, exercise, screen time, alcohol — entered by hand or imported from a phone
+- **Correlation** between anything measured and your mood, with several methods run side by side; agreement between them is the signal, not any single number
+- **Weather** resolved from an entry's location, and cycle tracking if you want it, both correlated like anything else
+- **Trends** including streaks, distribution, and a calendar heatmap
+- **Importer tokens** so a Shortcut or a cron script can send metrics without your password
+- **Import** from Daylio CSV or any CSV with a mapping wizard
+- **Two exports** that cannot be confused: a complete backup for keeping, and a readable journal for sharing
 - **Multi-user** with JWT authentication and per-user data isolation
 - **PWA** installable on mobile and desktop
 - **Self-hosted** with SQLite and local or S3 media storage
@@ -18,15 +23,23 @@ Self-hosted mood tracking journal. Log your mood, activities, photos, and voice
 ### Docker
 
 ```bash
-docker run -d \
+docker run -d --name k-mood \
   -p 3000:3000 \
   -v k-mood-data:/data \
   -e KMOOD_AUTH__JWT_SECRET=your-secret-here \
   ghcr.io/gabrielkaszewski/k-mood:latest
+
+docker run -d --name k-mood-worker \
+  -v k-mood-data:/data \
+  -e KMOOD_AUTH__JWT_SECRET=your-secret-here \
+  --entrypoint k-mood-worker \
+  ghcr.io/gabrielkaszewski/k-mood:latest
 ```
 
 Open `http://localhost:3000`, register an account, and start logging.
 
+The second container is the worker. Everything that happens on a schedule lives there — sending reminders, clearing expired sessions, resolving weather from an entry's location, and filling in the identity of songs logged while an upstream was unavailable. Run the server alone and none of that happens; nothing else breaks.
+
 ### Docker Compose
 
 ```yaml
@@ -40,41 +53,76 @@ services:
     environment:
       - KMOOD_AUTH__JWT_SECRET=your-secret-here
 
+  k-mood-worker:
+    image: ghcr.io/gabrielkaszewski/k-mood:latest
+    entrypoint: ["k-mood-worker"]
+    volumes:
+      - k-mood-data:/data
+    environment:
+      - KMOOD_AUTH__JWT_SECRET=your-secret-here
+    depends_on:
+      - k-mood
+
 volumes:
   k-mood-data:
 ```
 
 ### From Source
 
-Requires Rust 1.85+ and Bun.
+Requires Rust 1.88+ (the code uses let-chains, stable since 1.88) and Bun.
 
 ```bash
-# Build frontend
-cd spa && bun install && bun run build && cd ..
-
-# Build and run
-cargo run --release
+make run
 ```
 
+That builds the frontend, then starts the server with the worker beside it. Stopping the server stops both. `make run-server` and `make run-worker` start one at a time, `make dev` is the same pair with debug logging, and `make check` runs everything CI would.
+
 ## Configuration
 
-Copy `config.example.toml` to `config.toml` and adjust as needed.
+Three layers, each overriding the one before it: compiled-in defaults, then `config.toml`, then the environment. Copy `config.example.toml` to `config.toml` and adjust as needed — or set nothing at all and run on the defaults.
 
 | Section | Key | Default | Description |
 |---------|-----|---------|-------------|
 | `server` | `host` | `0.0.0.0` | Bind address |
 | `server` | `port` | `3000` | HTTP port |
 | `server.cors` | `allow_any_origin` | `true` | CORS policy |
-| `auth` | `jwt_secret` | `change-me-in-production` | JWT signing key |
+| `auth` | `jwt_secret` | none | JWT signing key. Required — the server refuses to start without it |
 | `auth` | `allow_registration` | `true` | Enable new user registration |
 | `storage` | `data_dir` | `./data` | SQLite and media storage path |
 | `storage.media` | `backend` | `local` | `local` or `s3` |
+| `analysis` | `minimum_sample_size` | `30` | Days needed before any correlation is shown |
+| `analysis` | `false_discovery_rate` | `0.10` | How often a marked correlation is expected to be a fluke |
+| `import` | `maximum_days_per_import` | `90` | Longest health import accepted in one request |
+| `import` | `rejections_kept` | `200` | Unusable readings kept per account, newest first |
+| `worker` | `look_up_weather` | `true` | Set `false` and no coordinates leave the machine |
+| `worker` | `most_attempts` | `5` | Failures before a job stops retrying and stays visible |
+| `worker` | `sweep_seconds` | `900` | How often stranded work is rediscovered |
+
+Every key has a default, so a section you leave out simply uses them. The full set with comments is in `config.example.toml`.
+
+### From the environment
+
+Every key has an environment twin: the prefix `KMOOD_`, a double underscore for each section you descend, and the key spelled as it is in the file.
+
+```bash
+KMOOD_SERVER__PORT=8080
+KMOOD_AUTH__JWT_SECRET=...
+KMOOD_STORAGE__DATA_DIR=/var/lib/kmood
+KMOOD_SERVER__CORS__ALLOW_ANY_ORIGIN=false
+KMOOD_WORKER__LOOK_UP_WEATHER=false
+```
+
+A single underscore stays inside a key name, so `data_dir` is written `DATA_DIR`; a double underscore descends a section. Lists are arrays — `KMOOD_SERVER__CORS__ALLOWED_ORIGINS=["https://a.example","https://b.example"]` — and the media backend switches the same way, with `KMOOD_STORAGE__MEDIA__BACKEND=s3` beside `KMOOD_STORAGE__MEDIA__BUCKET` and `KMOOD_STORAGE__MEDIA__REGION`.
+
+Secrets belong here rather than in a file: `auth.jwt_secret`, `push.vapid_private_key`, `provider.encryption_key`, and the S3 access and secret keys.
+
+`KMOOD_CONFIG_FILE` names a file other than `config.toml`. Having no `config.toml` is fine, since the defaults are a complete configuration — but a file you name that does not exist is an error, as are a malformed file and a value of the wrong type. The reasoning is in [ADR 0013](docs/adr/0013-configuration-layers-defaults-file-environment.md).
 
 ## Push Notifications
 
 K-Mood supports Web Push notifications (works on iOS 16.4+ when added to Home Screen, Android, and desktop browsers). No Firebase or third-party service required.
 
-**1. Generate a VAPID private key** (base64url-encoded, 32 bytes):
+**1. Generate a VAPID private key** (32 bytes, base64url or standard base64):
 
 ```bash
 python3 -c "
@@ -87,6 +135,8 @@ print(base64.urlsafe_b64encode(key[7:39]).rstrip(b'=').decode())
 "
 ```
 
+Standard base64 is accepted too: `+` and `/` are rewritten and any padding is stripped before use, so a key copied from a tool that emits the standard alphabet works unchanged.
+
 **2. Add to `config.toml`:**
 
 ```toml
@@ -96,9 +146,17 @@ vapid_private_key = "<output from step 1>"
 vapid_subject = "mailto:you@example.com"
 ```
 
+Or keep the key out of the file entirely:
+
+```bash
+KMOOD_PUSH__ENABLED=true
+KMOOD_PUSH__VAPID_PRIVATE_KEY=<output from step 1>
+KMOOD_PUSH__VAPID_SUBJECT=mailto:you@example.com
+```
+
 **3. Enable in the app:** Go to Settings and tap "Enable" under Notifications. Use "Send test notification" to verify it works.
 
-The server checks reminders every 60 seconds and sends push notifications to all subscribed devices for users with due reminders. Users must set a timezone in their profile for reminders to fire.
+The **worker** checks reminders every 60 seconds and sends push notifications to all subscribed devices for users with due reminders. Users must set a timezone in their profile for reminders to fire — and the worker must be running, or nothing is sent.
 
 ## Architecture
 
@@ -109,19 +167,29 @@ crates/
   domain/          Pure domain logic, entities, value objects, ports
   application/     Use cases as free-standing functions
   api-types/       Request/response DTOs and Zod-like validation
-  config/          Configuration types and defaults
+  config/          Configuration types, defaults, and the file/environment layering
   adapters/
     http-axum/     REST API (axum) + SPA serving
     sqlite/        SQLite persistence (sqlx)
     auth/          JWT + Argon2 authentication
     storage/       Media storage (local filesystem / S3)
     event-publisher/ Domain event bus (tokio mpsc)
-    importer/      Daylio CSV + generic import parsing
-    exporter/      ZIP export with media
-  server/          Composition root, startup, graceful shutdown
+    importer/      Daylio CSV, generic CSV, and backup reading
+    exporter/      Complete backup (ZIP) and shareable journal (Markdown)
+    music/         Subsonic now-playing, MusicBrainz recording lookup
+    weather/       Open-Meteo lookup, WMO codes mapped to our own vocabulary
+    crypto/        Provider credential encryption
+    web-push/      Reminder delivery
+  bootstrap/       Shared wiring, so both binaries build one object graph
+  server/          The HTTP binary (k-mood)
+  worker/          The background binary (k-mood-worker)
 spa/               React 19 SPA (TanStack Router, shadcn/ui, Tailwind v4)
 ```
 
+Two processes, one SQLite file. The server only serves; everything on a timer — reminders, session cleanup, enrichment — is the worker's. Background work is queued but the queue is deliberately losable: nothing is enqueued that a query over stored data cannot rediscover, so a lost job costs promptness and never data.
+
+Decisions with reasoning worth keeping are in `docs/adr/`, and the domain vocabulary is in `CONTEXT.md`.
+
 ## API
 
 Interactive API docs are available at `/docs` (Scalar UI) when the server is running. The OpenAPI spec is at `/openapi.json`.
diff --git a/config.dev.toml b/config.dev.toml
index e9c3e5c..57a5658 100644
--- a/config.dev.toml
+++ b/config.dev.toml
@@ -19,3 +19,22 @@ jwt_secret = "dev-secret-do-not-use-in-prod"
 access_token_ttl_seconds = 900
 refresh_token_ttl_seconds = 2592000
 allow_registration = true
+
+[analysis]
+minimum_sample_size = 30
+false_discovery_rate = 0.10
+
+[import]
+maximum_days_per_import = 90
+rejections_kept = 200
+
+[worker]
+poll_seconds = 15
+sweep_seconds = 900
+session_cleanup_seconds = 3600
+reminder_seconds = 60
+jobs_per_poll = 20
+enqueued_per_sweep = 200
+most_attempts = 5
+stalled_after_seconds = 300
+look_up_weather = true
diff --git a/config.example.toml b/config.example.toml
index 3417494..e261d0a 100644
--- a/config.example.toml
+++ b/config.example.toml
@@ -1,3 +1,8 @@
+# Every key here has an environment twin: prefix KMOOD_, a double underscore for
+# each section, the key as it is spelled below. KMOOD_SERVER__PORT sets server.port,
+# KMOOD_SERVER__CORS__ALLOW_ANY_ORIGIN sets server.cors.allow_any_origin. The
+# environment wins over this file, so secrets can stay out of it entirely.
+
 [server]
 host = "0.0.0.0"
 port = 3000
@@ -40,3 +45,30 @@ allow_registration = true
 # enabled = true
 # vapid_private_key = "<base64url-encoded 32-byte EC private key>"
 # vapid_subject = "mailto:you@example.com"
+
+[provider]
+# Base64-encoded 32-byte key that encrypts every user's music-service credential
+# at rest. Generate with: openssl rand -base64 32
+# Absent: provider connections are unavailable and the server logs this at startup.
+# Malformed: the server refuses to start rather than storing credentials the
+# operator believes are encrypted.
+# encryption_key = "<base64url-encoded 32-byte key>"
+
+[analysis]
+minimum_sample_size = 30
+false_discovery_rate = 0.10
+
+[import]
+maximum_days_per_import = 90
+rejections_kept = 200
+
+[worker]
+poll_seconds = 15
+sweep_seconds = 900
+session_cleanup_seconds = 3600
+reminder_seconds = 60
+jobs_per_poll = 20
+enqueued_per_sweep = 200
+most_attempts = 5
+stalled_after_seconds = 300
+look_up_weather = true
diff --git a/crates/adapters/auth/Cargo.toml b/crates/adapters/auth/Cargo.toml
index 136a165..8346b94 100644
--- a/crates/adapters/auth/Cargo.toml
+++ b/crates/adapters/auth/Cargo.toml
@@ -12,3 +12,9 @@ uuid.workspace = true
 serde.workspace = true
 jsonwebtoken.workspace = true
 argon2.workspace = true
+rand.workspace = true
+base64.workspace = true
+sha2.workspace = true
+
+[dev-dependencies]
+domain = { workspace = true, features = ["test-helpers"] }
diff --git a/crates/adapters/auth/src/api_token_secret.rs b/crates/adapters/auth/src/api_token_secret.rs
new file mode 100644
index 0000000..2c2a46b
--- /dev/null
+++ b/crates/adapters/auth/src/api_token_secret.rs
@@ -0,0 +1,31 @@
+use base64::Engine;
+use rand::RngCore;
+use sha2::{Digest, Sha256};
+
+use domain::api_token::TokenDigest;
+
+const SECRET_PREFIX: &str = "kmood_";
+const SECRET_BYTES: usize = 32;
+
+pub struct ApiTokenSecret;
+
+impl domain::ports::ApiTokenSecretPort for ApiTokenSecret {
+    fn mint(&self) -> String {
+        let mut bytes = [0u8; SECRET_BYTES];
+        rand::rng().fill_bytes(&mut bytes);
+
+        let body = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(bytes);
+
+        format!("{SECRET_PREFIX}{body}")
+    }
+
+    fn digest(&self, secret: &str) -> TokenDigest {
+        let digested = Sha256::digest(secret.as_bytes());
+
+        TokenDigest::from_persistence(hex(&digested))
+    }
+}
+
+fn hex(bytes: &[u8]) -> String {
+    bytes.iter().map(|byte| format!("{byte:02x}")).collect()
+}
diff --git a/crates/adapters/auth/src/lib.rs b/crates/adapters/auth/src/lib.rs
index 9adf624..6ab9390 100644
--- a/crates/adapters/auth/src/lib.rs
+++ b/crates/adapters/auth/src/lib.rs
@@ -1,5 +1,7 @@
+mod api_token_secret;
 mod jwt_service;
 mod password_hasher;
 
+pub use api_token_secret::ApiTokenSecret;
 pub use jwt_service::JwtAuthService;
 pub use password_hasher::Argon2PasswordHasher;
diff --git a/crates/adapters/auth/tests/api_token_secret_test.rs b/crates/adapters/auth/tests/api_token_secret_test.rs
new file mode 100644
index 0000000..3786a52
--- /dev/null
+++ b/crates/adapters/auth/tests/api_token_secret_test.rs
@@ -0,0 +1,62 @@
+use domain::ports::ApiTokenSecretPort;
+
+use auth::ApiTokenSecret;
+
+const HEX_CHARACTERS_IN_A_SHA256: usize = 64;
+
+#[test]
+fn a_minted_secret_announces_itself_so_a_scanner_can_spot_it() {
+    let minted = ApiTokenSecret.mint();
+
+    assert!(minted.starts_with("kmood_"), "got {minted}");
+    assert!(minted.len() > 40, "a secret needs real entropy: {minted}");
+}
+
+#[test]
+fn no_two_secrets_are_alike() {
+    let secrets: Vec<String> = (0..50).map(|_| ApiTokenSecret.mint()).collect();
+    let mut unique = secrets.clone();
+    unique.sort();
+    unique.dedup();
+
+    assert_eq!(unique.len(), secrets.len());
+}
+
+#[test]
+fn the_same_secret_always_digests_the_same_way() {
+    let secret = ApiTokenSecret.mint();
+
+    assert_eq!(
+        ApiTokenSecret.digest(&secret).value(),
+        ApiTokenSecret.digest(&secret).value()
+    );
+}
+
+#[test]
+fn different_secrets_digest_differently() {
+    let first = ApiTokenSecret.digest("kmood_one");
+    let second = ApiTokenSecret.digest("kmood_two");
+
+    assert_ne!(first.value(), second.value());
+}
+
+#[test]
+fn a_digest_gives_nothing_of_the_secret_away() {
+    let secret = ApiTokenSecret.mint();
+    let digest = ApiTokenSecret.digest(&secret);
+
+    assert_eq!(digest.value().len(), HEX_CHARACTERS_IN_A_SHA256);
+    assert!(!digest.value().contains(&secret));
+    assert!(!secret.contains(digest.value()));
+    assert!(digest.value().chars().all(|c| c.is_ascii_hexdigit()));
+}
+
+#[test]
+fn the_digest_matches_the_published_value_for_a_known_input() {
+    let digest = ApiTokenSecret.digest("abc");
+
+    assert_eq!(
+        digest.value(),
+        "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+    );
+}
diff --git a/crates/adapters/crypto/Cargo.toml b/crates/adapters/crypto/Cargo.toml
new file mode 100644
index 0000000..cbcf215
--- /dev/null
+++ b/crates/adapters/crypto/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "crypto"
+edition.workspace = true
+version.workspace = true
+
+[dependencies]
+domain.workspace = true
+config.workspace = true
+async-trait.workspace = true
+base64.workspace = true
+chacha20poly1305.workspace = true
+rand.workspace = true
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
diff --git a/crates/adapters/crypto/src/chacha_cipher.rs b/crates/adapters/crypto/src/chacha_cipher.rs
new file mode 100644
index 0000000..fa86461
--- /dev/null
+++ b/crates/adapters/crypto/src/chacha_cipher.rs
@@ -0,0 +1,68 @@
+use base64::Engine;
+use chacha20poly1305::aead::{Aead, KeyInit, OsRng, rand_core::RngCore};
+use chacha20poly1305::{Key, XChaCha20Poly1305, XNonce};
+
+use domain::errors::DomainError;
+use domain::provider::{CredentialCipher, EncryptedCredential};
+
+const KEY_BYTES: usize = 32;
+const NONCE_BYTES: usize = 24;
+
+pub struct ChaChaCredentialCipher {
+    cipher: XChaCha20Poly1305,
+}
+
+impl ChaChaCredentialCipher {
+    pub fn new(base64_key: &str) -> Result<Self, DomainError> {
+        let key_bytes = base64::engine::general_purpose::STANDARD
+            .decode(base64_key.trim())
+            .map_err(|_| {
+                DomainError::InvalidInput("credential encryption key must be base64".into())
+            })?;
+
+        if key_bytes.len() != KEY_BYTES {
+            return Err(DomainError::InvalidInput(format!(
+                "credential encryption key must decode to {KEY_BYTES} bytes, got {}",
+                key_bytes.len()
+            )));
+        }
+
+        Ok(Self {
+            cipher: XChaCha20Poly1305::new(Key::from_slice(&key_bytes)),
+        })
+    }
+}
+
+impl CredentialCipher for ChaChaCredentialCipher {
+    fn encrypt(&self, plaintext: &[u8]) -> Result<EncryptedCredential, DomainError> {
+        let mut nonce_bytes = [0u8; NONCE_BYTES];
+        OsRng.fill_bytes(&mut nonce_bytes);
+        let nonce = XNonce::from_slice(&nonce_bytes);
+
+        let ciphertext = self
+            .cipher
+            .encrypt(nonce, plaintext)
+            .map_err(|_| DomainError::InvalidInput("failed to encrypt credential".into()))?;
+
+        let mut sealed = nonce_bytes.to_vec();
+        sealed.extend_from_slice(&ciphertext);
+
+        Ok(EncryptedCredential::from_persistence(sealed))
+    }
+
+    fn decrypt(&self, credential: &EncryptedCredential) -> Result<Vec<u8>, DomainError> {
+        let sealed = credential.value();
+
+        if sealed.len() <= NONCE_BYTES {
+            return Err(DomainError::InvalidInput(
+                "stored credential is truncated".into(),
+            ));
+        }
+
+        let (nonce_bytes, ciphertext) = sealed.split_at(NONCE_BYTES);
+
+        self.cipher
+            .decrypt(XNonce::from_slice(nonce_bytes), ciphertext)
+            .map_err(|_| DomainError::InvalidInput("failed to decrypt credential".into()))
+    }
+}
diff --git a/crates/adapters/crypto/src/lib.rs b/crates/adapters/crypto/src/lib.rs
new file mode 100644
index 0000000..78f9bc8
--- /dev/null
+++ b/crates/adapters/crypto/src/lib.rs
@@ -0,0 +1,3 @@
+mod chacha_cipher;
+
+pub use chacha_cipher::ChaChaCredentialCipher;
diff --git a/crates/adapters/crypto/tests/cipher_test.rs b/crates/adapters/crypto/tests/cipher_test.rs
new file mode 100644
index 0000000..1646008
--- /dev/null
+++ b/crates/adapters/crypto/tests/cipher_test.rs
@@ -0,0 +1,77 @@
+use domain::provider::{CredentialCipher, EncryptedCredential};
+
+use crypto::ChaChaCredentialCipher;
+
+const TEST_KEY: &str = "gXqvVQF3v9pT2mKz8sYbN4jHcR7wLdE1uA0iO5tPxZk=";
+
+fn cipher() -> ChaChaCredentialCipher {
+    ChaChaCredentialCipher::new(TEST_KEY).unwrap()
+}
+
+#[test]
+fn a_credential_survives_a_round_trip() {
+    let cipher = cipher();
+    let secret = br#"{"url":"https://music.example","username":"gabriel","password":"hunter2"}"#;
+
+    let encrypted = cipher.encrypt(secret).unwrap();
+    let decrypted = cipher.decrypt(&encrypted).unwrap();
+
+    assert_eq!(decrypted, secret);
+}
+
+#[test]
+fn the_plaintext_never_appears_in_the_ciphertext() {
+    let cipher = cipher();
+
+    let encrypted = cipher.encrypt(b"hunter2").unwrap();
+
+    assert!(
+        !encrypted
+            .value()
+            .windows(7)
+            .any(|window| window == b"hunter2")
+    );
+}
+
+#[test]
+fn encrypting_the_same_secret_twice_gives_different_ciphertext() {
+    let cipher = cipher();
+
+    let first = cipher.encrypt(b"hunter2").unwrap();
+    let second = cipher.encrypt(b"hunter2").unwrap();
+
+    assert_ne!(first.value(), second.value());
+}
+
+#[test]
+fn a_tampered_credential_is_rejected_rather_than_silently_decrypted() {
+    let cipher = cipher();
+    let encrypted = cipher.encrypt(b"hunter2").unwrap();
+
+    let mut tampered = encrypted.value().to_vec();
+    let last = tampered.len() - 1;
+    tampered[last] ^= 0xff;
+
+    let result = cipher.decrypt(&EncryptedCredential::from_persistence(tampered));
+
+    assert!(result.is_err());
+}
+
+#[test]
+fn a_credential_encrypted_under_another_key_is_rejected() {
+    let other_key = "AAAAVQF3v9pT2mKz8sYbN4jHcR7wLdE1uA0iO5tPxZk=";
+    let encrypted = cipher().encrypt(b"hunter2").unwrap();
+
+    let result = ChaChaCredentialCipher::new(other_key)
+        .unwrap()
+        .decrypt(&encrypted);
+
+    assert!(result.is_err());
+}
+
+#[test]
+fn a_key_that_is_not_32_bytes_is_refused_at_construction() {
+    assert!(ChaChaCredentialCipher::new("dGhpcyBpcyB0b28gc2hvcnQ=").is_err());
+    assert!(ChaChaCredentialCipher::new("not-base64!!").is_err());
+    assert!(ChaChaCredentialCipher::new("").is_err());
+}
diff --git a/crates/adapters/exporter/Cargo.toml b/crates/adapters/exporter/Cargo.toml
index d5d5825..260c329 100644
--- a/crates/adapters/exporter/Cargo.toml
+++ b/crates/adapters/exporter/Cargo.toml
@@ -5,7 +5,14 @@ version.workspace = true
 
 [dependencies]
 domain.workspace = true
+api-types.workspace = true
+chrono.workspace = true
 async-trait.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 zip.workspace = true
+
+[dev-dependencies]
+domain = { workspace = true, features = ["test-helpers"] }
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
+chrono.workspace = true
diff --git a/crates/adapters/exporter/src/backup.rs b/crates/adapters/exporter/src/backup.rs
new file mode 100644
index 0000000..9b3d874
--- /dev/null
+++ b/crates/adapters/exporter/src/backup.rs
@@ -0,0 +1,185 @@
+use std::io::{Cursor, Write};
+
+use zip::ZipWriter;
+use zip::write::SimpleFileOptions;
+
+use chrono::Weekday;
+
+use api_types::dimension::DimensionPayload;
+use domain::activity::Activity;
+use domain::dimension::ComposedEntry;
+use domain::errors::DomainError;
+use domain::metric::DailyMetric;
+use domain::ports::UserBackup;
+use domain::reminder::Reminder;
+
+use super::shared::{io_err, json_err, zip_err};
+
+pub const BACKUP_FORMAT_VERSION: u32 = 2;
+pub const BACKUP_MANIFEST: &str = "backup.json";
+
+pub struct ZipBackupWriter;
+
+#[async_trait::async_trait]
+impl domain::ports::BackupWriterPort for ZipBackupWriter {
+    async fn write(&self, backup: &UserBackup) -> Result<Vec<u8>, DomainError> {
+        let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
+        let options =
+            SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
+
+        zip.start_file(BACKUP_MANIFEST, options).map_err(zip_err)?;
+        zip.write_all(&manifest(backup)?).map_err(io_err)?;
+
+        for photo in &backup.media.photos {
+            zip.start_file(format!("photos/{}", photo.id), options)
+                .map_err(zip_err)?;
+            zip.write_all(&photo.data).map_err(io_err)?;
+        }
+
+        for memo in &backup.media.voice_memos {
+            zip.start_file(format!("voice_memos/{}", memo.id), options)
+                .map_err(zip_err)?;
+            zip.write_all(&memo.data).map_err(io_err)?;
+        }
+
+        Ok(zip.finish().map_err(zip_err)?.into_inner())
+    }
+}
+
+fn manifest(backup: &UserBackup) -> Result<Vec<u8>, DomainError> {
+    let manifest = BackupManifest {
+        version: BACKUP_FORMAT_VERSION,
+        entries: backup.entries.iter().map(BackedUpEntry::from).collect(),
+        metrics: backup.metrics.iter().map(BackedUpMetric::from).collect(),
+        cycle_starts: backup
+            .cycle_starts
+            .iter()
+            .map(|start| start.date().to_string())
+            .collect(),
+        activities: backup
+            .activities
+            .iter()
+            .map(BackedUpActivity::from)
+            .collect(),
+        reminders: backup
+            .reminders
+            .iter()
+            .map(BackedUpReminder::from)
+            .collect(),
+        tracks_cycle: backup.preferences.tracks_cycle(),
+    };
+
+    serde_json::to_vec_pretty(&manifest).map_err(json_err)
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BackupManifest {
+    pub version: u32,
+    pub entries: Vec<BackedUpEntry>,
+    pub metrics: Vec<BackedUpMetric>,
+    pub cycle_starts: Vec<String>,
+    pub activities: Vec<BackedUpActivity>,
+    pub reminders: Vec<BackedUpReminder>,
+    pub tracks_cycle: bool,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BackedUpEntry {
+    pub mood: u8,
+    pub logged_at: String,
+    pub dimensions: Vec<DimensionPayload>,
+}
+
+impl From<&ComposedEntry> for BackedUpEntry {
+    fn from(composed: &ComposedEntry) -> Self {
+        Self {
+            mood: composed.entry.mood().value(),
+            logged_at: composed.entry.logged_at().to_rfc3339(),
+            dimensions: composed
+                .dimensions
+                .iter()
+                .map(DimensionPayload::from)
+                .collect(),
+        }
+    }
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BackedUpMetric {
+    pub date: String,
+    pub kind: String,
+    pub value: i64,
+    pub provider: Option<String>,
+}
+
+impl From<&DailyMetric> for BackedUpMetric {
+    fn from(metric: &DailyMetric) -> Self {
+        Self {
+            date: metric.date().to_string(),
+            kind: metric.kind().name().to_string(),
+            value: metric.value().count(),
+            provider: metric
+                .source()
+                .provider()
+                .map(|name| name.value().to_string()),
+        }
+    }
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BackedUpActivity {
+    pub id: String,
+    pub name: String,
+    pub category: Option<String>,
+    pub archived: bool,
+}
+
+impl From<&Activity> for BackedUpActivity {
+    fn from(activity: &Activity) -> Self {
+        Self {
+            id: activity.id().value().to_string(),
+            name: activity.name().value().to_string(),
+            category: activity.category().map(|c| c.value().to_string()),
+            archived: activity.is_archived(),
+        }
+    }
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BackedUpReminder {
+    pub enabled: bool,
+    pub monday: Option<String>,
+    pub tuesday: Option<String>,
+    pub wednesday: Option<String>,
+    pub thursday: Option<String>,
+    pub friday: Option<String>,
+    pub saturday: Option<String>,
+    pub sunday: Option<String>,
+}
+
+impl From<&Reminder> for BackedUpReminder {
+    fn from(reminder: &Reminder) -> Self {
+        let at = |day| {
+            reminder
+                .schedule()
+                .time_for(day)
+                .map(|time| time.format("%H:%M").to_string())
+        };
+
+        Self {
+            enabled: reminder.is_enabled(),
+            monday: at(Weekday::Mon),
+            tuesday: at(Weekday::Tue),
+            wednesday: at(Weekday::Wed),
+            thursday: at(Weekday::Thu),
+            friday: at(Weekday::Fri),
+            saturday: at(Weekday::Sat),
+            sunday: at(Weekday::Sun),
+        }
+    }
+}
diff --git a/crates/adapters/exporter/src/extract.rs b/crates/adapters/exporter/src/extract.rs
new file mode 100644
index 0000000..d70f021
--- /dev/null
+++ b/crates/adapters/exporter/src/extract.rs
@@ -0,0 +1,71 @@
+use std::collections::HashMap;
+
+use domain::dimension::ComposedEntry;
+use domain::errors::DomainError;
+use domain::ports::SharedExtract;
+
+const HEADING: &str = "# Mood journal";
+const PREAMBLE: &str = "A shareable extract: mood, what was written, and what was tagged. It deliberately carries \
+     nothing else — no places, no health readings, no cycle records — and it is not a backup.";
+
+pub struct MarkdownExtractWriter;
+
+#[async_trait::async_trait]
+impl domain::ports::ExtractWriterPort for MarkdownExtractWriter {
+    async fn write(&self, extract: &SharedExtract) -> Result<Vec<u8>, DomainError> {
+        let names: HashMap<String, String> = extract
+            .activities
+            .iter()
+            .map(|activity| {
+                (
+                    activity.id().value().to_string(),
+                    activity.name().value().to_string(),
+                )
+            })
+            .collect();
+
+        let mut entries: Vec<&ComposedEntry> = extract.entries.iter().collect();
+        entries.sort_by_key(|composed| *composed.entry.logged_at());
+
+        let mut document = format!("{HEADING}\n\n{PREAMBLE}\n");
+        let mut current_day = String::new();
+
+        for composed in entries {
+            let logged_at = composed.entry.logged_at();
+            let day = logged_at.format("%A %-d %B %Y").to_string();
+
+            if day != current_day {
+                document.push_str(&format!("\n## {day}\n"));
+                current_day = day;
+            }
+
+            document.push_str(&format!(
+                "\n**{}** — {:?}\n",
+                logged_at.format("%H:%M"),
+                composed.entry.mood()
+            ));
+
+            let tagged = tags(composed, &names);
+            if !tagged.is_empty() {
+                document.push_str(&format!("\n_{}_\n", tagged.join(", ")));
+            }
+
+            if let Some(content) = composed.content() {
+                document.push_str(&format!("\n{}\n", content.value()));
+            }
+        }
+
+        Ok(document.into_bytes())
+    }
+}
+
+fn tags(composed: &ComposedEntry, names: &HashMap<String, String>) -> Vec<String> {
+    composed
+        .activities()
+        .iter()
+        .map(|id| {
+            let id = id.value().to_string();
+            names.get(&id).cloned().unwrap_or(id)
+        })
+        .collect()
+}
diff --git a/crates/adapters/exporter/src/json_export.rs b/crates/adapters/exporter/src/json_export.rs
deleted file mode 100644
index 8bebcb8..0000000
--- a/crates/adapters/exporter/src/json_export.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-use std::io::{Cursor, Write};
-
-use zip::ZipWriter;
-use zip::write::SimpleFileOptions;
-
-use domain::errors::DomainError;
-use domain::ports::UserExport;
-
-pub struct JsonExportAdapter;
-
-#[async_trait::async_trait]
-impl domain::ports::ExportPort for JsonExportAdapter {
-    async fn export_user_data(&self, data: &UserExport) -> Result<Vec<u8>, DomainError> {
-        let buf = Cursor::new(Vec::new());
-        let mut zip = ZipWriter::new(buf);
-        let options =
-            SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
-
-        let json = build_data_json(data)?;
-        zip.start_file("data.json", options).map_err(zip_err)?;
-        zip.write_all(&json).map_err(io_err)?;
-
-        for photo in &data.photos {
-            zip.start_file(format!("photos/{}", photo.id), options)
-                .map_err(zip_err)?;
-            zip.write_all(&photo.data).map_err(io_err)?;
-        }
-
-        for memo in &data.voice_memos {
-            zip.start_file(format!("voice_memos/{}", memo.id), options)
-                .map_err(zip_err)?;
-            zip.write_all(&memo.data).map_err(io_err)?;
-        }
-
-        let cursor = zip.finish().map_err(zip_err)?;
-        Ok(cursor.into_inner())
-    }
-}
-
-fn build_data_json(data: &UserExport) -> Result<Vec<u8>, DomainError> {
-    let export = ExportData {
-        version: "1.0",
-        entries: data.entries.iter().map(EntryExport::from).collect(),
-        activities: data.activities.iter().map(ActivityExport::from).collect(),
-        reminder_count: data.reminders.len(),
-    };
-
-    serde_json::to_vec_pretty(&export)
-        .map_err(|e| DomainError::InvalidInput(format!("json serialization failed: {e}")))
-}
-
-fn zip_err(e: zip::result::ZipError) -> DomainError {
-    DomainError::InvalidInput(format!("zip error: {e}"))
-}
-
-fn io_err(e: std::io::Error) -> DomainError {
-    DomainError::InvalidInput(format!("io error: {e}"))
-}
-
-#[derive(serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-struct ExportData<'a> {
-    version: &'a str,
-    entries: Vec<EntryExport>,
-    activities: Vec<ActivityExport>,
-    reminder_count: usize,
-}
-
-#[derive(serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-struct EntryExport {
-    id: String,
-    mood: u8,
-    mood_label: String,
-    logged_at: String,
-    activities: Vec<String>,
-    content: Option<String>,
-    photos: Vec<String>,
-    voice_memos: Vec<String>,
-}
-
-impl From<&domain::entry::MoodEntry> for EntryExport {
-    fn from(entry: &domain::entry::MoodEntry) -> Self {
-        Self {
-            id: entry.id().value().to_string(),
-            mood: entry.mood().value(),
-            mood_label: format!("{:?}", entry.mood()),
-            logged_at: entry.logged_at().to_rfc3339(),
-            activities: entry
-                .activities()
-                .iter()
-                .map(|a| a.value().to_string())
-                .collect(),
-            content: entry.content().map(|c| c.value().to_string()),
-            photos: entry
-                .photos()
-                .iter()
-                .map(|p| p.value().to_string())
-                .collect(),
-            voice_memos: entry
-                .voice_memos()
-                .iter()
-                .map(|v| v.value().to_string())
-                .collect(),
-        }
-    }
-}
-
-#[derive(serde::Serialize)]
-#[serde(rename_all = "camelCase")]
-struct ActivityExport {
-    id: String,
-    name: String,
-    category: Option<String>,
-    archived: bool,
-}
-
-impl From<&domain::activity::Activity> for ActivityExport {
-    fn from(activity: &domain::activity::Activity) -> Self {
-        Self {
-            id: activity.id().value().to_string(),
-            name: activity.name().value().to_string(),
-            category: activity.category().map(|c| c.value().to_string()),
-            archived: activity.is_archived(),
-        }
-    }
-}
diff --git a/crates/adapters/exporter/src/lib.rs b/crates/adapters/exporter/src/lib.rs
index bb7a55f..7f116aa 100644
--- a/crates/adapters/exporter/src/lib.rs
+++ b/crates/adapters/exporter/src/lib.rs
@@ -1,3 +1,9 @@
-mod json_export;
+mod backup;
+mod extract;
+mod shared;
 
-pub use json_export::JsonExportAdapter;
+pub use backup::{
+    BACKUP_FORMAT_VERSION, BACKUP_MANIFEST, BackedUpActivity, BackedUpEntry, BackedUpMetric,
+    BackedUpReminder, BackupManifest, ZipBackupWriter,
+};
+pub use extract::MarkdownExtractWriter;
diff --git a/crates/adapters/exporter/src/shared.rs b/crates/adapters/exporter/src/shared.rs
new file mode 100644
index 0000000..11f4a51
--- /dev/null
+++ b/crates/adapters/exporter/src/shared.rs
@@ -0,0 +1,13 @@
+use domain::errors::DomainError;
+
+pub fn zip_err(error: zip::result::ZipError) -> DomainError {
+    DomainError::InvalidInput(format!("zip error: {error}"))
+}
+
+pub fn io_err(error: std::io::Error) -> DomainError {
+    DomainError::InvalidInput(format!("io error: {error}"))
+}
+
+pub fn json_err(error: serde_json::Error) -> DomainError {
+    DomainError::InvalidInput(format!("json error: {error}"))
+}
diff --git a/crates/adapters/exporter/tests/extract_test.rs b/crates/adapters/exporter/tests/extract_test.rs
new file mode 100644
index 0000000..0e1b6b8
--- /dev/null
+++ b/crates/adapters/exporter/tests/extract_test.rs
@@ -0,0 +1,132 @@
+use std::io::Read;
+
+use domain::activity::{Activity, ActivityName};
+use domain::dimension::{ComposedEntry, DimensionValue};
+use domain::entry::{Content, Mood, MoodEntry};
+use domain::location::Coordinates;
+use domain::metric::{DailyMetric, MetricValue, Source, Steps};
+use domain::ports::{BackupMedia, BackupWriterPort, ExtractWriterPort, SharedExtract, UserBackup};
+use domain::song::Song;
+use domain::user::{UserId, UserPreferences};
+
+use exporter::{MarkdownExtractWriter, ZipBackupWriter};
+
+fn at(instant: &str) -> chrono::DateTime<chrono::FixedOffset> {
+    chrono::DateTime::parse_from_rfc3339(instant).unwrap()
+}
+
+fn a_revealing_entry(owner: &UserId, exercise: &Activity) -> ComposedEntry {
+    ComposedEntry {
+        entry: MoodEntry::new(owner.clone(), Mood::Rad, at("2026-08-20T21:30:00+02:00")),
+        dimensions: vec![
+            DimensionValue::Content(Content::new("Long walk by the river").unwrap()),
+            DimensionValue::activities(vec![exercise.id().clone()]),
+            DimensionValue::Location(Coordinates::new(52.2297, 21.0122).unwrap()),
+            DimensionValue::Song(
+                Song::new("Teardrop", "Massive Attack", Some("Mezzanine".into()), None).unwrap(),
+            ),
+        ],
+    }
+}
+
+async fn extract_of(entries: Vec<ComposedEntry>, activities: Vec<Activity>) -> String {
+    let bytes = MarkdownExtractWriter
+        .write(&SharedExtract {
+            entries,
+            activities,
+        })
+        .await
+        .unwrap();
+
+    String::from_utf8(bytes).unwrap()
+}
+
+#[tokio::test]
+async fn the_extract_carries_the_journal_a_person_would_want_to_read() {
+    let owner = UserId::generate();
+    let exercise = Activity::new(owner.clone(), ActivityName::new("long walk").unwrap(), None);
+
+    let document = extract_of(vec![a_revealing_entry(&owner, &exercise)], vec![exercise]).await;
+
+    assert!(document.contains("Long walk by the river"), "{document}");
+    assert!(document.contains("Rad"), "{document}");
+    assert!(
+        document.contains("long walk"),
+        "the activity name is missing"
+    );
+    assert!(document.contains("Thursday 20 August 2026"), "{document}");
+}
+
+#[tokio::test]
+async fn the_extract_discloses_no_place_and_no_song() {
+    let owner = UserId::generate();
+    let exercise = Activity::new(owner.clone(), ActivityName::new("long walk").unwrap(), None);
+
+    let document = extract_of(vec![a_revealing_entry(&owner, &exercise)], vec![exercise]).await;
+
+    for secret in ["52.2", "21.0", "Massive Attack", "Teardrop", "Mezzanine"] {
+        assert!(
+            !document.contains(secret),
+            "the extract leaked {secret}:\n{document}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn the_extract_says_what_it_is_not() {
+    let document = extract_of(Vec::new(), Vec::new()).await;
+
+    assert!(document.contains("not a backup"), "{document}");
+}
+
+#[tokio::test]
+async fn a_backup_carries_everything_the_extract_leaves_out() {
+    let owner = UserId::generate();
+    let exercise = Activity::new(owner.clone(), ActivityName::new("long walk").unwrap(), None);
+
+    let backup = UserBackup {
+        entries: vec![a_revealing_entry(&owner, &exercise)],
+        metrics: vec![DailyMetric::new(
+            owner.clone(),
+            domain::entry::Date::from_persistence("2026-08-20".parse().unwrap()),
+            MetricValue::Steps(Steps::new(8_412).unwrap()),
+            Source::Manual,
+        )],
+        cycle_starts: vec![domain::cycle::CycleStartRestore::on(
+            domain::entry::Date::from_persistence("2026-08-01".parse().unwrap()),
+        )],
+        activities: vec![exercise],
+        reminders: Vec::new(),
+        preferences: UserPreferences::off_by_default(owner),
+        media: BackupMedia {
+            photos: Vec::new(),
+            voice_memos: Vec::new(),
+        },
+    };
+
+    let archive = ZipBackupWriter.write(&backup).await.unwrap();
+    let manifest = manifest_of(&archive);
+
+    for expected in [
+        "Long walk by the river",
+        "52.2297",
+        "Massive Attack",
+        "8412",
+        "2026-08-01",
+        "long walk",
+    ] {
+        assert!(
+            manifest.contains(expected),
+            "the backup is missing {expected}"
+        );
+    }
+}
+
+fn manifest_of(archive: &[u8]) -> String {
+    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(archive)).unwrap();
+    let mut file = zip.by_name("backup.json").expect("a backup has a manifest");
+    let mut manifest = String::new();
+    file.read_to_string(&mut manifest).unwrap();
+
+    manifest
+}
diff --git a/crates/adapters/http-axum/src/extractors/authenticated_user.rs b/crates/adapters/http-axum/src/extractors/authenticated_user.rs
index 631642b..1a6e99a 100644
--- a/crates/adapters/http-axum/src/extractors/authenticated_user.rs
+++ b/crates/adapters/http-axum/src/extractors/authenticated_user.rs
@@ -19,6 +19,12 @@ impl IntoResponse for AuthRejection {
 
 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,
@@ -29,7 +35,7 @@ where
     async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
         let app_state = AppState::from_ref(state);
 
-        let token = extract_bearer_token(parts)
+        let token = bearer_token(parts)
             .ok_or_else(|| AuthRejection("missing or invalid authorization header".into()))?;
 
         let user_id = app_state
@@ -42,7 +48,7 @@ where
     }
 }
 
-fn extract_bearer_token(parts: &Parts) -> Option<String> {
+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())
diff --git a/crates/adapters/http-axum/src/extractors/importing_provider.rs b/crates/adapters/http-axum/src/extractors/importing_provider.rs
new file mode 100644
index 0000000..ebcbfc9
--- /dev/null
+++ b/crates/adapters/http-axum/src/extractors/importing_provider.rs
@@ -0,0 +1,46 @@
+use axum::extract::{FromRef, FromRequestParts};
+use axum::http::request::Parts;
+
+use domain::provider::ProviderName;
+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 ImportingProvider {
+    pub user_id: UserId,
+    pub provider: ProviderName,
+}
+
+impl<S> FromRequestParts<S> for ImportingProvider
+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"))?;
+
+        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("importing needs an api token minted in settings"))?;
+
+        Ok(Self {
+            user_id: token.user_id().clone(),
+            provider: token.name().clone(),
+        })
+    }
+}
diff --git a/crates/adapters/http-axum/src/extractors/metric_writer.rs b/crates/adapters/http-axum/src/extractors/metric_writer.rs
new file mode 100644
index 0000000..6e32962
--- /dev/null
+++ b/crates/adapters/http-axum/src/extractors/metric_writer.rs
@@ -0,0 +1,53 @@
+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 76e6faf..d0fd249 100644
--- a/crates/adapters/http-axum/src/extractors/mod.rs
+++ b/crates/adapters/http-axum/src/extractors/mod.rs
@@ -1,7 +1,11 @@
-mod authenticated_user;
+pub mod authenticated_user;
+mod importing_provider;
+mod metric_writer;
 mod multipart;
 mod path_id;
 
 pub use authenticated_user::AuthenticatedUser;
+pub use importing_provider::ImportingProvider;
+pub use metric_writer::MetricWriter;
 pub use multipart::{extract_file_bytes, extract_media_upload};
 pub use path_id::PathId;
diff --git a/crates/adapters/http-axum/src/handlers/correlations.rs b/crates/adapters/http-axum/src/handlers/correlations.rs
new file mode 100644
index 0000000..0a58b35
--- /dev/null
+++ b/crates/adapters/http-axum/src/handlers/correlations.rs
@@ -0,0 +1,50 @@
+use axum::Json;
+use axum::extract::{Query, State};
+
+use api_types::requests::DateSpanParams;
+use api_types::responses::CorrelationRowResponse;
+use application::correlation::queries::CorrelationQuery;
+use application::correlation::use_cases::get_correlations;
+
+use crate::errors::ApiError;
+use crate::extractors::AuthenticatedUser;
+use crate::state::AppState;
+
+#[utoipa::path(get, path = "/api/v1/correlations", tag = "correlations", security(("bearer" = [])),
+    description = "Scores every metric kind, every active activity, and the moon as a control \
+                   against the mean mood of each day in the span. Every strategy that fits the \
+                   input is run and all of them are returned; agreement across them is the \
+                   headline, not any single coefficient. Rows come back in a fixed order and are \
+                   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>))
+)]
+pub async fn handle_list(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+    Query(params): Query<DateSpanParams>,
+) -> Result<Json<Vec<CorrelationRowResponse>>, ApiError> {
+    let span = params.into_span()?;
+
+    let deps = get_correlations::Deps {
+        entries: state.entry_query,
+        metrics: state.daily_metric_query,
+        activities: state.activity_query,
+        cycles: state.cycle_query,
+        weather_store: state.weather_store,
+        preferences: state.preferences_query,
+        users: state.user_query,
+    };
+
+    let query = CorrelationQuery {
+        user_id,
+        span,
+        minimum_sample_size: state.analysis_config.minimum_sample_size,
+        false_discovery_rate: state.analysis_config.false_discovery_rate,
+    };
+
+    let rows = get_correlations::execute(query, &deps).await?;
+
+    Ok(Json(rows.into_iter().map(Into::into).collect()))
+}
diff --git a/crates/adapters/http-axum/src/handlers/cycle.rs b/crates/adapters/http-axum/src/handlers/cycle.rs
new file mode 100644
index 0000000..8e62fd0
--- /dev/null
+++ b/crates/adapters/http-axum/src/handlers/cycle.rs
@@ -0,0 +1,109 @@
+use axum::Json;
+use axum::extract::{Path, State};
+use axum::http::StatusCode;
+
+use api_types::mappers::parse_date;
+use api_types::requests::SetPreferencesRequest;
+use api_types::responses::{CycleViewResponse, 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::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))
+)]
+pub async fn handle_read(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+) -> Result<Json<CycleViewResponse>, ApiError> {
+    let deps = read_cycle::Deps {
+        query: state.cycle_query,
+        preferences: state.preferences_query,
+        users: state.user_query,
+    };
+
+    let view = read_cycle::execute(user_id, &deps).await?;
+
+    Ok(Json(view.into()))
+}
+
+#[utoipa::path(put, path = "/api/v1/cycle/{date}", tag = "cycle", security(("bearer" = [])),
+    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))
+)]
+pub async fn handle_record(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+    Path(date): Path<String>,
+) -> Result<StatusCode, ApiError> {
+    let deps = record_cycle_start::Deps {
+        command: state.cycle_command,
+        preferences: state.preferences_query,
+    };
+
+    record_cycle_start::execute(user_id, parse_date(&date)?, &deps).await?;
+
+    Ok(StatusCode::NO_CONTENT)
+}
+
+#[utoipa::path(delete, path = "/api/v1/cycle/{date}", tag = "cycle", security(("bearer" = [])),
+    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))
+)]
+pub async fn handle_forget(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+    Path(date): Path<String>,
+) -> Result<StatusCode, ApiError> {
+    let deps = forget_cycle_start::Deps {
+        command: state.cycle_command,
+    };
+
+    forget_cycle_start::execute(user_id, parse_date(&date)?, &deps).await?;
+
+    Ok(StatusCode::NO_CONTENT)
+}
+
+#[utoipa::path(patch, path = "/api/v1/users/me/preferences", tag = "users", security(("bearer" = [])),
+    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))
+)]
+pub async fn handle_set_preferences(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+    Json(body): Json<SetPreferencesRequest>,
+) -> Result<Json<PreferencesResponse>, ApiError> {
+    let deps = set_preferences::Deps {
+        command: state.preferences_command,
+        query: state.preferences_query,
+    };
+
+    let preferences = set_preferences::execute(user_id, body.tracks_cycle, &deps).await?;
+
+    Ok(Json(preferences.into()))
+}
+
+#[utoipa::path(get, path = "/api/v1/users/me/preferences", tag = "users", security(("bearer" = [])),
+    responses((status = 200, body = PreferencesResponse))
+)]
+pub async fn handle_preferences(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+) -> Result<Json<PreferencesResponse>, ApiError> {
+    let preferences =
+        application::user::preferences::preferences_of(&user_id, &state.preferences_query).await?;
+
+    Ok(Json(preferences.into()))
+}
diff --git a/crates/adapters/http-axum/src/handlers/data.rs b/crates/adapters/http-axum/src/handlers/data.rs
new file mode 100644
index 0000000..edc9ae6
--- /dev/null
+++ b/crates/adapters/http-axum/src/handlers/data.rs
@@ -0,0 +1,117 @@
+use axum::Json;
+use axum::extract::{Multipart, State};
+use axum::http::{StatusCode, header};
+use axum::response::IntoResponse;
+
+use api_types::responses::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::state::AppState;
+
+const BACKUP_FILENAME: &str = "k-mood-complete-backup.zip";
+const EXTRACT_FILENAME: &str = "k-mood-shareable-journal.md";
+
+#[utoipa::path(get, path = "/api/v1/data/backup", tag = "data", security(("bearer" = [])),
+    description = "A complete backup: every entry with every dimension, every daily metric, \
+                   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"))
+)]
+pub async fn handle_backup(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+) -> Result<impl IntoResponse, ApiError> {
+    let deps = write_backup::Deps {
+        entries: state.entry_query,
+        dimensions: state.dimensions,
+        activities: state.activity_query,
+        reminders: state.reminder_query,
+        metrics: state.daily_metric_query,
+        cycles: state.cycle_query,
+        preferences: state.preferences_query,
+        media_storage: state.media_storage,
+        writer: state.backup_writer,
+    };
+
+    let archive = write_backup::execute(user_id, &deps).await?;
+
+    Ok(attachment("application/zip", BACKUP_FILENAME, archive))
+}
+
+#[utoipa::path(get, path = "/api/v1/data/extract", tag = "data", security(("bearer" = [])),
+    description = "A shareable journal: the mood, what was written and what was tagged, as a \
+                   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"))
+)]
+pub async fn handle_extract(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+) -> Result<impl IntoResponse, ApiError> {
+    let deps = write_extract::Deps {
+        entries: state.entry_query,
+        dimensions: state.dimensions,
+        activities: state.activity_query,
+        writer: state.extract_writer,
+    };
+
+    let document = write_extract::execute(user_id, &deps).await?;
+
+    Ok(attachment(
+        "text/markdown; charset=utf-8",
+        EXTRACT_FILENAME,
+        document,
+    ))
+}
+
+#[utoipa::path(post, path = "/api/v1/data/restore", tag = "data", security(("bearer" = [])),
+    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))
+)]
+pub async fn handle_restore(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+    multipart: Multipart,
+) -> Result<Json<RestoreOutcomeResponse>, ApiError> {
+    let data = extract_file_bytes(multipart).await?;
+
+    let deps = restore_backup::Deps {
+        reader: state.backup_reader,
+        entry_command: state.entry_command,
+        dimensions: state.dimensions,
+        activity_command: state.activity_command,
+        activity_query: state.activity_query,
+        reminder_command: state.reminder_command,
+        metrics: state.daily_metric_command,
+        cycles: state.cycle_command,
+        preferences_command: state.preferences_command,
+        preferences_query: state.preferences_query,
+        media_storage: state.media_storage,
+    };
+
+    let outcome = restore_backup::execute(RestoreBackupCommand { user_id, data }, &deps).await?;
+
+    Ok(Json(outcome.into()))
+}
+
+fn attachment(content_type: &str, filename: &str, body: Vec<u8>) -> impl IntoResponse {
+    (
+        StatusCode::OK,
+        [
+            (header::CONTENT_TYPE, content_type.to_string()),
+            (
+                header::CONTENT_DISPOSITION,
+                format!("attachment; filename=\"{filename}\""),
+            ),
+        ],
+        body,
+    )
+}
diff --git a/crates/adapters/http-axum/src/handlers/entries.rs b/crates/adapters/http-axum/src/handlers/entries.rs
index d59c82b..9d68071 100644
--- a/crates/adapters/http-axum/src/handlers/entries.rs
+++ b/crates/adapters/http-axum/src/handlers/entries.rs
@@ -2,27 +2,43 @@ use axum::Json;
 use axum::extract::{Path, Query, State};
 use axum::http::StatusCode;
 
-use api_types::mappers::correlation_response;
 use api_types::requests::{
     CreateEntryRequest, DateRangeParams, ListEntriesParams, ReplaceActivityRequest,
     UpdateEntryRequest,
 };
 use api_types::responses::{
-    BulkActionResponse, CalendarDayResponse, CorrelationResponse, EntryResponse, MoodStatsResponse,
+    BulkActionResponse, CalendarDayResponse, EntryResponse, MoodStatsResponse,
 };
+use application::entry::composition::EntryComposer;
 use application::entry::queries::{FilterByActivityQuery, FilterByMoodQuery, MoodStatsQuery};
 use application::entry::use_cases::{
     create_entry, delete_entries_by_date_range, delete_entry, filter_by_activity, filter_by_mood,
-    get_activity_correlation, get_calendar, get_entry, get_mood_stats, list_entries,
-    replace_activity, update_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 crate::errors::ApiError;
 use crate::extractors::{AuthenticatedUser, PathId};
 use crate::state::AppState;
 
+async fn compose(
+    dimensions: Vec<std::sync::Arc<dyn domain::ports::EntryDimensionPort>>,
+    entries: Vec<MoodEntry>,
+) -> Result<Vec<EntryResponse>, ApiError> {
+    let composed = EntryComposer::new(dimensions).compose(entries).await?;
+    Ok(composed.into_iter().map(EntryResponse::from).collect())
+}
+
+async fn compose_one(
+    dimensions: Vec<std::sync::Arc<dyn domain::ports::EntryDimensionPort>>,
+    entry: MoodEntry,
+) -> Result<EntryResponse, ApiError> {
+    let mut responses = compose(dimensions, vec![entry]).await?;
+    Ok(responses.remove(0))
+}
+
 #[utoipa::path(post, path = "/api/v1/entries", tag = "entries", security(("bearer" = [])),
     request_body = CreateEntryRequest,
     responses((status = 201, body = EntryResponse))
@@ -33,12 +49,17 @@ pub async fn handle_create(
     Json(body): Json<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 {
         entries: state.entry_command,
+        dimensions: state.dimensions.clone(),
         events: state.event_publisher,
     };
     let entry = create_entry::execute(cmd, &deps).await?;
-    Ok((StatusCode::CREATED, Json(EntryResponse::from(entry))))
+    Ok((
+        StatusCode::CREATED,
+        Json(compose_one(dimensions, entry).await?),
+    ))
 }
 
 #[utoipa::path(get, path = "/api/v1/entries/{id}", tag = "entries", security(("bearer" = [])),
@@ -50,11 +71,12 @@ pub async fn handle_get(
     AuthenticatedUser(user_id): AuthenticatedUser,
     PathId(entry_id): PathId<MoodEntryId>,
 ) -> Result<Json<EntryResponse>, ApiError> {
+    let dimensions = state.dimensions.clone();
     let deps = get_entry::Deps {
         query: state.entry_query,
     };
     let entry = get_entry::execute(entry_id, user_id, &deps).await?;
-    Ok(Json(EntryResponse::from(entry)))
+    Ok(Json(compose_one(dimensions, entry).await?))
 }
 
 #[utoipa::path(get, path = "/api/v1/entries", tag = "entries", security(("bearer" = [])),
@@ -67,11 +89,12 @@ pub async fn handle_list(
     Query(params): Query<ListEntriesParams>,
 ) -> Result<Json<Vec<EntryResponse>>, ApiError> {
     let query = params.into_query(user_id)?;
+    let dimensions = state.dimensions.clone();
     let deps = list_entries::Deps {
         query: state.entry_query,
     };
     let entries = list_entries::execute(query, &deps).await?;
-    Ok(Json(entries.into_iter().map(EntryResponse::from).collect()))
+    Ok(Json(compose(dimensions, entries).await?))
 }
 
 #[utoipa::path(patch, path = "/api/v1/entries/{id}", tag = "entries", security(("bearer" = [])),
@@ -86,14 +109,16 @@ pub async fn handle_update(
     Json(body): Json<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 {
         command: state.entry_command,
+        dimensions: state.dimensions.clone(),
         query: state.entry_query,
         media_storage: state.media_storage,
         events: state.event_publisher,
     };
     let entry = update_entry::execute(cmd, user_id, &deps).await?;
-    Ok(Json(EntryResponse::from(entry)))
+    Ok(Json(compose_one(dimensions, entry).await?))
 }
 
 #[utoipa::path(delete, path = "/api/v1/entries/{id}", tag = "entries", security(("bearer" = [])),
@@ -106,6 +131,7 @@ pub async fn handle_delete(
     PathId(entry_id): PathId<MoodEntryId>,
 ) -> Result<StatusCode, ApiError> {
     let deps = delete_entry::Deps {
+        dimensions: state.dimensions.clone(),
         command: state.entry_command,
         query: state.entry_query,
         events: state.event_publisher,
@@ -126,11 +152,12 @@ pub async fn handle_filter_by_mood(
 ) -> 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,
     };
     let entries = filter_by_mood::execute(query, &deps).await?;
-    Ok(Json(entries.into_iter().map(EntryResponse::from).collect()))
+    Ok(Json(compose(dimensions, entries).await?))
 }
 
 #[utoipa::path(get, path = "/api/v1/entries/filter/activity/{id}", tag = "entries", security(("bearer" = [])),
@@ -146,11 +173,12 @@ pub async fn handle_filter_by_activity(
         user_id,
         activity_id,
     };
+    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(entries.into_iter().map(EntryResponse::from).collect()))
+    Ok(Json(compose(dimensions, entries).await?))
 }
 
 #[utoipa::path(get, path = "/api/v1/entries/stats", tag = "entries", security(("bearer" = [])),
@@ -172,6 +200,7 @@ pub async fn handle_stats(
     };
     let query = MoodStatsQuery { user_id, range };
     let deps = get_mood_stats::Deps {
+        users: state.user_query.clone(),
         query: state.entry_query,
     };
     let stats = get_mood_stats::execute(query, &deps).await?;
@@ -189,7 +218,11 @@ pub async fn handle_calendar(
 ) -> Result<Json<Vec<CalendarDayResponse>>, ApiError> {
     let range = params.into_date_range()?;
     let deps = get_calendar::Deps {
+        users: state.user_query.clone(),
         query: state.entry_query,
+        dimensions: state.dimensions.clone(),
+        cycles: state.cycle_query,
+        preferences: state.preferences_query,
     };
     let days = get_calendar::execute(user_id, range, &deps).await?;
     Ok(Json(
@@ -197,32 +230,6 @@ pub async fn handle_calendar(
     ))
 }
 
-#[utoipa::path(get, path = "/api/v1/entries/correlation/{id}", tag = "entries", security(("bearer" = [])),
-    params(("id" = String, Path, description = "Activity ID"), ListEntriesParams),
-    responses((status = 200, body = CorrelationResponse))
-)]
-pub async fn handle_activity_correlation(
-    State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-    PathId(activity_id): PathId<ActivityId>,
-    Query(params): Query<ListEntriesParams>,
-) -> Result<Json<CorrelationResponse>, ApiError> {
-    let range = match (params.from, params.to) {
-        (Some(from), Some(to)) => {
-            let from = api_types::mappers::shared::parse_datetime(&from)?;
-            let to = api_types::mappers::shared::parse_datetime(&to)?;
-            Some(domain::entry::DateRange::new(from, to)?)
-        }
-        _ => None,
-    };
-    let deps = get_activity_correlation::Deps {
-        query: state.entry_query,
-    };
-    let correlation =
-        get_activity_correlation::execute(user_id, activity_id.clone(), range, &deps).await?;
-    Ok(Json(correlation_response(activity_id, correlation)))
-}
-
 #[utoipa::path(delete, path = "/api/v1/entries/bulk/delete", tag = "entries", security(("bearer" = [])),
     params(DateRangeParams),
     responses((status = 200, body = BulkActionResponse))
@@ -234,6 +241,8 @@ pub async fn handle_delete_by_date_range(
 ) -> Result<Json<BulkActionResponse>, ApiError> {
     let range = params.into_date_range()?;
     let deps = delete_entries_by_date_range::Deps {
+        query: state.entry_query.clone(),
+        dimensions: state.dimensions.clone(),
         cascade: state.cascade,
         media_storage: state.media_storage,
     };
diff --git a/crates/adapters/http-axum/src/handlers/import_export.rs b/crates/adapters/http-axum/src/handlers/import_export.rs
index 799e9e3..b910814 100644
--- a/crates/adapters/http-axum/src/handlers/import_export.rs
+++ b/crates/adapters/http-axum/src/handlers/import_export.rs
@@ -1,10 +1,7 @@
 use axum::Json;
 use axum::extract::{Multipart, State};
-use axum::http::header;
-use axum::response::IntoResponse;
 
 use api_types::responses::ImportResultResponse;
-use application::export::use_cases::export_user_data;
 use application::import::commands::ImportCommand;
 use application::import::use_cases::import_entries;
 
@@ -12,34 +9,6 @@ use crate::errors::ApiError;
 use crate::extractors::{AuthenticatedUser, extract_file_bytes};
 use crate::state::AppState;
 
-#[utoipa::path(get, path = "/api/v1/data/export", tag = "data", security(("bearer" = [])),
-    responses((status = 200, description = "ZIP archive with user data"))
-)]
-pub async fn handle_export(
-    State(state): State<AppState>,
-    AuthenticatedUser(user_id): AuthenticatedUser,
-) -> Result<impl IntoResponse, ApiError> {
-    let deps = export_user_data::Deps {
-        entry_query: state.entry_query,
-        activity_query: state.activity_query,
-        reminder_query: state.reminder_query,
-        media_storage: state.media_storage,
-        exporter: state.export_port.clone(),
-    };
-    let data = export_user_data::execute(user_id, &deps).await?;
-
-    Ok((
-        [
-            (header::CONTENT_TYPE, "application/zip"),
-            (
-                header::CONTENT_DISPOSITION,
-                "attachment; filename=\"k-mood-export.zip\"",
-            ),
-        ],
-        data,
-    ))
-}
-
 #[utoipa::path(post, path = "/api/v1/data/import", tag = "data", security(("bearer" = [])),
     responses((status = 200, body = ImportResultResponse))
 )]
@@ -57,6 +26,8 @@ pub async fn handle_import(
         entry_query: state.entry_query,
         activity_command: state.activity_command,
         activity_query: state.activity_query,
+        dimensions: state.dimensions.clone(),
+        users: state.user_query,
         preset: state.preset_config,
     };
     let result = import_entries::execute(cmd, &deps).await?;
diff --git a/crates/adapters/http-axum/src/handlers/metrics.rs b/crates/adapters/http-axum/src/handlers/metrics.rs
new file mode 100644
index 0000000..967459d
--- /dev/null
+++ b/crates/adapters/http-axum/src/handlers/metrics.rs
@@ -0,0 +1,127 @@
+use axum::Json;
+use axum::extract::{Path, Query, 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 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 crate::errors::ApiError;
+use crate::extractors::{AuthenticatedUser, ImportingProvider, MetricWriter};
+use crate::state::AppState;
+
+#[utoipa::path(get, path = "/api/v1/metrics", tag = "metrics", security(("bearer" = [])),
+    params(DateSpanParams),
+    responses((status = 200, body = Vec<DailyMetricResponse>))
+)]
+pub async fn handle_list(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+    Query(params): Query<DateSpanParams>,
+) -> Result<Json<Vec<DailyMetricResponse>>, ApiError> {
+    let span = params.into_span()?;
+
+    let deps = list_daily_metrics::Deps {
+        metrics: state.daily_metric_query,
+    };
+
+    let metrics = list_daily_metrics::execute(user_id, span, &deps).await?;
+
+    Ok(Json(metrics.into_iter().map(Into::into).collect()))
+}
+
+#[utoipa::path(put, path = "/api/v1/metrics/{date}", tag = "metrics", security(("bearer" = [])),
+    description = "States the given metrics for one day. A null value clears that kind instead, \
+                   after which a later provider import may report it again. Every kind may appear \
+                   only once per request.",
+    params(("date" = String, Path, description = "Calendar date, as YYYY-MM-DD")),
+    request_body = SetDailyMetricsRequest,
+    responses((status = 204))
+)]
+pub async fn handle_set(
+    State(state): State<AppState>,
+    writer: MetricWriter,
+    Path(date): Path<String>,
+    Json(body): Json<SetDailyMetricsRequest>,
+) -> Result<StatusCode, ApiError> {
+    let date = parse_date(&date)?;
+
+    let changes = body
+        .metrics
+        .into_iter()
+        .map(|payload| payload.into_change())
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let deps = set_daily_metrics::Deps {
+        metrics: state.daily_metric_command,
+        users: state.user_query,
+    };
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: writer.user_id,
+            date,
+            changes,
+            source: writer.source,
+        },
+        &deps,
+    )
+    .await?;
+
+    Ok(StatusCode::NO_CONTENT)
+}
+
+#[utoipa::path(post, path = "/api/v1/metrics/import", tag = "metrics", security(("bearer" = [])),
+    description = "Accepts a batch of days from an automation, authenticated by an api token and \
+                   nothing else. A payload carrying only some of the eight kinds is normal. Every \
+                   reading is judged on its own: the valid ones are stored and the rest are \
+                   rejected and written to a trace the account holder can read, so one bad value \
+                   never costs a night of good data. Values are never clamped. A reading the user \
+                   has stated by hand is reported as superseding the imported one, which is not a \
+                   rejection. Only a payload carrying more days than the configured limit is \
+                   refused outright.",
+    request_body = ImportDailyMetricsRequest,
+    responses((status = 200, body = ImportOutcomeResponse))
+)]
+pub async fn handle_import(
+    State(state): State<AppState>,
+    importer: ImportingProvider,
+    Json(body): Json<ImportDailyMetricsRequest>,
+) -> Result<Json<ImportOutcomeResponse>, ApiError> {
+    let deps = import_daily_metrics::Deps {
+        metrics: state.daily_metric_command,
+        rejections: state.rejection_command,
+    };
+
+    let outcome = import_daily_metrics::execute(
+        ImportDailyMetricsCommand {
+            user_id: importer.user_id,
+            provider: importer.provider,
+            days: body.into_days(),
+            maximum_days: state.import_config.maximum_days_per_import,
+        },
+        &deps,
+    )
+    .await?;
+
+    Ok(Json(outcome.into()))
+}
+
+#[utoipa::path(get, path = "/api/v1/metrics/rejections", tag = "metrics", security(("bearer" = [])),
+    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>))
+)]
+pub async fn handle_rejections(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+) -> Result<Json<Vec<RejectionResponse>>, ApiError> {
+    let rejections = state.rejection_query.find_recent_by_user(&user_id).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 ebc9181..39dcd30 100644
--- a/crates/adapters/http-axum/src/handlers/mod.rs
+++ b/crates/adapters/http-axum/src/handlers/mod.rs
@@ -1,8 +1,14 @@
 pub mod activities;
 pub mod auth;
+pub mod correlations;
+pub mod cycle;
+pub mod data;
 pub mod entries;
 pub mod import_export;
 pub mod media;
+pub mod metrics;
+pub mod providers;
 pub mod push;
 pub mod reminders;
+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
new file mode 100644
index 0000000..6e7e876
--- /dev/null
+++ b/crates/adapters/http-axum/src/handlers/providers.rs
@@ -0,0 +1,127 @@
+use axum::Json;
+use axum::extract::{Path, State};
+use axum::http::StatusCode;
+
+use api_types::dimension::DimensionPayload;
+use api_types::requests::ConnectProviderRequest;
+use api_types::responses::ProviderConnectionResponse;
+use application::provider::commands::ConnectProviderCommand;
+use application::provider::use_cases::{
+    connect_provider, disconnect_provider, get_now_playing, list_connections,
+};
+use domain::dimension::DimensionValue;
+use domain::errors::DomainError;
+use domain::provider::ProviderName;
+
+use crate::errors::ApiError;
+use crate::extractors::AuthenticatedUser;
+use crate::state::AppState;
+
+fn cipher(
+    state: &AppState,
+) -> Result<std::sync::Arc<dyn domain::provider::CredentialCipher>, ApiError> {
+    state.credential_cipher.clone().ok_or_else(|| {
+        DomainError::InvalidInput(
+            "provider connections are unavailable: no credential encryption key is configured"
+                .into(),
+        )
+        .into()
+    })
+}
+
+#[utoipa::path(get, path = "/api/v1/providers", tag = "providers", security(("bearer" = [])),
+    responses((status = 200, body = Vec<ProviderConnectionResponse>))
+)]
+pub async fn handle_list(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+) -> Result<Json<Vec<ProviderConnectionResponse>>, ApiError> {
+    let deps = list_connections::Deps {
+        query: state.provider_connection_query,
+    };
+    let connections = list_connections::execute(user_id, &deps).await?;
+
+    Ok(Json(connections.into_iter().map(Into::into).collect()))
+}
+
+#[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))
+)]
+pub async fn handle_connect(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+    Path(provider): Path<String>,
+    Json(body): Json<ConnectProviderRequest>,
+) -> Result<StatusCode, ApiError> {
+    let cipher = cipher(&state)?;
+    let provider = ProviderName::new(provider)?;
+
+    let credential = serde_json::to_vec(&body.credential)
+        .map_err(|_| DomainError::InvalidInput("credential must be a JSON object".into()))?;
+
+    let deps = connect_provider::Deps {
+        command: state.provider_connection_command,
+        cipher,
+    };
+
+    connect_provider::execute(
+        ConnectProviderCommand {
+            user_id,
+            provider,
+            credential,
+        },
+        &deps,
+    )
+    .await?;
+
+    Ok(StatusCode::NO_CONTENT)
+}
+
+#[utoipa::path(delete, path = "/api/v1/providers/{provider}", tag = "providers", security(("bearer" = [])),
+    params(("provider" = String, Path, description = "Provider name")),
+    responses((status = 204))
+)]
+pub async fn handle_disconnect(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+    Path(provider): Path<String>,
+) -> Result<StatusCode, ApiError> {
+    let provider = ProviderName::new(provider)?;
+
+    let deps = disconnect_provider::Deps {
+        command: state.provider_connection_command,
+    };
+
+    disconnect_provider::execute(user_id, provider, &deps).await?;
+
+    Ok(StatusCode::NO_CONTENT)
+}
+
+#[utoipa::path(get, path = "/api/v1/providers/now-playing", tag = "providers", security(("bearer" = [])),
+    responses((status = 200, body = Option<DimensionPayload>))
+)]
+pub async fn handle_now_playing(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+) -> Result<Json<Option<DimensionPayload>>, ApiError> {
+    let cipher = cipher(&state)?;
+
+    let now_playing = state.now_playing.clone().ok_or_else(|| -> ApiError {
+        DomainError::InvalidInput("no music provider is configured".into()).into()
+    })?;
+
+    let deps = get_now_playing::Deps {
+        query: state.provider_connection_query,
+        cipher,
+        now_playing,
+        recordings: state.recording_lookup,
+    };
+
+    let song = get_now_playing::execute(user_id, &deps).await?;
+
+    Ok(Json(song.map(|song| {
+        DimensionPayload::from(&DimensionValue::Song(song))
+    })))
+}
diff --git a/crates/adapters/http-axum/src/handlers/tokens.rs b/crates/adapters/http-axum/src/handlers/tokens.rs
new file mode 100644
index 0000000..5df15ea
--- /dev/null
+++ b/crates/adapters/http-axum/src/handlers/tokens.rs
@@ -0,0 +1,80 @@
+use axum::Json;
+use axum::extract::State;
+use axum::http::StatusCode;
+
+use api_types::requests::MintApiTokenRequest;
+use api_types::responses::{ApiTokenResponse, 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::provider::ProviderName;
+
+use crate::errors::ApiError;
+use crate::extractors::{AuthenticatedUser, PathId};
+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>))
+)]
+pub async fn handle_list(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+) -> Result<Json<Vec<ApiTokenResponse>>, ApiError> {
+    let deps = list_api_tokens::Deps {
+        query: state.api_token_query,
+    };
+
+    let tokens = list_api_tokens::execute(user_id, &deps).await?;
+
+    Ok(Json(tokens.into_iter().map(Into::into).collect()))
+}
+
+#[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.",
+    request_body = MintApiTokenRequest,
+    responses((status = 201, body = MintedApiTokenResponse))
+)]
+pub async fn handle_mint(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+    Json(body): Json<MintApiTokenRequest>,
+) -> Result<(StatusCode, Json<MintedApiTokenResponse>), ApiError> {
+    let deps = mint_api_token::Deps {
+        command: state.api_token_command,
+        secrets: state.api_token_secrets,
+    };
+
+    let minted = mint_api_token::execute(
+        MintApiTokenCommand {
+            user_id,
+            name: ProviderName::new(body.name)?,
+        },
+        &deps,
+    )
+    .await?;
+
+    Ok((StatusCode::CREATED, Json(minted.into())))
+}
+
+#[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))
+)]
+pub async fn handle_revoke(
+    State(state): State<AppState>,
+    AuthenticatedUser(user_id): AuthenticatedUser,
+    PathId(token_id): PathId<ApiTokenId>,
+) -> Result<StatusCode, ApiError> {
+    let deps = revoke_api_token::Deps {
+        command: state.api_token_command,
+    };
+
+    revoke_api_token::execute(user_id, token_id, &deps).await?;
+
+    Ok(StatusCode::NO_CONTENT)
+}
diff --git a/crates/adapters/http-axum/src/handlers/users.rs b/crates/adapters/http-axum/src/handlers/users.rs
index 1e25737..0564155 100644
--- a/crates/adapters/http-axum/src/handlers/users.rs
+++ b/crates/adapters/http-axum/src/handlers/users.rs
@@ -97,6 +97,7 @@ pub async fn handle_delete(
     AuthenticatedUser(user_id): AuthenticatedUser,
 ) -> 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,
@@ -115,6 +116,7 @@ pub async fn handle_clear_data(
     AuthenticatedUser(user_id): AuthenticatedUser,
 ) -> 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,
diff --git a/crates/adapters/http-axum/src/openapi.rs b/crates/adapters/http-axum/src/openapi.rs
index 78fc9d0..19d5769 100644
--- a/crates/adapters/http-axum/src/openapi.rs
+++ b/crates/adapters/http-axum/src/openapi.rs
@@ -10,6 +10,10 @@ use utoipa::{Modify, OpenApi};
     ),
     modifiers(&SecurityAddon),
     paths(
+        crate::handlers::providers::handle_list,
+        crate::handlers::providers::handle_connect,
+        crate::handlers::providers::handle_disconnect,
+        crate::handlers::providers::handle_now_playing,
         crate::handlers::auth::handle_login,
         crate::handlers::auth::handle_refresh,
         crate::handlers::auth::handle_logout,
@@ -22,7 +26,6 @@ use utoipa::{Modify, OpenApi};
         crate::handlers::entries::handle_filter_by_activity,
         crate::handlers::entries::handle_stats,
         crate::handlers::entries::handle_calendar,
-        crate::handlers::entries::handle_activity_correlation,
         crate::handlers::entries::handle_delete_by_date_range,
         crate::handlers::entries::handle_replace_activity,
         crate::handlers::activities::handle_create,
@@ -50,12 +53,27 @@ use utoipa::{Modify, OpenApi};
         crate::handlers::media::handle_serve_voice_memo,
         crate::handlers::media::handle_delete_photo,
         crate::handlers::media::handle_delete_voice_memo,
-        crate::handlers::import_export::handle_export,
+        crate::handlers::data::handle_backup,
+        crate::handlers::data::handle_extract,
+        crate::handlers::data::handle_restore,
         crate::handlers::import_export::handle_import,
         crate::handlers::push::handle_vapid_key,
         crate::handlers::push::handle_subscribe,
         crate::handlers::push::handle_unsubscribe,
         crate::handlers::push::handle_test,
+        crate::handlers::correlations::handle_list,
+        crate::handlers::cycle::handle_read,
+        crate::handlers::cycle::handle_record,
+        crate::handlers::cycle::handle_forget,
+        crate::handlers::cycle::handle_preferences,
+        crate::handlers::cycle::handle_set_preferences,
+        crate::handlers::tokens::handle_list,
+        crate::handlers::tokens::handle_mint,
+        crate::handlers::tokens::handle_revoke,
+        crate::handlers::metrics::handle_list,
+        crate::handlers::metrics::handle_import,
+        crate::handlers::metrics::handle_rejections,
+        crate::handlers::metrics::handle_set,
     ),
     components(schemas(
         api_types::requests::CreateEntryRequest,
@@ -83,9 +101,30 @@ use utoipa::{Modify, OpenApi};
         api_types::responses::MoodFrequency,
         api_types::responses::CalendarDayResponse,
         api_types::responses::BulkActionResponse,
-        api_types::responses::CorrelationResponse,
         api_types::responses::ImportResultResponse,
+        api_types::responses::RestoreOutcomeResponse,
         api_types::responses::MediaIdResponse,
+        api_types::requests::SetDailyMetricsRequest,
+        api_types::requests::MetricPayload,
+        api_types::requests::DateSpanParams,
+        api_types::responses::DailyMetricResponse,
+        api_types::requests::MintApiTokenRequest,
+        api_types::requests::SetPreferencesRequest,
+        api_types::responses::CycleViewResponse,
+        api_types::responses::CyclePositionResponse,
+        api_types::responses::PreferencesResponse,
+        api_types::requests::ImportDailyMetricsRequest,
+        api_types::requests::ImportedDayPayload,
+        api_types::requests::ImportedMetricPayload,
+        api_types::responses::ImportOutcomeResponse,
+        api_types::responses::RejectedMetricResponse,
+        api_types::responses::RejectionResponse,
+        api_types::responses::ApiTokenResponse,
+        api_types::responses::MintedApiTokenResponse,
+        api_types::responses::CorrelationRowResponse,
+        api_types::responses::CorrelationInputResponse,
+        api_types::responses::AgreementResponse,
+        api_types::responses::StrategyScoreResponse,
         api_types::requests::PushSubscribeRequest,
         api_types::requests::PushUnsubscribeRequest,
     )),
@@ -98,6 +137,10 @@ use utoipa::{Modify, OpenApi};
         (name = "media", description = "Photo and voice memo storage"),
         (name = "data", description = "Import and export"),
         (name = "push", description = "Push notifications"),
+        (name = "metrics", description = "Daily metrics"),
+        (name = "correlations", description = "Correlation between metrics and mood"),
+        (name = "tokens", description = "API tokens for headless importers"),
+        (name = "cycle", description = "Menstrual cycle starts and derived cycle day"),
     )
 )]
 pub struct ApiDoc;
diff --git a/crates/adapters/http-axum/src/router.rs b/crates/adapters/http-axum/src/router.rs
index 23b7b2d..7558d97 100644
--- a/crates/adapters/http-axum/src/router.rs
+++ b/crates/adapters/http-axum/src/router.rs
@@ -1,13 +1,16 @@
 use axum::extract::DefaultBodyLimit;
 use axum::http::HeaderValue;
-use axum::routing::{delete, get, patch, post};
+use axum::routing::{delete, get, patch, post, put};
 use axum::{Json, Router};
 use tower_http::cors::{AllowOrigin, Any, CorsLayer};
 use tower_http::trace::TraceLayer;
 use utoipa::OpenApi;
 use utoipa_scalar::{Scalar, Servable};
 
-use crate::handlers::{activities, auth, entries, import_export, media, push, reminders, users};
+use crate::handlers::{
+    activities, auth, correlations, cycle, data, entries, import_export, media, metrics, providers,
+    push, reminders, tokens, users,
+};
 use crate::openapi::ApiDoc;
 use crate::state::AppState;
 
@@ -62,10 +65,50 @@ fn api_routes() -> Router<AppState> {
         .nest("/users", user_routes())
         .nest("/reminders", reminder_routes())
         .nest("/media", media_routes())
+        .nest("/metrics", metric_routes())
+        .nest("/correlations", correlation_routes())
+        .nest("/tokens", token_routes())
+        .nest("/cycle", cycle_routes())
+        .nest("/providers", provider_routes())
         .nest("/push", push_routes())
         .nest("/data", data_routes())
 }
 
+fn cycle_routes() -> Router<AppState> {
+    Router::new().route("/", get(cycle::handle_read)).route(
+        "/{date}",
+        put(cycle::handle_record).delete(cycle::handle_forget),
+    )
+}
+
+fn token_routes() -> Router<AppState> {
+    Router::new()
+        .route("/", get(tokens::handle_list).post(tokens::handle_mint))
+        .route("/{id}", delete(tokens::handle_revoke))
+}
+
+fn correlation_routes() -> Router<AppState> {
+    Router::new().route("/", get(correlations::handle_list))
+}
+
+fn metric_routes() -> Router<AppState> {
+    Router::new()
+        .route("/", get(metrics::handle_list))
+        .route("/import", post(metrics::handle_import))
+        .route("/rejections", get(metrics::handle_rejections))
+        .route("/{date}", put(metrics::handle_set))
+}
+
+fn provider_routes() -> Router<AppState> {
+    Router::new()
+        .route("/", get(providers::handle_list))
+        .route("/now-playing", get(providers::handle_now_playing))
+        .route(
+            "/{provider}",
+            put(providers::handle_connect).delete(providers::handle_disconnect),
+        )
+}
+
 fn auth_routes() -> Router<AppState> {
     Router::new()
         .route("/login", post(auth::handle_login))
@@ -89,10 +132,6 @@ fn entry_routes() -> Router<AppState> {
             "/filter/activity/{id}",
             get(entries::handle_filter_by_activity),
         )
-        .route(
-            "/correlation/{id}",
-            get(entries::handle_activity_correlation),
-        )
         .route("/bulk/delete", delete(entries::handle_delete_by_date_range))
         .route(
             "/bulk/replace-activity",
@@ -127,6 +166,10 @@ fn user_routes() -> Router<AppState> {
         )
         .route("/me/password", patch(users::handle_change_password))
         .route("/me/data", delete(users::handle_clear_data))
+        .route(
+            "/me/preferences",
+            get(cycle::handle_preferences).patch(cycle::handle_set_preferences),
+        )
 }
 
 fn reminder_routes() -> Router<AppState> {
@@ -167,6 +210,8 @@ fn push_routes() -> Router<AppState> {
 
 fn data_routes() -> Router<AppState> {
     Router::new()
-        .route("/export", get(import_export::handle_export))
+        .route("/backup", get(data::handle_backup))
+        .route("/extract", get(data::handle_extract))
+        .route("/restore", post(data::handle_restore))
         .route("/import", post(import_export::handle_import))
 }
diff --git a/crates/adapters/http-axum/src/state.rs b/crates/adapters/http-axum/src/state.rs
index 8ab9670..0ce0114 100644
--- a/crates/adapters/http-axum/src/state.rs
+++ b/crates/adapters/http-axum/src/state.rs
@@ -1,18 +1,26 @@
 use std::sync::Arc;
 
-use config::{AuthConfig, EntryConfig, PresetConfig, PushConfig, ServerConfig};
+use config::{
+    AnalysisConfig, AuthConfig, EntryConfig, ImportConfig, PresetConfig, PushConfig, ServerConfig,
+};
 use domain::ports::{
-    ActivityCommandPort, ActivityQueryPort, AuthServicePort, CascadeDeletePort, EventPublisherPort,
-    ExportPort, ImportSourcePort, MediaStoragePort, MoodEntryCommandPort, MoodEntryQueryPort,
-    PasswordHasherPort, PushSubscriptionCommandPort, PushSubscriptionQueryPort,
-    RefreshSessionCommandPort, RefreshSessionQueryPort, ReminderCommandPort, ReminderQueryPort,
-    ReminderSenderPort, UserCommandPort, UserQueryPort,
+    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,
 };
 
 #[derive(Clone)]
 pub struct AppState {
     pub entry_command: Arc<dyn MoodEntryCommandPort>,
     pub entry_query: Arc<dyn MoodEntryQueryPort>,
+    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
+    pub weather_store: Arc<dyn EntryDimensionPort>,
     pub activity_command: Arc<dyn ActivityCommandPort>,
     pub activity_query: Arc<dyn ActivityQueryPort>,
     pub user_command: Arc<dyn UserCommandPort>,
@@ -22,17 +30,37 @@ pub struct AppState {
     pub refresh_session_command: Arc<dyn RefreshSessionCommandPort>,
     pub refresh_session_query: Arc<dyn RefreshSessionQueryPort>,
     pub cascade: Arc<dyn CascadeDeletePort>,
+    pub daily_metric_command: Arc<dyn DailyMetricCommandPort>,
+    pub daily_metric_query: Arc<dyn DailyMetricQueryPort>,
+    pub cycle_command: Arc<dyn CycleStartCommandPort>,
+    pub cycle_query: Arc<dyn CycleStartQueryPort>,
+    pub preferences_command: Arc<dyn UserPreferencesCommandPort>,
+    pub preferences_query: Arc<dyn UserPreferencesQueryPort>,
+    pub rejection_command: Arc<dyn RejectionCommandPort>,
+    pub rejection_query: Arc<dyn RejectionQueryPort>,
+    pub api_token_command: Arc<dyn ApiTokenCommandPort>,
+    pub api_token_query: Arc<dyn ApiTokenQueryPort>,
+    pub api_token_secrets: Arc<dyn ApiTokenSecretPort>,
     pub auth_service: Arc<dyn AuthServicePort>,
     pub password_hasher: Arc<dyn PasswordHasherPort>,
     pub event_publisher: Arc<dyn EventPublisherPort>,
     pub media_storage: Arc<dyn MediaStoragePort>,
-    pub export_port: Arc<dyn ExportPort>,
+    pub backup_writer: Arc<dyn BackupWriterPort>,
+    pub backup_reader: Arc<dyn BackupReaderPort>,
+    pub extract_writer: Arc<dyn ExtractWriterPort>,
     pub import_source: Arc<dyn ImportSourcePort>,
+    pub provider_connection_command: Arc<dyn ProviderConnectionCommandPort>,
+    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 recording_lookup: Arc<dyn domain::ports::RecordingLookupPort>,
     pub push_subscription_command: Arc<dyn PushSubscriptionCommandPort>,
     pub push_subscription_query: Arc<dyn PushSubscriptionQueryPort>,
     pub reminder_sender: Option<Arc<dyn ReminderSenderPort>>,
     pub server_config: ServerConfig,
     pub entry_config: EntryConfig,
+    pub analysis_config: AnalysisConfig,
+    pub import_config: ImportConfig,
     pub auth_config: AuthConfig,
     pub push_config: PushConfig,
     pub preset_config: PresetConfig,
diff --git a/crates/adapters/importer/Cargo.toml b/crates/adapters/importer/Cargo.toml
index fc3586b..a09ea7d 100644
--- a/crates/adapters/importer/Cargo.toml
+++ b/crates/adapters/importer/Cargo.toml
@@ -5,9 +5,14 @@ version.workspace = true
 
 [dependencies]
 domain.workspace = true
+exporter.workspace = true
+api-types.workspace = true
 async-trait.workspace = true
 csv.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 zip.workspace = true
 tracing.workspace = true
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
diff --git a/crates/adapters/importer/src/backup_reader.rs b/crates/adapters/importer/src/backup_reader.rs
new file mode 100644
index 0000000..619a142
--- /dev/null
+++ b/crates/adapters/importer/src/backup_reader.rs
@@ -0,0 +1,83 @@
+use api_types::dimension::DimensionPayload;
+use domain::dimension::DimensionValue;
+use domain::errors::DomainError;
+use domain::ports::{
+    RestorableActivity, RestorableContents, RestorableEntry, RestorableMetric, RestorableReminder,
+};
+
+use super::kmood_backup::KmoodBackupReader;
+
+pub struct KmoodBackupAdapter;
+
+#[async_trait::async_trait]
+impl domain::ports::BackupReaderPort for KmoodBackupAdapter {
+    async fn read(&self, data: &[u8]) -> Result<RestorableContents, DomainError> {
+        let read = KmoodBackupReader::read(data)?;
+        let manifest = read.manifest;
+
+        Ok(RestorableContents {
+            entries: manifest
+                .entries
+                .into_iter()
+                .map(|held| RestorableEntry {
+                    mood: held.mood,
+                    logged_at: held.logged_at,
+                    dimensions: readable_dimensions(held.dimensions),
+                })
+                .collect(),
+            metrics: manifest
+                .metrics
+                .into_iter()
+                .map(|held| RestorableMetric {
+                    date: held.date,
+                    kind: held.kind,
+                    value: held.value,
+                    provider: held.provider,
+                })
+                .collect(),
+            cycle_starts: manifest.cycle_starts,
+            activities: manifest
+                .activities
+                .into_iter()
+                .map(|held| RestorableActivity {
+                    id: held.id,
+                    name: held.name,
+                    category: held.category,
+                    archived: held.archived,
+                })
+                .collect(),
+            reminders: manifest
+                .reminders
+                .into_iter()
+                .map(|held| RestorableReminder {
+                    enabled: held.enabled,
+                    times: [
+                        held.monday,
+                        held.tuesday,
+                        held.wednesday,
+                        held.thursday,
+                        held.friday,
+                        held.saturday,
+                        held.sunday,
+                    ],
+                })
+                .collect(),
+            tracks_cycle: manifest.tracks_cycle,
+            photos: read.photos.into_iter().collect(),
+            voice_memos: read.voice_memos.into_iter().collect(),
+        })
+    }
+}
+
+fn readable_dimensions(payloads: Vec<DimensionPayload>) -> Vec<DimensionValue> {
+    payloads
+        .into_iter()
+        .filter_map(|payload| match payload.into_dimension() {
+            Ok(dimension) => Some(dimension),
+            Err(error) => {
+                tracing::warn!(%error, "a backed-up dimension could not be read");
+                None
+            }
+        })
+        .collect()
+}
diff --git a/crates/adapters/importer/src/daylio.rs b/crates/adapters/importer/src/daylio.rs
index 19177ad..0634799 100644
--- a/crates/adapters/importer/src/daylio.rs
+++ b/crates/adapters/importer/src/daylio.rs
@@ -1,60 +1,100 @@
+use std::collections::HashMap;
+
 use domain::errors::DomainError;
 use domain::ports::ImportedRow;
 
+const DATE: &str = "full_date";
+const TIME: &str = "time";
+const MOOD: &str = "mood";
+const ACTIVITIES: &str = "activities";
+const NOTE: &str = "note";
+const NOTE_TITLE: &str = "note_title";
+
 pub struct DaylioImportAdapter;
 
 #[async_trait::async_trait]
 impl domain::ports::ImportSourcePort for DaylioImportAdapter {
     async fn read_entries(&self, data: &[u8]) -> Result<Vec<ImportedRow>, DomainError> {
         let content = std::str::from_utf8(data)
-            .map_err(|e| DomainError::InvalidInput(format!("invalid UTF-8: {e}")))?;
+            .map_err(|error| DomainError::InvalidInput(format!("invalid UTF-8: {error}")))?;
 
         let mut reader = csv::ReaderBuilder::new()
             .has_headers(true)
             .from_reader(content.as_bytes());
 
+        let columns = columns_of(&mut reader)?;
         let mut rows = Vec::new();
 
         for result in reader.records() {
-            let record =
-                result.map_err(|e| DomainError::InvalidInput(format!("CSV parse error: {e}")))?;
+            let record = result
+                .map_err(|error| DomainError::InvalidInput(format!("CSV parse error: {error}")))?;
 
-            let mood_str = record.get(4).unwrap_or("").trim();
-            let mood = map_daylio_mood(mood_str)?;
-
-            let date = record.get(0).unwrap_or("").trim().to_string();
-            let time = record.get(3).unwrap_or("").trim().to_string();
-
-            let activities_str = record.get(5).unwrap_or("").trim();
-            let activities = if activities_str.is_empty() {
-                Vec::new()
-            } else {
-                activities_str
-                    .split('|')
-                    .map(|s| s.trim().to_string())
-                    .filter(|s| !s.is_empty())
-                    .collect()
+            let read = |name: &str| {
+                columns
+                    .get(name)
+                    .and_then(|at| record.get(*at))
+                    .unwrap_or("")
+                    .trim()
             };
 
-            let note = record
-                .get(7)
-                .map(|s| s.trim().to_string())
-                .filter(|s| !s.is_empty());
-
             rows.push(ImportedRow {
-                mood,
-                date,
-                time,
-                activities,
-                note,
+                mood: map_daylio_mood(read(MOOD))?,
+                date: read(DATE).to_string(),
+                time: read(TIME).to_string(),
+                activities: split_activities(read(ACTIVITIES)),
+                note: whatever_was_written(read(NOTE_TITLE), read(NOTE)),
             });
         }
 
         tracing::info!(row_count = rows.len(), "parsed Daylio export");
+
         Ok(rows)
     }
 }
 
+fn columns_of<R: std::io::Read>(
+    reader: &mut csv::Reader<R>,
+) -> Result<HashMap<String, usize>, DomainError> {
+    let headers = reader
+        .headers()
+        .map_err(|error| DomainError::InvalidInput(format!("CSV has no header row: {error}")))?;
+
+    let columns: HashMap<String, usize> = headers
+        .iter()
+        .enumerate()
+        .map(|(at, name)| (name.trim().to_lowercase(), at))
+        .collect();
+
+    for required in [DATE, TIME, MOOD] {
+        if !columns.contains_key(required) {
+            return Err(DomainError::InvalidInput(format!(
+                "this does not look like a Daylio export: no {required} column"
+            )));
+        }
+    }
+
+    Ok(columns)
+}
+
+fn split_activities(written: &str) -> Vec<String> {
+    written
+        .split('|')
+        .map(|activity| activity.trim().to_string())
+        .filter(|activity| !activity.is_empty())
+        .collect()
+}
+
+fn whatever_was_written(title: &str, note: &str) -> Option<String> {
+    let written = [title, note]
+        .iter()
+        .filter(|part| !part.is_empty())
+        .copied()
+        .collect::<Vec<&str>>()
+        .join("\n\n");
+
+    Some(written).filter(|written| !written.is_empty())
+}
+
 fn map_daylio_mood(mood: &str) -> Result<u8, DomainError> {
     match mood.to_lowercase().as_str() {
         "awful" => Ok(1),
diff --git a/crates/adapters/importer/src/kmood_backup.rs b/crates/adapters/importer/src/kmood_backup.rs
new file mode 100644
index 0000000..6c613a3
--- /dev/null
+++ b/crates/adapters/importer/src/kmood_backup.rs
@@ -0,0 +1,99 @@
+use std::collections::HashMap;
+use std::io::{Cursor, Read};
+
+use zip::ZipArchive;
+
+use domain::errors::DomainError;
+use exporter::{BACKUP_MANIFEST, BackupManifest};
+
+pub struct RestorableBackup {
+    pub manifest: BackupManifest,
+    pub photos: HashMap<String, Vec<u8>>,
+    pub voice_memos: HashMap<String, Vec<u8>>,
+}
+
+pub struct KmoodBackupReader;
+
+impl KmoodBackupReader {
+    pub fn read(data: &[u8]) -> Result<RestorableBackup, DomainError> {
+        let mut archive = ZipArchive::new(Cursor::new(data))
+            .map_err(|error| DomainError::InvalidInput(format!("not a zip archive: {error}")))?;
+
+        let manifest = read_named(&mut archive, BACKUP_MANIFEST)?.ok_or_else(|| {
+            DomainError::InvalidInput(
+                "this archive has no backup.json, so it is not a k-mood backup".into(),
+            )
+        })?;
+
+        let manifest: BackupManifest = serde_json::from_slice(&manifest).map_err(|error| {
+            DomainError::InvalidInput(format!("this backup cannot be read: {error}"))
+        })?;
+
+        let (photos, voice_memos) = read_media(&mut archive)?;
+
+        tracing::info!(
+            version = manifest.version,
+            entries = manifest.entries.len(),
+            metrics = manifest.metrics.len(),
+            "read a k-mood backup"
+        );
+
+        Ok(RestorableBackup {
+            manifest,
+            photos,
+            voice_memos,
+        })
+    }
+}
+
+type Media = (HashMap<String, Vec<u8>>, HashMap<String, Vec<u8>>);
+
+fn read_media(archive: &mut ZipArchive<Cursor<&[u8]>>) -> Result<Media, DomainError> {
+    let mut photos = HashMap::new();
+    let mut voice_memos = HashMap::new();
+
+    for index in 0..archive.len() {
+        let mut file = archive
+            .by_index(index)
+            .map_err(|error| DomainError::InvalidInput(format!("zip read error: {error}")))?;
+
+        let name = file.name().to_string();
+
+        let destination = match (
+            name.strip_prefix("photos/"),
+            name.strip_prefix("voice_memos/"),
+        ) {
+            (Some(id), _) if !id.is_empty() => (&mut photos, id.to_string()),
+            (_, Some(id)) if !id.is_empty() => (&mut voice_memos, id.to_string()),
+            _ => continue,
+        };
+
+        let (into, id) = destination;
+
+        let mut bytes = Vec::new();
+        file.read_to_end(&mut bytes).map_err(|error| {
+            DomainError::InvalidInput(format!("could not read {name}: {error}"))
+        })?;
+
+        into.insert(id, bytes);
+    }
+
+    Ok((photos, voice_memos))
+}
+
+fn read_named(
+    archive: &mut ZipArchive<Cursor<&[u8]>>,
+    name: &str,
+) -> Result<Option<Vec<u8>>, DomainError> {
+    let mut file = match archive.by_name(name) {
+        Ok(file) => file,
+        Err(zip::result::ZipError::FileNotFound) => return Ok(None),
+        Err(error) => return Err(DomainError::InvalidInput(format!("zip error: {error}"))),
+    };
+
+    let mut bytes = Vec::new();
+    file.read_to_end(&mut bytes)
+        .map_err(|error| DomainError::InvalidInput(format!("could not read {name}: {error}")))?;
+
+    Ok(Some(bytes))
+}
diff --git a/crates/adapters/importer/src/lib.rs b/crates/adapters/importer/src/lib.rs
index 10d47d5..626e1ae 100644
--- a/crates/adapters/importer/src/lib.rs
+++ b/crates/adapters/importer/src/lib.rs
@@ -1,7 +1,11 @@
+mod backup_reader;
 mod csv_generic;
 mod daylio;
+mod kmood_backup;
 mod kmood_zip;
 
+pub use backup_reader::KmoodBackupAdapter;
 pub use csv_generic::{CsvImportAdapter, CsvImportConfig};
 pub use daylio::DaylioImportAdapter;
+pub use kmood_backup::{KmoodBackupReader, RestorableBackup};
 pub use kmood_zip::{KmoodImportEntry, KmoodImportResult, KmoodZipImportAdapter};
diff --git a/crates/adapters/importer/tests/daylio_test.rs b/crates/adapters/importer/tests/daylio_test.rs
new file mode 100644
index 0000000..bc651c4
--- /dev/null
+++ b/crates/adapters/importer/tests/daylio_test.rs
@@ -0,0 +1,98 @@
+use domain::ports::ImportSourcePort;
+
+use importer::DaylioImportAdapter;
+
+const CURRENT_EXPORT: &str = "full_date,date,weekday,time,mood,activities,scales,note_title,note\n\
+2026-08-25,25 Aug,Tuesday,8:00 PM,meh,,,\"\",\"\"\n\
+2026-08-24,24 Aug,Monday,8:00 PM,rad,\"friends | walk\",,\"\",\"I KISSED OLA\"\n";
+
+const OLDER_EXPORT_WITHOUT_SCALES: &str = "full_date,date,weekday,time,mood,activities,note_title,note\n\
+2026-08-24,24 Aug,Monday,8:00 PM,good,walk,\"A title\",\"A note\"\n";
+
+const COLUMNS_IN_A_DIFFERENT_ORDER: &str = "note,mood,time,full_date,activities\n\
+\"reordered\",bad,9:15 PM,2026-08-23,reading\n";
+
+async fn read(csv: &str) -> Vec<domain::ports::ImportedRow> {
+    DaylioImportAdapter
+        .read_entries(csv.as_bytes())
+        .await
+        .unwrap()
+}
+
+#[tokio::test]
+async fn the_note_is_read_from_the_note_column_not_the_title() {
+    let rows = read(CURRENT_EXPORT).await;
+
+    assert_eq!(rows.len(), 2);
+    assert_eq!(rows[0].note, None, "an empty note is no note");
+    assert_eq!(
+        rows[1].note.as_deref(),
+        Some("I KISSED OLA"),
+        "the note column sits after note_title, and it is the one worth keeping"
+    );
+}
+
+#[tokio::test]
+async fn a_title_and_a_note_are_both_kept() {
+    let rows = read(OLDER_EXPORT_WITHOUT_SCALES).await;
+
+    assert_eq!(
+        rows[0].note.as_deref(),
+        Some("A title\n\nA note"),
+        "a Daylio note can have a title, and losing either is losing writing"
+    );
+}
+
+#[tokio::test]
+async fn an_export_without_the_scales_column_still_reads() {
+    let rows = read(OLDER_EXPORT_WITHOUT_SCALES).await;
+
+    assert_eq!(rows.len(), 1);
+    assert_eq!(rows[0].mood, 4);
+    assert_eq!(rows[0].date, "2026-08-24");
+    assert_eq!(rows[0].time, "8:00 PM");
+    assert_eq!(rows[0].activities, ["walk"]);
+}
+
+#[tokio::test]
+async fn columns_are_found_by_name_rather_than_by_position() {
+    let rows = read(COLUMNS_IN_A_DIFFERENT_ORDER).await;
+
+    assert_eq!(rows[0].mood, 2);
+    assert_eq!(rows[0].date, "2026-08-23");
+    assert_eq!(rows[0].time, "9:15 PM");
+    assert_eq!(rows[0].note.as_deref(), Some("reordered"));
+    assert_eq!(rows[0].activities, ["reading"]);
+}
+
+#[tokio::test]
+async fn activities_are_split_on_the_pipe_and_trimmed() {
+    let rows = read(CURRENT_EXPORT).await;
+
+    assert_eq!(rows[1].activities, ["friends", "walk"]);
+}
+
+#[tokio::test]
+async fn a_file_that_is_not_a_daylio_export_is_refused_by_name() {
+    let refused = DaylioImportAdapter
+        .read_entries(b"when,how_i_felt\n2026-08-25,fine\n")
+        .await
+        .unwrap_err();
+
+    assert!(
+        refused
+            .to_string()
+            .contains("does not look like a Daylio export"),
+        "a file with none of the columns is refused for that reason, not for a bad mood: {refused}"
+    );
+}
+
+#[tokio::test]
+async fn a_mood_daylio_never_writes_is_refused() {
+    let refused = DaylioImportAdapter
+        .read_entries(b"full_date,time,mood\n2026-08-25,8:00 PM,ecstatic\n")
+        .await
+        .unwrap_err();
+
+    assert!(refused.to_string().contains("ecstatic"));
+}
diff --git a/crates/adapters/music/Cargo.toml b/crates/adapters/music/Cargo.toml
new file mode 100644
index 0000000..8b5ffd3
--- /dev/null
+++ b/crates/adapters/music/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "music"
+edition.workspace = true
+version.workspace = true
+
+[dependencies]
+domain.workspace = true
+async-trait.workspace = true
+reqwest.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+md-5.workspace = true
+rand.workspace = true
+tracing.workspace = true
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
diff --git a/crates/adapters/music/src/lib.rs b/crates/adapters/music/src/lib.rs
new file mode 100644
index 0000000..9a56313
--- /dev/null
+++ b/crates/adapters/music/src/lib.rs
@@ -0,0 +1,5 @@
+pub mod musicbrainz;
+pub mod subsonic;
+
+pub use musicbrainz::MusicBrainzRecordingLookup;
+pub use subsonic::SubsonicNowPlayingAdapter;
diff --git a/crates/adapters/music/src/musicbrainz/client.rs b/crates/adapters/music/src/musicbrainz/client.rs
new file mode 100644
index 0000000..d3916fe
--- /dev/null
+++ b/crates/adapters/music/src/musicbrainz/client.rs
@@ -0,0 +1,62 @@
+use domain::errors::DomainError;
+use domain::ports::RecordingLookupPort;
+use domain::song::RecordingId;
+
+const SEARCH_URL: &str = "https://musicbrainz.org/ws/2/recording";
+pub const USER_AGENT: &str = concat!("k-mood/", env!("CARGO_PKG_VERSION"));
+
+pub struct MusicBrainzRecordingLookup {
+    http: reqwest::Client,
+}
+
+impl MusicBrainzRecordingLookup {
+    pub fn new(http: reqwest::Client) -> Self {
+        Self { http }
+    }
+}
+
+#[derive(serde::Deserialize)]
+struct SearchResult {
+    #[serde(default)]
+    recordings: Vec<Recording>,
+}
+
+#[derive(serde::Deserialize)]
+struct Recording {
+    id: String,
+}
+
+pub fn parse_first_recording(body: &str) -> Option<RecordingId> {
+    let result: SearchResult = serde_json::from_str(body).ok()?;
+    let first = result.recordings.first()?;
+    RecordingId::new(&first.id).ok()
+}
+
+#[async_trait::async_trait]
+impl RecordingLookupPort for MusicBrainzRecordingLookup {
+    async fn find_recording(
+        &self,
+        title: &str,
+        artist: &str,
+    ) -> Result<Option<RecordingId>, DomainError> {
+        let query = format!(r#"recording:"{title}" AND artist:"{artist}""#);
+
+        let response = self
+            .http
+            .get(SEARCH_URL)
+            .query(&[("query", query.as_str()), ("fmt", "json"), ("limit", "1")])
+            .send()
+            .await;
+
+        let Ok(response) = response else {
+            tracing::debug!("musicbrainz lookup failed");
+            return Ok(None);
+        };
+
+        let Ok(body) = response.text().await else {
+            return Ok(None);
+        };
+
+        Ok(parse_first_recording(&body))
+    }
+}
diff --git a/crates/adapters/music/src/musicbrainz/mod.rs b/crates/adapters/music/src/musicbrainz/mod.rs
new file mode 100644
index 0000000..dd9abb0
--- /dev/null
+++ b/crates/adapters/music/src/musicbrainz/mod.rs
@@ -0,0 +1,3 @@
+mod client;
+
+pub use client::{MusicBrainzRecordingLookup, USER_AGENT, parse_first_recording};
diff --git a/crates/adapters/music/src/subsonic/client.rs b/crates/adapters/music/src/subsonic/client.rs
new file mode 100644
index 0000000..79111e7
--- /dev/null
+++ b/crates/adapters/music/src/subsonic/client.rs
@@ -0,0 +1,76 @@
+use md5::{Digest, Md5};
+use rand::Rng;
+
+use domain::errors::DomainError;
+use domain::ports::NowPlayingPort;
+use domain::song::Song;
+
+use super::credential::SubsonicCredential;
+use super::response::parse_now_playing;
+
+const API_VERSION: &str = "1.16.1";
+const CLIENT_NAME: &str = "k-mood";
+const SALT_BYTES: usize = 12;
+
+pub struct SubsonicNowPlayingAdapter {
+    http: reqwest::Client,
+}
+
+impl SubsonicNowPlayingAdapter {
+    pub fn new(http: reqwest::Client) -> Self {
+        Self { http }
+    }
+}
+
+pub fn auth_token(password: &str, salt: &str) -> String {
+    let mut hasher = Md5::new();
+    hasher.update(password.as_bytes());
+    hasher.update(salt.as_bytes());
+    format!("{:x}", hasher.finalize())
+}
+
+fn random_salt() -> String {
+    let mut bytes = [0u8; SALT_BYTES];
+    rand::rng().fill(&mut bytes);
+    bytes.iter().map(|byte| format!("{byte:02x}")).collect()
+}
+
+#[async_trait::async_trait]
+impl NowPlayingPort for SubsonicNowPlayingAdapter {
+    fn provider(&self) -> &str {
+        "subsonic"
+    }
+
+    async fn now_playing(&self, credential: &[u8]) -> Result<Option<Song>, DomainError> {
+        let credential = SubsonicCredential::parse(credential)?;
+        let salt = random_salt();
+        let token = auth_token(&credential.password, &salt);
+
+        let url = format!("{}/rest/getNowPlaying", credential.base_url());
+
+        let response = self
+            .http
+            .get(&url)
+            .query(&[
+                ("u", credential.username.as_str()),
+                ("t", token.as_str()),
+                ("s", salt.as_str()),
+                ("v", API_VERSION),
+                ("c", CLIENT_NAME),
+                ("f", "json"),
+            ])
+            .send()
+            .await
+            .map_err(|e| {
+                tracing::warn!(%e, "subsonic request failed");
+                DomainError::InvalidInput("could not reach the music provider".into())
+            })?;
+
+        let body = response.text().await.map_err(|e| {
+            tracing::warn!(%e, "subsonic response could not be read");
+            DomainError::InvalidInput("could not read the music provider's response".into())
+        })?;
+
+        parse_now_playing(&body)
+    }
+}
diff --git a/crates/adapters/music/src/subsonic/credential.rs b/crates/adapters/music/src/subsonic/credential.rs
new file mode 100644
index 0000000..aeaccab
--- /dev/null
+++ b/crates/adapters/music/src/subsonic/credential.rs
@@ -0,0 +1,43 @@
+use domain::errors::DomainError;
+
+#[derive(serde::Deserialize)]
+pub struct SubsonicCredential {
+    pub url: String,
+    pub username: String,
+    pub password: String,
+}
+
+impl SubsonicCredential {
+    pub fn parse(bytes: &[u8]) -> Result<Self, DomainError> {
+        let credential: Self = serde_json::from_slice(bytes).map_err(|_| {
+            DomainError::InvalidInput(
+                "subsonic credential must carry a url, username and password".into(),
+            )
+        })?;
+
+        if credential.url.trim().is_empty()
+            || credential.username.trim().is_empty()
+            || credential.password.is_empty()
+        {
+            return Err(DomainError::InvalidInput(
+                "subsonic credential must carry a url, username and password".into(),
+            ));
+        }
+
+        Ok(credential)
+    }
+
+    pub fn base_url(&self) -> &str {
+        self.url.trim().trim_end_matches('/')
+    }
+}
+
+impl std::fmt::Debug for SubsonicCredential {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SubsonicCredential")
+            .field("url", &self.url)
+            .field("username", &self.username)
+            .field("password", &"<redacted>")
+            .finish()
+    }
+}
diff --git a/crates/adapters/music/src/subsonic/mod.rs b/crates/adapters/music/src/subsonic/mod.rs
new file mode 100644
index 0000000..33e7deb
--- /dev/null
+++ b/crates/adapters/music/src/subsonic/mod.rs
@@ -0,0 +1,7 @@
+mod client;
+mod credential;
+mod response;
+
+pub use client::{SubsonicNowPlayingAdapter, auth_token};
+pub use credential::SubsonicCredential;
+pub use response::parse_now_playing;
diff --git a/crates/adapters/music/src/subsonic/response.rs b/crates/adapters/music/src/subsonic/response.rs
new file mode 100644
index 0000000..bbd2860
--- /dev/null
+++ b/crates/adapters/music/src/subsonic/response.rs
@@ -0,0 +1,62 @@
+use domain::errors::DomainError;
+use domain::song::Song;
+
+#[derive(serde::Deserialize)]
+struct Envelope {
+    #[serde(rename = "subsonic-response")]
+    response: SubsonicResponse,
+}
+
+#[derive(serde::Deserialize)]
+struct SubsonicResponse {
+    status: String,
+    #[serde(rename = "nowPlaying")]
+    now_playing: Option<NowPlaying>,
+    error: Option<SubsonicError>,
+}
+
+#[derive(serde::Deserialize)]
+struct SubsonicError {
+    message: Option<String>,
+}
+
+#[derive(serde::Deserialize)]
+struct NowPlaying {
+    #[serde(default)]
+    entry: Vec<NowPlayingEntry>,
+}
+
+#[derive(serde::Deserialize)]
+struct NowPlayingEntry {
+    title: Option<String>,
+    artist: Option<String>,
+    album: Option<String>,
+}
+
+pub fn parse_now_playing(body: &str) -> Result<Option<Song>, DomainError> {
+    let envelope: Envelope = serde_json::from_str(body)
+        .map_err(|_| DomainError::InvalidInput("unrecognised subsonic response".into()))?;
+
+    if envelope.response.status != "ok" {
+        let message = envelope
+            .response
+            .error
+            .and_then(|error| error.message)
+            .unwrap_or_else(|| "subsonic rejected the request".into());
+        return Err(DomainError::InvalidInput(message));
+    }
+
+    let Some(entry) = envelope
+        .response
+        .now_playing
+        .and_then(|playing| playing.entry.into_iter().next())
+    else {
+        return Ok(None);
+    };
+
+    let (Some(title), Some(artist)) = (entry.title, entry.artist) else {
+        return Ok(None);
+    };
+
+    Ok(Some(Song::new(title, artist, entry.album, None)?))
+}
diff --git a/crates/adapters/music/tests/musicbrainz_test.rs b/crates/adapters/music/tests/musicbrainz_test.rs
new file mode 100644
index 0000000..f909eeb
--- /dev/null
+++ b/crates/adapters/music/tests/musicbrainz_test.rs
@@ -0,0 +1,30 @@
+use music::musicbrainz::parse_first_recording;
+
+#[test]
+fn the_first_recording_is_taken_as_the_match() {
+    let body = r#"{"recordings":[
+        {"id":"f5c7e7a2-0000-4000-8000-000000000001","title":"Paranoid Android"},
+        {"id":"f5c7e7a2-0000-4000-8000-000000000002","title":"Paranoid Android (live)"}
+    ]}"#;
+
+    let recording = parse_first_recording(body).unwrap();
+
+    assert_eq!(
+        recording.value().to_string(),
+        "f5c7e7a2-0000-4000-8000-000000000001"
+    );
+}
+
+#[test]
+fn no_match_yields_nothing_rather_than_an_error() {
+    assert!(parse_first_recording(r#"{"recordings":[]}"#).is_none());
+    assert!(parse_first_recording(r#"{}"#).is_none());
+    assert!(parse_first_recording("not json").is_none());
+}
+
+#[test]
+fn a_recording_id_that_is_not_a_uuid_is_ignored() {
+    let body = r#"{"recordings":[{"id":"not-a-uuid"}]}"#;
+
+    assert!(parse_first_recording(body).is_none());
+}
diff --git a/crates/adapters/music/tests/subsonic_test.rs b/crates/adapters/music/tests/subsonic_test.rs
new file mode 100644
index 0000000..5c338b2
--- /dev/null
+++ b/crates/adapters/music/tests/subsonic_test.rs
@@ -0,0 +1,81 @@
+use music::subsonic::{SubsonicCredential, auth_token, parse_now_playing};
+
+#[test]
+fn the_auth_token_is_md5_of_password_and_salt() {
+    assert_eq!(
+        auth_token("hunter2", "c19b2d"),
+        "1b41ecef65ff7799cf7a84cf2d505e08"
+    );
+}
+
+#[test]
+fn a_different_salt_produces_a_different_token() {
+    assert_ne!(auth_token("hunter2", "aaa"), auth_token("hunter2", "bbb"));
+}
+
+#[test]
+fn a_credential_needs_a_url_username_and_password() {
+    let valid = br#"{"url":"https://music.example/","username":"gabriel","password":"hunter2"}"#;
+    let credential = SubsonicCredential::parse(valid).unwrap();
+
+    assert_eq!(credential.base_url(), "https://music.example");
+    assert_eq!(credential.username, "gabriel");
+}
+
+#[test]
+fn an_incomplete_credential_is_rejected() {
+    assert!(SubsonicCredential::parse(br#"{"url":"https://music.example"}"#).is_err());
+    assert!(SubsonicCredential::parse(br#"{"url":"","username":"g","password":"p"}"#).is_err());
+    assert!(SubsonicCredential::parse(b"not json").is_err());
+}
+
+#[test]
+fn a_credential_never_reveals_its_password_in_debug_output() {
+    let credential = SubsonicCredential::parse(
+        br#"{"url":"https://music.example","username":"gabriel","password":"hunter2"}"#,
+    )
+    .unwrap();
+
+    assert!(!format!("{credential:?}").contains("hunter2"));
+}
+
+#[test]
+fn a_playing_track_becomes_a_song() {
+    let body = r#"{"subsonic-response":{"status":"ok","version":"1.16.1","nowPlaying":{"entry":[
+        {"title":"Paranoid Android","artist":"Radiohead","album":"OK Computer"}
+    ]}}}"#;
+
+    let song = parse_now_playing(body).unwrap().unwrap();
+
+    assert_eq!(song.title().value(), "Paranoid Android");
+    assert_eq!(song.artist().value(), "Radiohead");
+    assert_eq!(song.album().map(|a| a.value()), Some("OK Computer"));
+}
+
+#[test]
+fn nothing_playing_is_not_an_error() {
+    let empty = r#"{"subsonic-response":{"status":"ok","version":"1.16.1"}}"#;
+    let no_entries = r#"{"subsonic-response":{"status":"ok","nowPlaying":{"entry":[]}}}"#;
+
+    assert!(parse_now_playing(empty).unwrap().is_none());
+    assert!(parse_now_playing(no_entries).unwrap().is_none());
+}
+
+#[test]
+fn a_failed_call_is_an_error_even_though_subsonic_answers_with_http_200() {
+    let body = r#"{"subsonic-response":{"status":"failed","version":"1.16.1",
+        "error":{"code":40,"message":"Wrong username or password."}}}"#;
+
+    let result = parse_now_playing(body);
+
+    assert!(result.is_err());
+}
+
+#[test]
+fn a_track_missing_its_artist_is_skipped_rather_than_half_stored() {
+    let body = r#"{"subsonic-response":{"status":"ok","nowPlaying":{"entry":[
+        {"title":"Untitled"}
+    ]}}}"#;
+
+    assert!(parse_now_playing(body).unwrap().is_none());
+}
diff --git a/crates/adapters/sqlite/Cargo.toml b/crates/adapters/sqlite/Cargo.toml
index 5f7c65e..1efb206 100644
--- a/crates/adapters/sqlite/Cargo.toml
+++ b/crates/adapters/sqlite/Cargo.toml
@@ -11,3 +11,7 @@ sqlx.workspace = true
 uuid.workspace = true
 chrono.workspace = true
 tracing.workspace = true
+
+[dev-dependencies]
+domain = { workspace = true, features = ["test-helpers"] }
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
diff --git a/crates/adapters/sqlite/src/db.rs b/crates/adapters/sqlite/src/db.rs
index ee507a4..746692a 100644
--- a/crates/adapters/sqlite/src/db.rs
+++ b/crates/adapters/sqlite/src/db.rs
@@ -1,16 +1,68 @@
+use std::time::Duration;
+
 use sqlx::SqlitePool;
 use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
 
-const MIGRATIONS: &[&str] = &[
-    include_str!("migrations/001_initial.sql"),
-    include_str!("migrations/002_push_subscriptions.sql"),
+const BUSY_TIMEOUT: Duration = Duration::from_secs(10);
+
+const MIGRATIONS: &[(&str, &str)] = &[
+    ("001_initial", include_str!("migrations/001_initial.sql")),
+    (
+        "002_push_subscriptions",
+        include_str!("migrations/002_push_subscriptions.sql"),
+    ),
+    (
+        "003_entry_content",
+        include_str!("migrations/003_entry_content.sql"),
+    ),
+    (
+        "004_drop_entry_content_column",
+        include_str!("migrations/004_drop_entry_content_column.sql"),
+    ),
+    (
+        "005_location_and_song",
+        include_str!("migrations/005_location_and_song.sql"),
+    ),
+    (
+        "006_provider_connections",
+        include_str!("migrations/006_provider_connections.sql"),
+    ),
+    (
+        "007_daily_metrics",
+        include_str!("migrations/007_daily_metrics.sql"),
+    ),
+    (
+        "008_api_tokens",
+        include_str!("migrations/008_api_tokens.sql"),
+    ),
+    (
+        "009_metric_rejections",
+        include_str!("migrations/009_metric_rejections.sql"),
+    ),
+    (
+        "010_cycle_and_preferences",
+        include_str!("migrations/010_cycle_and_preferences.sql"),
+    ),
+    ("011_jobs", include_str!("migrations/011_jobs.sql")),
+    (
+        "012_entry_weather",
+        include_str!("migrations/012_entry_weather.sql"),
+    ),
 ];
 
+const TAKE_THE_WRITE_LOCK_UP_FRONT: &str = "BEGIN IMMEDIATE";
+
+const SCHEMA_MIGRATIONS_TABLE: &str = "CREATE TABLE IF NOT EXISTS schema_migrations (
+    name TEXT PRIMARY KEY NOT NULL,
+    applied_at TEXT NOT NULL
+)";
+
 pub async fn create_pool(database_url: &str) -> Result<SqlitePool, sqlx::Error> {
     let options: SqliteConnectOptions = database_url
         .parse::<SqliteConnectOptions>()?
         .create_if_missing(true)
         .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal)
+        .busy_timeout(BUSY_TIMEOUT)
         .foreign_keys(true);
 
     let pool = SqlitePoolOptions::new()
@@ -22,9 +74,59 @@ pub async fn create_pool(database_url: &str) -> Result<SqlitePool, sqlx::Error>
 }
 
 pub async fn run_migrations(pool: &SqlitePool) -> Result<(), sqlx::Error> {
-    for migration in MIGRATIONS {
-        sqlx::raw_sql(*migration).execute(pool).await?;
+    let mut connection = pool.acquire().await?;
+
+    sqlx::raw_sql(SCHEMA_MIGRATIONS_TABLE)
+        .execute(&mut *connection)
+        .await?;
+
+    sqlx::raw_sql(TAKE_THE_WRITE_LOCK_UP_FRONT)
+        .execute(&mut *connection)
+        .await?;
+
+    match apply_pending(&mut connection).await {
+        Ok(()) => {
+            sqlx::raw_sql("COMMIT").execute(&mut *connection).await?;
+
+            Ok(())
+        }
+        Err(error) => {
+            let _ = sqlx::raw_sql("ROLLBACK").execute(&mut *connection).await;
+
+            Err(error)
+        }
     }
-    tracing::info!("database migrations completed");
+}
+
+async fn apply_pending(connection: &mut sqlx::SqliteConnection) -> Result<(), sqlx::Error> {
+    for (name, sql) in MIGRATIONS {
+        if is_applied(connection, name).await? {
+            continue;
+        }
+
+        sqlx::raw_sql(*sql).execute(&mut *connection).await?;
+
+        sqlx::query("INSERT INTO schema_migrations (name, applied_at) VALUES (?, ?)")
+            .bind(*name)
+            .bind(chrono::Utc::now().to_rfc3339())
+            .execute(&mut *connection)
+            .await?;
+
+        tracing::info!(migration = *name, "applied migration");
+    }
+
     Ok(())
 }
+
+async fn is_applied(
+    connection: &mut sqlx::SqliteConnection,
+    name: &str,
+) -> Result<bool, sqlx::Error> {
+    let existing: Option<(String,)> =
+        sqlx::query_as("SELECT name FROM schema_migrations WHERE name = ?")
+            .bind(name)
+            .fetch_optional(&mut *connection)
+            .await?;
+
+    Ok(existing.is_some())
+}
diff --git a/crates/adapters/sqlite/src/migrations/003_entry_content.sql b/crates/adapters/sqlite/src/migrations/003_entry_content.sql
new file mode 100644
index 0000000..ab66a0e
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/003_entry_content.sql
@@ -0,0 +1,4 @@
+CREATE TABLE IF NOT EXISTS entry_content (
+    entry_id TEXT PRIMARY KEY NOT NULL REFERENCES mood_entries(id) ON DELETE CASCADE,
+    content TEXT NOT NULL
+);
diff --git a/crates/adapters/sqlite/src/migrations/004_drop_entry_content_column.sql b/crates/adapters/sqlite/src/migrations/004_drop_entry_content_column.sql
new file mode 100644
index 0000000..86abc15
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/004_drop_entry_content_column.sql
@@ -0,0 +1,4 @@
+INSERT OR IGNORE INTO entry_content (entry_id, content)
+SELECT id, content FROM mood_entries WHERE content IS NOT NULL;
+
+ALTER TABLE mood_entries DROP COLUMN content;
diff --git a/crates/adapters/sqlite/src/migrations/005_location_and_song.sql b/crates/adapters/sqlite/src/migrations/005_location_and_song.sql
new file mode 100644
index 0000000..a19cb47
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/005_location_and_song.sql
@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS entry_location (
+    entry_id TEXT PRIMARY KEY NOT NULL REFERENCES mood_entries(id) ON DELETE CASCADE,
+    latitude REAL NOT NULL,
+    longitude REAL NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS entry_song (
+    entry_id TEXT PRIMARY KEY NOT NULL REFERENCES mood_entries(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    artist TEXT NOT NULL,
+    album TEXT,
+    recording_id TEXT
+);
diff --git a/crates/adapters/sqlite/src/migrations/006_provider_connections.sql b/crates/adapters/sqlite/src/migrations/006_provider_connections.sql
new file mode 100644
index 0000000..8611374
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/006_provider_connections.sql
@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS provider_connections (
+    id TEXT PRIMARY KEY NOT NULL,
+    user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    provider TEXT NOT NULL,
+    credential BLOB NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE (user_id, provider)
+);
+
+CREATE INDEX IF NOT EXISTS idx_provider_connections_user_id ON provider_connections(user_id);
diff --git a/crates/adapters/sqlite/src/migrations/007_daily_metrics.sql b/crates/adapters/sqlite/src/migrations/007_daily_metrics.sql
new file mode 100644
index 0000000..af2dbba
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/007_daily_metrics.sql
@@ -0,0 +1,8 @@
+CREATE TABLE IF NOT EXISTS daily_metrics (
+    user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    date TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    value INTEGER NOT NULL,
+    provider TEXT,
+    PRIMARY KEY (user_id, date, kind)
+);
diff --git a/crates/adapters/sqlite/src/migrations/008_api_tokens.sql b/crates/adapters/sqlite/src/migrations/008_api_tokens.sql
new file mode 100644
index 0000000..3c0bcda
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/008_api_tokens.sql
@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS api_tokens (
+    id TEXT PRIMARY KEY NOT NULL,
+    user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    digest TEXT NOT NULL UNIQUE,
+    scope TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    last_used_at TEXT,
+    UNIQUE (user_id, name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_api_tokens_user_id ON api_tokens(user_id);
diff --git a/crates/adapters/sqlite/src/migrations/009_metric_rejections.sql b/crates/adapters/sqlite/src/migrations/009_metric_rejections.sql
new file mode 100644
index 0000000..549b51a
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/009_metric_rejections.sql
@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS metric_rejections (
+    id TEXT PRIMARY KEY NOT NULL,
+    user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    origin TEXT NOT NULL,
+    provider TEXT,
+    date TEXT,
+    kind TEXT NOT NULL,
+    value INTEGER,
+    reason TEXT NOT NULL,
+    recorded_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_metric_rejections_user ON metric_rejections(user_id, recorded_at);
diff --git a/crates/adapters/sqlite/src/migrations/010_cycle_and_preferences.sql b/crates/adapters/sqlite/src/migrations/010_cycle_and_preferences.sql
new file mode 100644
index 0000000..19b8928
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/010_cycle_and_preferences.sql
@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS cycle_starts (
+    user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    date TEXT NOT NULL,
+    PRIMARY KEY (user_id, date)
+);
+
+CREATE TABLE IF NOT EXISTS user_preferences (
+    user_id TEXT PRIMARY KEY NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    tracks_cycle INTEGER NOT NULL DEFAULT 0
+);
diff --git a/crates/adapters/sqlite/src/migrations/011_jobs.sql b/crates/adapters/sqlite/src/migrations/011_jobs.sql
new file mode 100644
index 0000000..f1fa413
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/011_jobs.sql
@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS jobs (
+    id TEXT PRIMARY KEY NOT NULL,
+    kind TEXT NOT NULL,
+    subject TEXT NOT NULL,
+    status TEXT NOT NULL,
+    attempts INTEGER NOT NULL DEFAULT 0,
+    last_error TEXT,
+    enqueued_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE (kind, subject)
+);
+
+CREATE INDEX IF NOT EXISTS idx_jobs_claimable ON jobs(kind, status, enqueued_at);
diff --git a/crates/adapters/sqlite/src/migrations/012_entry_weather.sql b/crates/adapters/sqlite/src/migrations/012_entry_weather.sql
new file mode 100644
index 0000000..ef90fa9
--- /dev/null
+++ b/crates/adapters/sqlite/src/migrations/012_entry_weather.sql
@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS entry_weather (
+    entry_id TEXT PRIMARY KEY NOT NULL REFERENCES mood_entries(id) ON DELETE CASCADE,
+    condition TEXT NOT NULL,
+    temperature REAL NOT NULL,
+    observed_by TEXT NOT NULL
+);
diff --git a/crates/adapters/sqlite/src/repositories/api_token/command.rs b/crates/adapters/sqlite/src/repositories/api_token/command.rs
new file mode 100644
index 0000000..039dc44
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/api_token/command.rs
@@ -0,0 +1,80 @@
+use sqlx::SqlitePool;
+
+use domain::api_token::{ApiToken, ApiTokenId};
+use domain::errors::DomainError;
+use domain::user::UserId;
+
+use super::super::shared::db_err;
+
+pub struct SqliteApiTokenCommandRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteApiTokenCommandRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::ApiTokenCommandPort for SqliteApiTokenCommandRepository {
+    async fn save(&self, token: &ApiToken) -> Result<(), DomainError> {
+        let taken: Option<(String,)> =
+            sqlx::query_as("SELECT id FROM api_tokens WHERE user_id = ? AND name = ?")
+                .bind(token.user_id().value().to_string())
+                .bind(token.name().value())
+                .fetch_optional(&self.pool)
+                .await
+                .map_err(db_err)?;
+
+        if taken.is_some() {
+            return Err(DomainError::Conflict(format!(
+                "a token named {} already exists",
+                token.name().value()
+            )));
+        }
+
+        sqlx::query(
+            "INSERT INTO api_tokens (id, user_id, name, digest, scope, 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.created_at().to_rfc3339())
+        .bind(token.last_used_at().map(|used| used.to_rfc3339()))
+        .execute(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(())
+    }
+
+    async fn revoke(&self, user_id: &UserId, id: &ApiTokenId) -> Result<(), DomainError> {
+        let removed = sqlx::query("DELETE FROM api_tokens WHERE id = ? AND user_id = ?")
+            .bind(id.value().to_string())
+            .bind(user_id.value().to_string())
+            .execute(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        if removed.rows_affected() == 0 {
+            return Err(DomainError::NotFound("api token not found".into()));
+        }
+
+        Ok(())
+    }
+
+    async fn mark_used(&self, id: &ApiTokenId) -> Result<(), DomainError> {
+        sqlx::query("UPDATE api_tokens SET last_used_at = ? WHERE id = ?")
+            .bind(chrono::Utc::now().to_rfc3339())
+            .bind(id.value().to_string())
+            .execute(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        Ok(())
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/api_token/mod.rs b/crates/adapters/sqlite/src/repositories/api_token/mod.rs
new file mode 100644
index 0000000..345d874
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/api_token/mod.rs
@@ -0,0 +1,6 @@
+mod command;
+mod query;
+mod rows;
+
+pub use command::SqliteApiTokenCommandRepository;
+pub use query::SqliteApiTokenQueryRepository;
diff --git a/crates/adapters/sqlite/src/repositories/api_token/query.rs b/crates/adapters/sqlite/src/repositories/api_token/query.rs
new file mode 100644
index 0000000..11f7181
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/api_token/query.rs
@@ -0,0 +1,47 @@
+use sqlx::SqlitePool;
+
+use domain::api_token::{ApiToken, TokenDigest};
+use domain::errors::DomainError;
+use domain::user::UserId;
+
+use super::super::shared::db_err;
+use super::rows::{ApiTokenRow, readable};
+
+pub struct SqliteApiTokenQueryRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteApiTokenQueryRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait::async_trait]
+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
+             FROM api_tokens WHERE digest = ?",
+        )
+        .bind(digest.value())
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(row.as_ref().and_then(readable))
+    }
+
+    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
+             FROM api_tokens WHERE user_id = ? ORDER BY created_at DESC",
+        )
+        .bind(user_id.value().to_string())
+        .fetch_all(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(rows.iter().filter_map(readable).collect())
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/api_token/rows.rs b/crates/adapters/sqlite/src/repositories/api_token/rows.rs
new file mode 100644
index 0000000..79ba5c9
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/api_token/rows.rs
@@ -0,0 +1,45 @@
+use domain::api_token::{ApiToken, ApiTokenData, ApiTokenId, TokenDigest, TokenScope};
+use domain::provider::ProviderName;
+use domain::user::UserId;
+
+#[derive(sqlx::FromRow)]
+pub struct ApiTokenRow {
+    pub id: String,
+    pub user_id: String,
+    pub name: String,
+    pub digest: String,
+    pub scope: String,
+    pub created_at: String,
+    pub last_used_at: Option<String>,
+}
+
+pub fn row_to_token(row: &ApiTokenRow) -> Option<ApiToken> {
+    let last_used_at = match &row.last_used_at {
+        None => None,
+        Some(stamp) => Some(stamp.parse().ok()?),
+    };
+
+    Some(ApiToken::from_persistence(ApiTokenData {
+        id: ApiTokenId::from_uuid(row.id.parse().ok()?),
+        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)?,
+        created_at: row.created_at.parse().ok()?,
+        last_used_at,
+    }))
+}
+
+pub fn readable(row: &ApiTokenRow) -> Option<ApiToken> {
+    let token = row_to_token(row);
+
+    if token.is_none() {
+        tracing::warn!(
+            token_id = %row.id,
+            scope = %row.scope,
+            "skipped a stored api token this build cannot read"
+        );
+    }
+
+    token
+}
diff --git a/crates/adapters/sqlite/src/repositories/cascade/mod.rs b/crates/adapters/sqlite/src/repositories/cascade/mod.rs
index 794fffb..15dba21 100644
--- a/crates/adapters/sqlite/src/repositories/cascade/mod.rs
+++ b/crates/adapters/sqlite/src/repositories/cascade/mod.rs
@@ -41,6 +41,12 @@ impl domain::ports::CascadeDeletePort for SqliteCascadeDeleteRepository {
             .await
             .map_err(db_err)?;
 
+        sqlx::query("DELETE FROM daily_metrics WHERE user_id = ?")
+            .bind(&uid)
+            .execute(&mut *tx)
+            .await
+            .map_err(db_err)?;
+
         tx.commit().await.map_err(db_err)?;
         Ok(())
     }
diff --git a/crates/adapters/sqlite/src/repositories/cycle/mod.rs b/crates/adapters/sqlite/src/repositories/cycle/mod.rs
new file mode 100644
index 0000000..aa59829
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/cycle/mod.rs
@@ -0,0 +1,3 @@
+mod repository;
+
+pub use repository::{SqliteCycleStartRepository, SqliteUserPreferencesRepository};
diff --git a/crates/adapters/sqlite/src/repositories/cycle/repository.rs b/crates/adapters/sqlite/src/repositories/cycle/repository.rs
new file mode 100644
index 0000000..e6319d4
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/cycle/repository.rs
@@ -0,0 +1,103 @@
+use sqlx::SqlitePool;
+
+use domain::entry::Date;
+use domain::errors::DomainError;
+use domain::user::{UserId, UserPreferences};
+
+use super::super::shared::db_err;
+
+pub struct SqliteCycleStartRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteCycleStartRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::CycleStartCommandPort for SqliteCycleStartRepository {
+    async fn record(&self, user_id: &UserId, date: &Date) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO cycle_starts (user_id, date) VALUES (?, ?)
+             ON CONFLICT(user_id, date) DO NOTHING",
+        )
+        .bind(user_id.value().to_string())
+        .bind(date.to_string())
+        .execute(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(())
+    }
+
+    async fn forget(&self, user_id: &UserId, date: &Date) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM cycle_starts WHERE user_id = ? AND date = ?")
+            .bind(user_id.value().to_string())
+            .bind(date.to_string())
+            .execute(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::CycleStartQueryPort for SqliteCycleStartRepository {
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<Date>, DomainError> {
+        let rows: Vec<(String,)> =
+            sqlx::query_as("SELECT date FROM cycle_starts WHERE user_id = ? ORDER BY date")
+                .bind(user_id.value().to_string())
+                .fetch_all(&self.pool)
+                .await
+                .map_err(db_err)?;
+
+        Ok(rows
+            .iter()
+            .filter_map(|row| row.0.parse().ok().map(Date::from_persistence))
+            .collect())
+    }
+}
+
+pub struct SqliteUserPreferencesRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteUserPreferencesRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::UserPreferencesCommandPort for SqliteUserPreferencesRepository {
+    async fn save(&self, preferences: &UserPreferences) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO user_preferences (user_id, tracks_cycle) VALUES (?, ?)
+             ON CONFLICT(user_id) DO UPDATE SET tracks_cycle = excluded.tracks_cycle",
+        )
+        .bind(preferences.user_id().value().to_string())
+        .bind(preferences.tracks_cycle())
+        .execute(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::UserPreferencesQueryPort for SqliteUserPreferencesRepository {
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Option<UserPreferences>, DomainError> {
+        let row: Option<(bool,)> =
+            sqlx::query_as("SELECT tracks_cycle FROM user_preferences WHERE user_id = ?")
+                .bind(user_id.value().to_string())
+                .fetch_optional(&self.pool)
+                .await
+                .map_err(db_err)?;
+
+        Ok(row.map(|found| UserPreferences::from_persistence(user_id.clone(), found.0)))
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/daily_metric/command.rs b/crates/adapters/sqlite/src/repositories/daily_metric/command.rs
new file mode 100644
index 0000000..1ac6ac9
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/daily_metric/command.rs
@@ -0,0 +1,99 @@
+use sqlx::SqlitePool;
+
+use domain::entry::Date;
+use domain::errors::DomainError;
+use domain::metric::{DailyMetric, MetricKind};
+use domain::user::UserId;
+
+use super::super::shared::db_err;
+use super::rows::{DailyMetricRow, provider_column, source_of};
+
+pub struct SqliteDailyMetricCommandRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteDailyMetricCommandRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::DailyMetricCommandPort for SqliteDailyMetricCommandRepository {
+    async fn save(&self, metrics: &[DailyMetric]) -> Result<usize, DomainError> {
+        let mut tx = self.pool.begin().await.map_err(db_err)?;
+        let mut written = 0;
+
+        for metric in metrics {
+            let user_id = metric.user_id().value().to_string();
+            let date = metric.date().to_string();
+            let kind = metric.kind().name();
+
+            let stored: Option<DailyMetricRow> = sqlx::query_as(
+                "SELECT user_id, date, kind, value, provider FROM daily_metrics
+                 WHERE user_id = ? AND date = ? AND kind = ?",
+            )
+            .bind(&user_id)
+            .bind(&date)
+            .bind(kind)
+            .fetch_optional(&mut *tx)
+            .await
+            .map_err(db_err)?;
+
+            if let Some(row) = &stored
+                && !source_of(row).is_superseded_by(metric.source())
+            {
+                continue;
+            }
+
+            sqlx::query(
+                "INSERT INTO daily_metrics (user_id, date, kind, value, provider)
+                 VALUES (?, ?, ?, ?, ?)
+                 ON CONFLICT(user_id, date, kind) DO UPDATE SET
+                    value = excluded.value, provider = excluded.provider",
+            )
+            .bind(&user_id)
+            .bind(&date)
+            .bind(kind)
+            .bind(metric.value().count())
+            .bind(provider_column(metric.source()))
+            .execute(&mut *tx)
+            .await
+            .map_err(db_err)?;
+
+            written += 1;
+        }
+
+        tx.commit().await.map_err(db_err)?;
+
+        Ok(written)
+    }
+
+    async fn delete(
+        &self,
+        user_id: &UserId,
+        date: &Date,
+        kinds: &[MetricKind],
+    ) -> Result<(), DomainError> {
+        if kinds.is_empty() {
+            return Ok(());
+        }
+
+        let placeholders = vec!["?"; kinds.len()].join(",");
+        let sql = format!(
+            "DELETE FROM daily_metrics WHERE user_id = ? AND date = ? AND kind IN ({placeholders})"
+        );
+
+        let mut query = sqlx::query(sqlx::AssertSqlSafe(sql))
+            .bind(user_id.value().to_string())
+            .bind(date.to_string());
+
+        for kind in kinds {
+            query = query.bind(kind.name());
+        }
+
+        query.execute(&self.pool).await.map_err(db_err)?;
+
+        Ok(())
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/daily_metric/mod.rs b/crates/adapters/sqlite/src/repositories/daily_metric/mod.rs
new file mode 100644
index 0000000..45c1aaf
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/daily_metric/mod.rs
@@ -0,0 +1,6 @@
+mod command;
+mod query;
+mod rows;
+
+pub use command::SqliteDailyMetricCommandRepository;
+pub use query::SqliteDailyMetricQueryRepository;
diff --git a/crates/adapters/sqlite/src/repositories/daily_metric/query.rs b/crates/adapters/sqlite/src/repositories/daily_metric/query.rs
new file mode 100644
index 0000000..5674974
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/daily_metric/query.rs
@@ -0,0 +1,98 @@
+use std::sync::Arc;
+
+use sqlx::SqlitePool;
+
+use domain::entry::DateSpan;
+use domain::errors::DomainError;
+use domain::metric::DailyMetric;
+use domain::ports::RejectionCommandPort;
+use domain::rejection::{RejectedMetric, RejectionDetail, RejectionOrigin};
+use domain::user::UserId;
+
+use super::super::shared::db_err;
+use super::rows::{DailyMetricRow, row_to_metric};
+
+pub struct SqliteDailyMetricQueryRepository {
+    pool: SqlitePool,
+    rejections: Arc<dyn RejectionCommandPort>,
+}
+
+impl SqliteDailyMetricQueryRepository {
+    pub fn new(pool: SqlitePool, rejections: Arc<dyn RejectionCommandPort>) -> Self {
+        Self { pool, rejections }
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::DailyMetricQueryPort for SqliteDailyMetricQueryRepository {
+    async fn find_by_span(
+        &self,
+        user_id: &UserId,
+        span: &DateSpan,
+    ) -> Result<Vec<DailyMetric>, DomainError> {
+        let rows: Vec<DailyMetricRow> = sqlx::query_as(
+            "SELECT user_id, date, kind, value, provider FROM daily_metrics
+             WHERE user_id = ? AND date >= ? AND date <= ?
+             ORDER BY date, kind",
+        )
+        .bind(user_id.value().to_string())
+        .bind(span.start().to_string())
+        .bind(span.end().to_string())
+        .fetch_all(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        let mut readable = Vec::with_capacity(rows.len());
+        let mut unreadable = Vec::new();
+
+        for row in &rows {
+            match row_to_metric(row) {
+                Some(metric) => readable.push(metric),
+                None => unreadable.push(unreadable_row(user_id, row)),
+            }
+        }
+
+        self.trace(&unreadable).await;
+
+        Ok(readable)
+    }
+}
+
+impl SqliteDailyMetricQueryRepository {
+    async fn trace(&self, unreadable: &[RejectedMetric]) {
+        if unreadable.is_empty() {
+            return;
+        }
+
+        tracing::warn!(
+            count = unreadable.len(),
+            "skipped stored metrics this build cannot read"
+        );
+
+        if let Err(error) = self.rejections.record(unreadable).await {
+            tracing::warn!(%error, "could not write to the rejection trace");
+        }
+    }
+}
+
+fn unreadable_row(user_id: &UserId, row: &DailyMetricRow) -> RejectedMetric {
+    let date = row
+        .date
+        .parse()
+        .ok()
+        .map(domain::entry::Date::from_persistence);
+
+    RejectedMetric::new(
+        user_id.clone(),
+        RejectionOrigin::StoredRow,
+        RejectionDetail::new(
+            row.provider
+                .clone()
+                .map(domain::provider::ProviderName::from_persistence),
+            date,
+            row.kind.clone(),
+            Some(row.value),
+        ),
+        "this reading is stored but cannot be read back by this build",
+    )
+}
diff --git a/crates/adapters/sqlite/src/repositories/daily_metric/rows.rs b/crates/adapters/sqlite/src/repositories/daily_metric/rows.rs
new file mode 100644
index 0000000..fac9ed8
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/daily_metric/rows.rs
@@ -0,0 +1,33 @@
+use domain::entry::Date;
+use domain::metric::{DailyMetric, MetricKind, MetricValue, Source};
+use domain::provider::ProviderName;
+use domain::user::UserId;
+
+#[derive(sqlx::FromRow)]
+pub struct DailyMetricRow {
+    pub user_id: String,
+    pub date: String,
+    pub kind: String,
+    pub value: i64,
+    pub provider: Option<String>,
+}
+
+pub fn row_to_metric(row: &DailyMetricRow) -> Option<DailyMetric> {
+    let user_id = row.user_id.parse().ok().map(UserId::from_uuid)?;
+    let date = row.date.parse().ok().map(Date::from_persistence)?;
+    let kind = MetricKind::from_name(&row.kind)?;
+    let value = MetricValue::of_kind(kind, row.value).ok()?;
+
+    Some(DailyMetric::new(user_id, date, value, source_of(row)))
+}
+
+pub fn source_of(row: &DailyMetricRow) -> Source {
+    match &row.provider {
+        None => Source::Manual,
+        Some(name) => Source::Provider(ProviderName::from_persistence(name.clone())),
+    }
+}
+
+pub fn provider_column(source: &Source) -> Option<&str> {
+    source.provider().map(|name| name.value())
+}
diff --git a/crates/adapters/sqlite/src/repositories/dimension/content.rs b/crates/adapters/sqlite/src/repositories/dimension/content.rs
new file mode 100644
index 0000000..33fcf16
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/dimension/content.rs
@@ -0,0 +1,94 @@
+use std::collections::HashMap;
+
+use sqlx::SqlitePool;
+
+use domain::dimension::{DimensionKind, DimensionValue};
+use domain::entry::{Content, MoodEntryId};
+use domain::errors::DomainError;
+
+use super::super::shared::db_err;
+
+pub struct SqliteContentDimensionRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteContentDimensionRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct ContentRow {
+    entry_id: String,
+    content: String,
+}
+
+#[async_trait::async_trait]
+impl domain::ports::EntryDimensionPort for SqliteContentDimensionRepository {
+    async fn load(
+        &self,
+        entry_ids: &[MoodEntryId],
+    ) -> Result<HashMap<MoodEntryId, DimensionValue>, DomainError> {
+        if entry_ids.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        let placeholders = vec!["?"; entry_ids.len()].join(",");
+        let sql = format!(
+            "SELECT entry_id, content FROM entry_content WHERE entry_id IN ({placeholders})"
+        );
+
+        let mut query = sqlx::query_as::<_, ContentRow>(sqlx::AssertSqlSafe(sql));
+        for id in entry_ids {
+            query = query.bind(id.value().to_string());
+        }
+
+        let rows = query.fetch_all(&self.pool).await.map_err(db_err)?;
+
+        Ok(rows
+            .into_iter()
+            .filter_map(|row| {
+                let id = row.entry_id.parse().ok()?;
+                Some((
+                    MoodEntryId::from_uuid(id),
+                    DimensionValue::Content(Content::from_persistence(row.content)),
+                ))
+            })
+            .collect())
+    }
+
+    async fn save(
+        &self,
+        entry_id: &MoodEntryId,
+        values: &[DimensionValue],
+    ) -> Result<(), DomainError> {
+        let id = entry_id.value().to_string();
+
+        match values
+            .iter()
+            .find(|value| value.kind() == DimensionKind::Content)
+        {
+            Some(DimensionValue::Content(content)) => {
+                sqlx::query(
+                    "INSERT INTO entry_content (entry_id, content) VALUES (?, ?)
+                     ON CONFLICT(entry_id) DO UPDATE SET content = excluded.content",
+                )
+                .bind(&id)
+                .bind(content.value())
+                .execute(&self.pool)
+                .await
+                .map_err(db_err)?;
+            }
+            _ => {
+                sqlx::query("DELETE FROM entry_content WHERE entry_id = ?")
+                    .bind(&id)
+                    .execute(&self.pool)
+                    .await
+                    .map_err(db_err)?;
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/dimension/location.rs b/crates/adapters/sqlite/src/repositories/dimension/location.rs
new file mode 100644
index 0000000..261dd6a
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/dimension/location.rs
@@ -0,0 +1,101 @@
+use std::collections::HashMap;
+
+use sqlx::SqlitePool;
+
+use domain::dimension::{DimensionKind, DimensionValue};
+use domain::entry::MoodEntryId;
+use domain::errors::DomainError;
+use domain::location::Coordinates;
+
+use super::super::shared::db_err;
+
+pub struct SqliteLocationDimensionRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteLocationDimensionRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct LocationRow {
+    entry_id: String,
+    latitude: f64,
+    longitude: f64,
+}
+
+#[async_trait::async_trait]
+impl domain::ports::EntryDimensionPort for SqliteLocationDimensionRepository {
+    async fn load(
+        &self,
+        entry_ids: &[MoodEntryId],
+    ) -> Result<HashMap<MoodEntryId, DimensionValue>, DomainError> {
+        if entry_ids.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        let placeholders = vec!["?"; entry_ids.len()].join(",");
+        let sql = format!(
+            "SELECT entry_id, latitude, longitude FROM entry_location WHERE entry_id IN ({placeholders})"
+        );
+
+        let mut query = sqlx::query_as::<_, LocationRow>(sqlx::AssertSqlSafe(sql));
+        for id in entry_ids {
+            query = query.bind(id.value().to_string());
+        }
+
+        let rows = query.fetch_all(&self.pool).await.map_err(db_err)?;
+
+        Ok(rows
+            .into_iter()
+            .filter_map(|row| {
+                let entry_id = row.entry_id.parse().ok()?;
+                Some((
+                    MoodEntryId::from_uuid(entry_id),
+                    DimensionValue::Location(Coordinates::from_persistence(
+                        row.latitude,
+                        row.longitude,
+                    )),
+                ))
+            })
+            .collect())
+    }
+
+    async fn save(
+        &self,
+        entry_id: &MoodEntryId,
+        values: &[DimensionValue],
+    ) -> Result<(), DomainError> {
+        let id = entry_id.value().to_string();
+
+        match values
+            .iter()
+            .find(|value| value.kind() == DimensionKind::Location)
+        {
+            Some(DimensionValue::Location(coordinates)) => {
+                sqlx::query(
+                    "INSERT INTO entry_location (entry_id, latitude, longitude) VALUES (?, ?, ?)
+                     ON CONFLICT(entry_id) DO UPDATE SET
+                        latitude = excluded.latitude, longitude = excluded.longitude",
+                )
+                .bind(&id)
+                .bind(coordinates.latitude().value())
+                .bind(coordinates.longitude().value())
+                .execute(&self.pool)
+                .await
+                .map_err(db_err)?;
+            }
+            _ => {
+                sqlx::query("DELETE FROM entry_location WHERE entry_id = ?")
+                    .bind(&id)
+                    .execute(&self.pool)
+                    .await
+                    .map_err(db_err)?;
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/dimension/mod.rs b/crates/adapters/sqlite/src/repositories/dimension/mod.rs
new file mode 100644
index 0000000..bb4b9ca
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/dimension/mod.rs
@@ -0,0 +1,11 @@
+mod content;
+mod location;
+mod relation;
+mod song;
+mod weather;
+
+pub use content::SqliteContentDimensionRepository;
+pub use location::SqliteLocationDimensionRepository;
+pub use relation::SqliteRelationDimensionRepository;
+pub use song::SqliteSongDimensionRepository;
+pub use weather::SqliteWeatherDimensionRepository;
diff --git a/crates/adapters/sqlite/src/repositories/dimension/relation.rs b/crates/adapters/sqlite/src/repositories/dimension/relation.rs
new file mode 100644
index 0000000..59d3de5
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/dimension/relation.rs
@@ -0,0 +1,166 @@
+use std::collections::HashMap;
+
+use sqlx::SqlitePool;
+use uuid::Uuid;
+
+use domain::activity::ActivityId;
+use domain::attachment::{PhotoId, VoiceMemoId};
+use domain::dimension::{DimensionKind, DimensionValue};
+use domain::entry::MoodEntryId;
+use domain::errors::DomainError;
+
+use super::super::shared::db_err;
+
+pub struct SqliteRelationDimensionRepository {
+    pool: SqlitePool,
+    table: &'static str,
+    column: &'static str,
+    kind: DimensionKind,
+}
+
+impl SqliteRelationDimensionRepository {
+    pub fn activities(pool: SqlitePool) -> Self {
+        Self {
+            pool,
+            table: "entry_activities",
+            column: "activity_id",
+            kind: DimensionKind::Activities,
+        }
+    }
+
+    pub fn photos(pool: SqlitePool) -> Self {
+        Self {
+            pool,
+            table: "entry_photos",
+            column: "photo_id",
+            kind: DimensionKind::Photos,
+        }
+    }
+
+    pub fn voice_memos(pool: SqlitePool) -> Self {
+        Self {
+            pool,
+            table: "entry_voice_memos",
+            column: "voice_memo_id",
+            kind: DimensionKind::VoiceMemos,
+        }
+    }
+
+    fn to_value(&self, ids: Vec<Uuid>) -> DimensionValue {
+        match self.kind {
+            DimensionKind::Activities => {
+                DimensionValue::Activities(ids.into_iter().map(ActivityId::from_uuid).collect())
+            }
+            DimensionKind::Photos => {
+                DimensionValue::Photos(ids.into_iter().map(PhotoId::from_uuid).collect())
+            }
+            DimensionKind::VoiceMemos => {
+                DimensionValue::VoiceMemos(ids.into_iter().map(VoiceMemoId::from_uuid).collect())
+            }
+            DimensionKind::Content
+            | DimensionKind::Location
+            | DimensionKind::Song
+            | DimensionKind::Weather => {
+                unreachable!("relation repository serves only id-list dimensions")
+            }
+        }
+    }
+}
+
+fn related_ids(value: &DimensionValue) -> Vec<String> {
+    match value {
+        DimensionValue::Activities(ids) => ids.iter().map(|id| id.value().to_string()).collect(),
+        DimensionValue::Photos(ids) => ids.iter().map(|id| id.value().to_string()).collect(),
+        DimensionValue::VoiceMemos(ids) => ids.iter().map(|id| id.value().to_string()).collect(),
+        DimensionValue::Content(_)
+        | DimensionValue::Location(_)
+        | DimensionValue::Song(_)
+        | DimensionValue::Weather(_) => Vec::new(),
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct RelationRow {
+    entry_id: String,
+    related_id: String,
+}
+
+#[async_trait::async_trait]
+impl domain::ports::EntryDimensionPort for SqliteRelationDimensionRepository {
+    async fn load(
+        &self,
+        entry_ids: &[MoodEntryId],
+    ) -> Result<HashMap<MoodEntryId, DimensionValue>, DomainError> {
+        if entry_ids.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        let placeholders = vec!["?"; entry_ids.len()].join(",");
+        let sql = format!(
+            "SELECT entry_id, {} AS related_id FROM {} WHERE entry_id IN ({placeholders})",
+            self.column, self.table
+        );
+
+        let mut query = sqlx::query_as::<_, RelationRow>(sqlx::AssertSqlSafe(sql));
+        for id in entry_ids {
+            query = query.bind(id.value().to_string());
+        }
+
+        let rows = query.fetch_all(&self.pool).await.map_err(db_err)?;
+
+        let mut grouped: HashMap<MoodEntryId, Vec<Uuid>> = HashMap::new();
+        for row in rows {
+            let (Ok(entry_id), Ok(related_id)) =
+                (row.entry_id.parse::<Uuid>(), row.related_id.parse::<Uuid>())
+            else {
+                continue;
+            };
+            grouped
+                .entry(MoodEntryId::from_uuid(entry_id))
+                .or_default()
+                .push(related_id);
+        }
+
+        Ok(grouped
+            .into_iter()
+            .map(|(entry_id, ids)| (entry_id, self.to_value(ids)))
+            .collect())
+    }
+
+    async fn save(
+        &self,
+        entry_id: &MoodEntryId,
+        values: &[DimensionValue],
+    ) -> Result<(), DomainError> {
+        let id = entry_id.value().to_string();
+
+        let mut tx = self.pool.begin().await.map_err(db_err)?;
+
+        sqlx::query(sqlx::AssertSqlSafe(format!(
+            "DELETE FROM {} WHERE entry_id = ?",
+            self.table
+        )))
+        .bind(&id)
+        .execute(&mut *tx)
+        .await
+        .map_err(db_err)?;
+
+        if let Some(value) = values.iter().find(|value| value.kind() == self.kind) {
+            let insert = format!(
+                "INSERT OR IGNORE INTO {} (entry_id, {}) VALUES (?, ?)",
+                self.table, self.column
+            );
+            for related in related_ids(value) {
+                sqlx::query(sqlx::AssertSqlSafe(insert.clone()))
+                    .bind(&id)
+                    .bind(related)
+                    .execute(&mut *tx)
+                    .await
+                    .map_err(db_err)?;
+            }
+        }
+
+        tx.commit().await.map_err(db_err)?;
+        Ok(())
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/dimension/song.rs b/crates/adapters/sqlite/src/repositories/dimension/song.rs
new file mode 100644
index 0000000..7ceb965
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/dimension/song.rs
@@ -0,0 +1,109 @@
+use std::collections::HashMap;
+
+use sqlx::SqlitePool;
+
+use domain::dimension::{DimensionKind, DimensionValue};
+use domain::entry::MoodEntryId;
+use domain::errors::DomainError;
+use domain::song::{AlbumName, ArtistName, RecordingId, Song, SongTitle};
+
+use super::super::shared::db_err;
+
+pub struct SqliteSongDimensionRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteSongDimensionRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct SongRow {
+    entry_id: String,
+    title: String,
+    artist: String,
+    album: Option<String>,
+    recording_id: Option<String>,
+}
+
+#[async_trait::async_trait]
+impl domain::ports::EntryDimensionPort for SqliteSongDimensionRepository {
+    async fn load(
+        &self,
+        entry_ids: &[MoodEntryId],
+    ) -> Result<HashMap<MoodEntryId, DimensionValue>, DomainError> {
+        if entry_ids.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        let placeholders = vec!["?"; entry_ids.len()].join(",");
+        let sql = format!(
+            "SELECT entry_id, title, artist, album, recording_id FROM entry_song WHERE entry_id IN ({placeholders})"
+        );
+
+        let mut query = sqlx::query_as::<_, SongRow>(sqlx::AssertSqlSafe(sql));
+        for id in entry_ids {
+            query = query.bind(id.value().to_string());
+        }
+
+        let rows = query.fetch_all(&self.pool).await.map_err(db_err)?;
+
+        Ok(rows
+            .into_iter()
+            .filter_map(|row| {
+                let entry_id = row.entry_id.parse().ok()?;
+                let song = Song::from_persistence(
+                    SongTitle::from_persistence(row.title),
+                    ArtistName::from_persistence(row.artist),
+                    row.album.map(AlbumName::from_persistence),
+                    row.recording_id
+                        .and_then(|id| id.parse().ok())
+                        .map(RecordingId::from_uuid),
+                );
+                Some((MoodEntryId::from_uuid(entry_id), DimensionValue::Song(song)))
+            })
+            .collect())
+    }
+
+    async fn save(
+        &self,
+        entry_id: &MoodEntryId,
+        values: &[DimensionValue],
+    ) -> Result<(), DomainError> {
+        let id = entry_id.value().to_string();
+
+        match values
+            .iter()
+            .find(|value| value.kind() == DimensionKind::Song)
+        {
+            Some(DimensionValue::Song(song)) => {
+                sqlx::query(
+                    "INSERT INTO entry_song (entry_id, title, artist, album, recording_id)
+                     VALUES (?, ?, ?, ?, ?)
+                     ON CONFLICT(entry_id) DO UPDATE SET
+                        title = excluded.title, artist = excluded.artist,
+                        album = excluded.album, recording_id = excluded.recording_id",
+                )
+                .bind(&id)
+                .bind(song.title().value())
+                .bind(song.artist().value())
+                .bind(song.album().map(|album| album.value().to_string()))
+                .bind(song.recording_id().map(|id| id.value().to_string()))
+                .execute(&self.pool)
+                .await
+                .map_err(db_err)?;
+            }
+            _ => {
+                sqlx::query("DELETE FROM entry_song WHERE entry_id = ?")
+                    .bind(&id)
+                    .execute(&self.pool)
+                    .await
+                    .map_err(db_err)?;
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/dimension/weather.rs b/crates/adapters/sqlite/src/repositories/dimension/weather.rs
new file mode 100644
index 0000000..2069c01
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/dimension/weather.rs
@@ -0,0 +1,109 @@
+use std::collections::HashMap;
+
+use sqlx::SqlitePool;
+
+use domain::dimension::{DimensionKind, DimensionValue};
+use domain::entry::MoodEntryId;
+use domain::errors::DomainError;
+use domain::provider::ProviderName;
+use domain::weather::{Celsius, Condition, Weather};
+
+use super::super::shared::db_err;
+
+pub struct SqliteWeatherDimensionRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteWeatherDimensionRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct WeatherRow {
+    entry_id: String,
+    condition: String,
+    temperature: f64,
+    observed_by: String,
+}
+
+#[async_trait::async_trait]
+impl domain::ports::EntryDimensionPort for SqliteWeatherDimensionRepository {
+    async fn load(
+        &self,
+        entry_ids: &[MoodEntryId],
+    ) -> Result<HashMap<MoodEntryId, DimensionValue>, DomainError> {
+        if entry_ids.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        let placeholders = vec!["?"; entry_ids.len()].join(",");
+        let sql = format!(
+            "SELECT entry_id, condition, temperature, observed_by
+             FROM entry_weather WHERE entry_id IN ({placeholders})"
+        );
+
+        let mut query = sqlx::query_as::<_, WeatherRow>(sqlx::AssertSqlSafe(sql));
+        for id in entry_ids {
+            query = query.bind(id.value().to_string());
+        }
+
+        let rows = query.fetch_all(&self.pool).await.map_err(db_err)?;
+
+        Ok(rows.iter().filter_map(readable).collect())
+    }
+
+    async fn save(
+        &self,
+        entry_id: &MoodEntryId,
+        values: &[DimensionValue],
+    ) -> Result<(), DomainError> {
+        let observed = values
+            .iter()
+            .find(|value| value.kind() == DimensionKind::Weather);
+
+        let Some(DimensionValue::Weather(weather)) = observed else {
+            return Ok(());
+        };
+
+        sqlx::query(
+            "INSERT INTO entry_weather (entry_id, condition, temperature, observed_by)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(entry_id) DO UPDATE SET
+                condition = excluded.condition,
+                temperature = excluded.temperature,
+                observed_by = excluded.observed_by",
+        )
+        .bind(entry_id.value().to_string())
+        .bind(weather.condition().name())
+        .bind(weather.temperature().value())
+        .bind(weather.observed_by().value())
+        .execute(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(())
+    }
+}
+
+fn readable(row: &WeatherRow) -> Option<(MoodEntryId, DimensionValue)> {
+    let entry_id = MoodEntryId::from_uuid(row.entry_id.parse().ok()?);
+    let condition = Condition::from_name(&row.condition);
+
+    if condition.is_none() {
+        tracing::warn!(
+            entry_id = %row.entry_id,
+            condition = %row.condition,
+            "skipped stored weather this build cannot read"
+        );
+    }
+
+    let weather = Weather::new(
+        condition?,
+        Celsius::from_persistence(row.temperature),
+        ProviderName::from_persistence(row.observed_by.clone()),
+    );
+
+    Some((entry_id, DimensionValue::Weather(weather)))
+}
diff --git a/crates/adapters/sqlite/src/repositories/entry/command.rs b/crates/adapters/sqlite/src/repositories/entry/command.rs
index d8f00ca..394ce50 100644
--- a/crates/adapters/sqlite/src/repositories/entry/command.rs
+++ b/crates/adapters/sqlite/src/repositories/entry/command.rs
@@ -15,78 +15,29 @@ impl SqliteEntryCommandRepository {
     pub fn new(pool: SqlitePool) -> Self {
         Self { pool }
     }
-
-    async fn save_relations(&self, entry: &MoodEntry) -> Result<(), DomainError> {
-        let entry_id = entry.id().value().to_string();
-
-        sqlx::query("DELETE FROM entry_activities WHERE entry_id = ?")
-            .bind(&entry_id)
-            .execute(&self.pool)
-            .await
-            .map_err(db_err)?;
-        for activity_id in entry.activities() {
-            sqlx::query("INSERT INTO entry_activities (entry_id, activity_id) VALUES (?, ?)")
-                .bind(&entry_id)
-                .bind(activity_id.value().to_string())
-                .execute(&self.pool)
-                .await
-                .map_err(db_err)?;
-        }
-
-        sqlx::query("DELETE FROM entry_photos WHERE entry_id = ?")
-            .bind(&entry_id)
-            .execute(&self.pool)
-            .await
-            .map_err(db_err)?;
-        for photo_id in entry.photos() {
-            sqlx::query("INSERT INTO entry_photos (entry_id, photo_id) VALUES (?, ?)")
-                .bind(&entry_id)
-                .bind(photo_id.value().to_string())
-                .execute(&self.pool)
-                .await
-                .map_err(db_err)?;
-        }
-
-        sqlx::query("DELETE FROM entry_voice_memos WHERE entry_id = ?")
-            .bind(&entry_id)
-            .execute(&self.pool)
-            .await
-            .map_err(db_err)?;
-        for voice_memo_id in entry.voice_memos() {
-            sqlx::query("INSERT INTO entry_voice_memos (entry_id, voice_memo_id) VALUES (?, ?)")
-                .bind(&entry_id)
-                .bind(voice_memo_id.value().to_string())
-                .execute(&self.pool)
-                .await
-                .map_err(db_err)?;
-        }
-
-        Ok(())
-    }
 }
 
 #[async_trait::async_trait]
 impl domain::ports::MoodEntryCommandPort for SqliteEntryCommandRepository {
     async fn save(&self, entry: &MoodEntry) -> Result<(), DomainError> {
         sqlx::query(
-            "INSERT INTO mood_entries (id, user_id, mood, logged_at, content, created_at, updated_at)
-             VALUES (?, ?, ?, ?, ?, ?, ?)
+            "INSERT INTO mood_entries (id, user_id, mood, logged_at, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?)
              ON CONFLICT(id) DO UPDATE SET
                 mood = excluded.mood, logged_at = excluded.logged_at,
-                content = excluded.content, updated_at = excluded.updated_at"
+                updated_at = excluded.updated_at",
         )
         .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(entry.content().map(|c| c.value().to_string()))
         .bind(entry.created_at().to_rfc3339())
         .bind(entry.updated_at().to_rfc3339())
         .execute(&self.pool)
         .await
         .map_err(db_err)?;
 
-        self.save_relations(entry).await
+        Ok(())
     }
 
     async fn save_batch(&self, entries: &[MoodEntry]) -> Result<(), DomainError> {
@@ -96,51 +47,21 @@ impl domain::ports::MoodEntryCommandPort for SqliteEntryCommandRepository {
             let entry_id = entry.id().value().to_string();
 
             sqlx::query(
-                "INSERT INTO mood_entries (id, user_id, mood, logged_at, content, created_at, updated_at)
-                 VALUES (?, ?, ?, ?, ?, ?, ?)
+                "INSERT INTO mood_entries (id, user_id, mood, logged_at, created_at, updated_at)
+                 VALUES (?, ?, ?, ?, ?, ?)
                  ON CONFLICT(id) DO UPDATE SET
                     mood = excluded.mood, logged_at = excluded.logged_at,
-                    content = excluded.content, updated_at = excluded.updated_at"
+                    updated_at = excluded.updated_at",
             )
             .bind(&entry_id)
             .bind(entry.user_id().value().to_string())
             .bind(entry.mood().value() as i32)
             .bind(entry.logged_at().to_rfc3339())
-            .bind(entry.content().map(|c| c.value().to_string()))
             .bind(entry.created_at().to_rfc3339())
             .bind(entry.updated_at().to_rfc3339())
             .execute(&mut *tx)
             .await
             .map_err(db_err)?;
-
-            for activity_id in entry.activities() {
-                sqlx::query("INSERT INTO entry_activities (entry_id, activity_id) VALUES (?, ?)")
-                    .bind(&entry_id)
-                    .bind(activity_id.value().to_string())
-                    .execute(&mut *tx)
-                    .await
-                    .map_err(db_err)?;
-            }
-
-            for photo_id in entry.photos() {
-                sqlx::query("INSERT INTO entry_photos (entry_id, photo_id) VALUES (?, ?)")
-                    .bind(&entry_id)
-                    .bind(photo_id.value().to_string())
-                    .execute(&mut *tx)
-                    .await
-                    .map_err(db_err)?;
-            }
-
-            for voice_memo_id in entry.voice_memos() {
-                sqlx::query(
-                    "INSERT INTO entry_voice_memos (entry_id, voice_memo_id) VALUES (?, ?)",
-                )
-                .bind(&entry_id)
-                .bind(voice_memo_id.value().to_string())
-                .execute(&mut *tx)
-                .await
-                .map_err(db_err)?;
-            }
         }
 
         tx.commit().await.map_err(db_err)?;
diff --git a/crates/adapters/sqlite/src/repositories/entry/rows.rs b/crates/adapters/sqlite/src/repositories/entry/rows.rs
index 1946456..19f3fdc 100644
--- a/crates/adapters/sqlite/src/repositories/entry/rows.rs
+++ b/crates/adapters/sqlite/src/repositories/entry/rows.rs
@@ -1,153 +1,39 @@
-use std::collections::HashMap;
-
 use sqlx::SqlitePool;
 
-use domain::activity::ActivityId;
-use domain::attachment::{PhotoId, VoiceMemoId};
-use domain::entry::{Content, Mood, MoodEntry, MoodEntryData, MoodEntryId};
+use domain::entry::{Mood, MoodEntry, MoodEntryData, MoodEntryId};
 use domain::errors::DomainError;
 use domain::user::UserId;
 
-use super::super::shared::db_err;
-
 #[derive(sqlx::FromRow)]
 pub struct EntryRow {
     pub id: String,
     pub user_id: String,
     pub mood: i32,
     pub logged_at: String,
-    pub content: Option<String>,
     pub created_at: String,
     pub updated_at: String,
 }
 
-#[derive(sqlx::FromRow)]
-struct RelationRow {
-    entry_id: String,
-    related_id: String,
-}
+pub fn row_to_entry(row: EntryRow) -> Result<MoodEntry, DomainError> {
+    let parse_failed = || DomainError::InvalidInput("stored entry row is malformed".into());
 
-pub fn row_to_entry(
-    row: EntryRow,
-    activity_ids: Vec<String>,
-    photo_ids: Vec<String>,
-    voice_memo_ids: Vec<String>,
-) -> Result<MoodEntry, DomainError> {
     Ok(MoodEntry::from_persistence(MoodEntryData {
-        id: MoodEntryId::from_uuid(row.id.parse().unwrap()),
-        user_id: UserId::from_uuid(row.user_id.parse().unwrap()),
+        id: MoodEntryId::from_uuid(row.id.parse().map_err(|_| parse_failed())?),
+        user_id: UserId::from_uuid(row.user_id.parse().map_err(|_| parse_failed())?),
         mood: Mood::try_from(row.mood as u8)?,
-        logged_at: row.logged_at.parse().unwrap(),
-        activities: activity_ids
-            .into_iter()
-            .map(|id| ActivityId::from_uuid(id.parse().unwrap()))
-            .collect(),
-        content: row.content.map(Content::from_persistence),
-        photos: photo_ids
-            .into_iter()
-            .map(|id| PhotoId::from_uuid(id.parse().unwrap()))
-            .collect(),
-        voice_memos: voice_memo_ids
-            .into_iter()
-            .map(|id| VoiceMemoId::from_uuid(id.parse().unwrap()))
-            .collect(),
-        created_at: row.created_at.parse().unwrap(),
-        updated_at: row.updated_at.parse().unwrap(),
+        logged_at: row.logged_at.parse().map_err(|_| parse_failed())?,
+        created_at: row.created_at.parse().map_err(|_| parse_failed())?,
+        updated_at: row.updated_at.parse().map_err(|_| parse_failed())?,
     }))
 }
 
-pub async fn hydrate_single(pool: &SqlitePool, row: EntryRow) -> Result<MoodEntry, DomainError> {
-    let entry_id = row.id.clone();
-
-    let activities: Vec<RelationRow> = sqlx::query_as(
-        "SELECT entry_id, activity_id AS related_id FROM entry_activities WHERE entry_id = ?",
-    )
-    .bind(&entry_id)
-    .fetch_all(pool)
-    .await
-    .map_err(db_err)?;
-
-    let photos: Vec<RelationRow> = sqlx::query_as(
-        "SELECT entry_id, photo_id AS related_id FROM entry_photos WHERE entry_id = ?",
-    )
-    .bind(&entry_id)
-    .fetch_all(pool)
-    .await
-    .map_err(db_err)?;
-
-    let voice_memos: Vec<RelationRow> = sqlx::query_as(
-        "SELECT entry_id, voice_memo_id AS related_id FROM entry_voice_memos WHERE entry_id = ?",
-    )
-    .bind(&entry_id)
-    .fetch_all(pool)
-    .await
-    .map_err(db_err)?;
-
-    row_to_entry(
-        row,
-        activities.into_iter().map(|r| r.related_id).collect(),
-        photos.into_iter().map(|r| r.related_id).collect(),
-        voice_memos.into_iter().map(|r| r.related_id).collect(),
-    )
+pub async fn hydrate_single(_pool: &SqlitePool, row: EntryRow) -> Result<MoodEntry, DomainError> {
+    row_to_entry(row)
 }
 
 pub async fn hydrate_batch(
-    pool: &SqlitePool,
+    _pool: &SqlitePool,
     rows: Vec<EntryRow>,
 ) -> Result<Vec<MoodEntry>, DomainError> {
-    if rows.is_empty() {
-        return Ok(Vec::new());
-    }
-
-    let entry_ids: Vec<String> = rows.iter().map(|r| r.id.clone()).collect();
-    let placeholders = vec!["?"; entry_ids.len()].join(",");
-
-    let activities = batch_load(
-        pool,
-        &format!("SELECT entry_id, activity_id AS related_id FROM entry_activities WHERE entry_id IN ({placeholders})"),
-        &entry_ids,
-    ).await?;
-
-    let photos = batch_load(
-        pool,
-        &format!("SELECT entry_id, photo_id AS related_id FROM entry_photos WHERE entry_id IN ({placeholders})"),
-        &entry_ids,
-    ).await?;
-
-    let voice_memos = batch_load(
-        pool,
-        &format!("SELECT entry_id, voice_memo_id AS related_id FROM entry_voice_memos WHERE entry_id IN ({placeholders})"),
-        &entry_ids,
-    ).await?;
-
-    let mut entries = Vec::with_capacity(rows.len());
-    for row in rows {
-        let id = row.id.clone();
-        entries.push(row_to_entry(
-            row,
-            activities.get(&id).cloned().unwrap_or_default(),
-            photos.get(&id).cloned().unwrap_or_default(),
-            voice_memos.get(&id).cloned().unwrap_or_default(),
-        )?);
-    }
-    Ok(entries)
-}
-
-async fn batch_load(
-    pool: &SqlitePool,
-    sql: &str,
-    entry_ids: &[String],
-) -> Result<HashMap<String, Vec<String>>, DomainError> {
-    let mut query = sqlx::query_as::<_, RelationRow>(sqlx::AssertSqlSafe(sql));
-    for id in entry_ids {
-        query = query.bind(id);
-    }
-
-    let rows = query.fetch_all(pool).await.map_err(db_err)?;
-
-    let mut map: HashMap<String, Vec<String>> = HashMap::new();
-    for row in rows {
-        map.entry(row.entry_id).or_default().push(row.related_id);
-    }
-    Ok(map)
+    rows.into_iter().map(row_to_entry).collect()
 }
diff --git a/crates/adapters/sqlite/src/repositories/job/backfill.rs b/crates/adapters/sqlite/src/repositories/job/backfill.rs
new file mode 100644
index 0000000..ed58f4f
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/job/backfill.rs
@@ -0,0 +1,78 @@
+use sqlx::SqlitePool;
+
+use domain::entry::MoodEntryId;
+use domain::errors::DomainError;
+use domain::ports::UnidentifiedSong;
+use domain::song::RecordingId;
+use domain::user::UserId;
+
+use super::super::shared::db_err;
+
+pub struct SqliteRecordingBackfillRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteRecordingBackfillRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct UnidentifiedSongRow {
+    entry_id: String,
+    user_id: String,
+    title: String,
+    artist: String,
+}
+
+#[async_trait::async_trait]
+impl domain::ports::RecordingBackfillQueryPort for SqliteRecordingBackfillRepository {
+    async fn find_songs_without_a_recording(
+        &self,
+        most: usize,
+    ) -> Result<Vec<UnidentifiedSong>, DomainError> {
+        let rows: Vec<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
+             ORDER BY e.logged_at DESC
+             LIMIT ?",
+        )
+        .bind(most_as_limit(most))
+        .fetch_all(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(rows.iter().filter_map(readable).collect())
+    }
+
+    async fn record_identity(
+        &self,
+        entry_id: &MoodEntryId,
+        recording_id: &RecordingId,
+    ) -> Result<(), DomainError> {
+        sqlx::query("UPDATE entry_song SET recording_id = ? WHERE entry_id = ?")
+            .bind(recording_id.value().to_string())
+            .bind(entry_id.value().to_string())
+            .execute(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        Ok(())
+    }
+}
+
+fn most_as_limit(most: usize) -> i64 {
+    i64::try_from(most).unwrap_or(i64::MAX)
+}
+
+fn readable(row: &UnidentifiedSongRow) -> Option<UnidentifiedSong> {
+    Some(UnidentifiedSong {
+        entry_id: MoodEntryId::from_uuid(row.entry_id.parse().ok()?),
+        user_id: UserId::from_uuid(row.user_id.parse().ok()?),
+        title: row.title.clone(),
+        artist: row.artist.clone(),
+    })
+}
diff --git a/crates/adapters/sqlite/src/repositories/job/mod.rs b/crates/adapters/sqlite/src/repositories/job/mod.rs
new file mode 100644
index 0000000..b99b28f
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/job/mod.rs
@@ -0,0 +1,8 @@
+mod backfill;
+mod repository;
+mod rows;
+mod weather;
+
+pub use backfill::SqliteRecordingBackfillRepository;
+pub use repository::SqliteJobQueueRepository;
+pub use weather::SqliteWeatherBacklogRepository;
diff --git a/crates/adapters/sqlite/src/repositories/job/repository.rs b/crates/adapters/sqlite/src/repositories/job/repository.rs
new file mode 100644
index 0000000..1a213f2
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/job/repository.rs
@@ -0,0 +1,160 @@
+use sqlx::SqlitePool;
+
+use domain::errors::DomainError;
+use domain::job::{Job, JobId, JobKind, JobStatus, JobSubject};
+
+use super::super::shared::db_err;
+use super::rows::{JobRow, readable};
+
+const COLUMNS: &str = "id, kind, subject, status, attempts, last_error, enqueued_at, updated_at";
+
+pub struct SqliteJobQueueRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteJobQueueRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::JobQueueCommandPort for SqliteJobQueueRepository {
+    async fn enqueue(&self, kind: JobKind, subject: &JobSubject) -> Result<bool, DomainError> {
+        let job = Job::pending(kind, subject.clone());
+
+        let written = sqlx::query(
+            "INSERT INTO jobs (id, kind, subject, status, attempts, last_error, enqueued_at, updated_at)
+             VALUES (?, ?, ?, ?, 0, NULL, ?, ?)
+             ON CONFLICT(kind, subject) DO NOTHING",
+        )
+        .bind(job.id().value().to_string())
+        .bind(kind.name())
+        .bind(subject.key())
+        .bind(JobStatus::Pending.name())
+        .bind(job.enqueued_at().to_rfc3339())
+        .bind(job.updated_at().to_rfc3339())
+        .execute(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(written.rows_affected() > 0)
+    }
+
+    async fn claim(&self, kind: JobKind, most: usize) -> Result<Vec<Job>, DomainError> {
+        let sql = format!(
+            "UPDATE jobs SET status = ?, updated_at = ?
+             WHERE id IN (
+                 SELECT id FROM jobs WHERE kind = ? AND status = ?
+                 ORDER BY enqueued_at LIMIT ?
+             )
+             RETURNING {COLUMNS}"
+        );
+
+        let rows: Vec<JobRow> = sqlx::query_as(sqlx::AssertSqlSafe(sql))
+            .bind(JobStatus::Running.name())
+            .bind(chrono::Utc::now().to_rfc3339())
+            .bind(kind.name())
+            .bind(JobStatus::Pending.name())
+            .bind(most as i64)
+            .fetch_all(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        let mut claimed = Vec::with_capacity(rows.len());
+
+        for row in &rows {
+            match readable(row) {
+                Some(job) => claimed.push(job),
+                None => self.abandon_unreadable(row).await?,
+            }
+        }
+
+        Ok(claimed)
+    }
+
+    async fn finish(&self, id: &JobId) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM jobs WHERE id = ?")
+            .bind(id.value().to_string())
+            .execute(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        Ok(())
+    }
+
+    async fn release(&self, id: &JobId, reason: &str) -> Result<(), DomainError> {
+        self.settle(id, JobStatus::Pending, reason).await
+    }
+
+    async fn exhaust(&self, id: &JobId, reason: &str) -> Result<(), DomainError> {
+        self.settle(id, JobStatus::Exhausted, reason).await
+    }
+
+    async fn reclaim_stalled(&self, stalled_after_seconds: i64) -> Result<u64, DomainError> {
+        let stalled_before =
+            chrono::Utc::now() - chrono::Duration::seconds(stalled_after_seconds.max(0));
+
+        let reclaimed = sqlx::query(
+            "UPDATE jobs SET status = ?, updated_at = ?
+             WHERE status = ? AND updated_at <= ?",
+        )
+        .bind(JobStatus::Pending.name())
+        .bind(chrono::Utc::now().to_rfc3339())
+        .bind(JobStatus::Running.name())
+        .bind(stalled_before.to_rfc3339())
+        .execute(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(reclaimed.rows_affected())
+    }
+}
+
+impl SqliteJobQueueRepository {
+    async fn abandon_unreadable(&self, row: &JobRow) -> Result<(), DomainError> {
+        sqlx::query("UPDATE jobs SET status = ?, last_error = ?, updated_at = ? WHERE id = ?")
+            .bind(JobStatus::Exhausted.name())
+            .bind("this job is stored in a shape this build cannot read")
+            .bind(chrono::Utc::now().to_rfc3339())
+            .bind(&row.id)
+            .execute(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        Ok(())
+    }
+
+    async fn settle(&self, id: &JobId, status: JobStatus, reason: &str) -> Result<(), DomainError> {
+        sqlx::query(
+            "UPDATE jobs SET status = ?, attempts = attempts + 1, last_error = ?, updated_at = ?
+             WHERE id = ?",
+        )
+        .bind(status.name())
+        .bind(reason)
+        .bind(chrono::Utc::now().to_rfc3339())
+        .bind(id.value().to_string())
+        .execute(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::JobQueueQueryPort for SqliteJobQueueRepository {
+    async fn find_exhausted(&self, most: usize) -> Result<Vec<Job>, DomainError> {
+        let sql =
+            format!("SELECT {COLUMNS} FROM jobs WHERE status = ? ORDER BY updated_at DESC LIMIT ?");
+
+        let rows: Vec<JobRow> = sqlx::query_as(sqlx::AssertSqlSafe(sql))
+            .bind(JobStatus::Exhausted.name())
+            .bind(most as i64)
+            .fetch_all(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        Ok(rows.iter().filter_map(readable).collect())
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/job/rows.rs b/crates/adapters/sqlite/src/repositories/job/rows.rs
new file mode 100644
index 0000000..2b97bfb
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/job/rows.rs
@@ -0,0 +1,41 @@
+use domain::job::{Job, JobData, JobId, JobKind, JobStatus, JobSubject};
+
+#[derive(sqlx::FromRow)]
+pub struct JobRow {
+    pub id: String,
+    pub kind: String,
+    pub subject: String,
+    pub status: String,
+    pub attempts: i64,
+    pub last_error: Option<String>,
+    pub enqueued_at: String,
+    pub updated_at: String,
+}
+
+pub fn readable(row: &JobRow) -> Option<Job> {
+    let job = row_to_job(row);
+
+    if job.is_none() {
+        tracing::warn!(
+            job_id = %row.id,
+            kind = %row.kind,
+            status = %row.status,
+            "skipped a stored job this build cannot read"
+        );
+    }
+
+    job
+}
+
+fn row_to_job(row: &JobRow) -> Option<Job> {
+    Some(Job::from_persistence(JobData {
+        id: JobId::from_uuid(row.id.parse().ok()?),
+        kind: JobKind::from_name(&row.kind)?,
+        subject: JobSubject::from_key(&row.subject)?,
+        status: JobStatus::from_name(&row.status)?,
+        attempts: u32::try_from(row.attempts).ok()?,
+        last_error: row.last_error.clone(),
+        enqueued_at: row.enqueued_at.parse().ok()?,
+        updated_at: row.updated_at.parse().ok()?,
+    }))
+}
diff --git a/crates/adapters/sqlite/src/repositories/job/weather.rs b/crates/adapters/sqlite/src/repositories/job/weather.rs
new file mode 100644
index 0000000..9e867cb
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/job/weather.rs
@@ -0,0 +1,58 @@
+use sqlx::SqlitePool;
+
+use domain::entry::MoodEntryId;
+use domain::errors::DomainError;
+use domain::location::Coordinates;
+use domain::ports::UnwatchedPlace;
+
+use super::super::shared::db_err;
+
+pub struct SqliteWeatherBacklogRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteWeatherBacklogRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[derive(sqlx::FromRow)]
+struct UnwatchedPlaceRow {
+    entry_id: String,
+    latitude: f64,
+    longitude: f64,
+    logged_at: String,
+}
+
+#[async_trait::async_trait]
+impl domain::ports::WeatherBacklogQueryPort for SqliteWeatherBacklogRepository {
+    async fn find_places_without_weather(
+        &self,
+        most: usize,
+    ) -> Result<Vec<UnwatchedPlace>, DomainError> {
+        let rows: Vec<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
+             ORDER BY e.logged_at DESC
+             LIMIT ?",
+        )
+        .bind(i64::try_from(most).unwrap_or(i64::MAX))
+        .fetch_all(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(rows.iter().filter_map(readable).collect())
+    }
+}
+
+fn readable(row: &UnwatchedPlaceRow) -> Option<UnwatchedPlace> {
+    Some(UnwatchedPlace {
+        entry_id: MoodEntryId::from_uuid(row.entry_id.parse().ok()?),
+        coordinates: Coordinates::from_persistence(row.latitude, row.longitude),
+        logged_at: row.logged_at.parse().ok()?,
+    })
+}
diff --git a/crates/adapters/sqlite/src/repositories/mod.rs b/crates/adapters/sqlite/src/repositories/mod.rs
index cefa8ee..9aea842 100644
--- a/crates/adapters/sqlite/src/repositories/mod.rs
+++ b/crates/adapters/sqlite/src/repositories/mod.rs
@@ -1,21 +1,43 @@
 pub mod shared;
 
 mod activity;
+mod api_token;
 mod cascade;
+mod cycle;
+mod daily_metric;
+mod dimension;
 mod entry;
+mod job;
+mod provider_connection;
 mod push_subscription;
 mod refresh_session;
+mod rejection;
 mod reminder;
 mod user;
 
 pub use activity::{SqliteActivityCommandRepository, SqliteActivityQueryRepository};
+pub use api_token::{SqliteApiTokenCommandRepository, SqliteApiTokenQueryRepository};
 pub use cascade::SqliteCascadeDeleteRepository;
+pub use cycle::{SqliteCycleStartRepository, SqliteUserPreferencesRepository};
+pub use daily_metric::{SqliteDailyMetricCommandRepository, SqliteDailyMetricQueryRepository};
+pub use dimension::{
+    SqliteContentDimensionRepository, SqliteLocationDimensionRepository,
+    SqliteRelationDimensionRepository, SqliteSongDimensionRepository,
+    SqliteWeatherDimensionRepository,
+};
 pub use entry::{SqliteEntryCommandRepository, SqliteEntryQueryRepository};
+pub use job::{
+    SqliteJobQueueRepository, SqliteRecordingBackfillRepository, SqliteWeatherBacklogRepository,
+};
+pub use provider_connection::{
+    SqliteProviderConnectionCommandRepository, SqliteProviderConnectionQueryRepository,
+};
 pub use push_subscription::{
     SqlitePushSubscriptionCommandRepository, SqlitePushSubscriptionQueryRepository,
 };
 pub use refresh_session::{
     SqliteRefreshSessionCommandRepository, SqliteRefreshSessionQueryRepository,
 };
+pub use rejection::SqliteRejectionRepository;
 pub use reminder::{SqliteReminderCommandRepository, SqliteReminderQueryRepository};
 pub use user::{SqliteUserCommandRepository, SqliteUserQueryRepository};
diff --git a/crates/adapters/sqlite/src/repositories/provider_connection/command.rs b/crates/adapters/sqlite/src/repositories/provider_connection/command.rs
new file mode 100644
index 0000000..770202f
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/provider_connection/command.rs
@@ -0,0 +1,51 @@
+use sqlx::SqlitePool;
+
+use domain::errors::DomainError;
+use domain::provider::{ProviderConnection, ProviderName};
+use domain::user::UserId;
+
+use super::super::shared::db_err;
+
+pub struct SqliteProviderConnectionCommandRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteProviderConnectionCommandRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::ProviderConnectionCommandPort for SqliteProviderConnectionCommandRepository {
+    async fn save(&self, connection: &ProviderConnection) -> Result<(), DomainError> {
+        sqlx::query(
+            "INSERT INTO provider_connections (id, user_id, provider, credential, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?)
+             ON CONFLICT(user_id, provider) DO UPDATE SET
+                credential = excluded.credential, updated_at = excluded.updated_at",
+        )
+        .bind(connection.id().value().to_string())
+        .bind(connection.user_id().value().to_string())
+        .bind(connection.provider().value())
+        .bind(connection.credential().value())
+        .bind(connection.created_at().to_rfc3339())
+        .bind(connection.updated_at().to_rfc3339())
+        .execute(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(())
+    }
+
+    async fn delete(&self, user_id: &UserId, provider: &ProviderName) -> Result<(), DomainError> {
+        sqlx::query("DELETE FROM provider_connections WHERE user_id = ? AND provider = ?")
+            .bind(user_id.value().to_string())
+            .bind(provider.value())
+            .execute(&self.pool)
+            .await
+            .map_err(db_err)?;
+
+        Ok(())
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/provider_connection/mod.rs b/crates/adapters/sqlite/src/repositories/provider_connection/mod.rs
new file mode 100644
index 0000000..0f6b152
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/provider_connection/mod.rs
@@ -0,0 +1,6 @@
+mod command;
+mod query;
+mod rows;
+
+pub use command::SqliteProviderConnectionCommandRepository;
+pub use query::SqliteProviderConnectionQueryRepository;
diff --git a/crates/adapters/sqlite/src/repositories/provider_connection/query.rs b/crates/adapters/sqlite/src/repositories/provider_connection/query.rs
new file mode 100644
index 0000000..ada40aa
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/provider_connection/query.rs
@@ -0,0 +1,50 @@
+use sqlx::SqlitePool;
+
+use domain::errors::DomainError;
+use domain::provider::{ProviderConnection, ProviderName};
+use domain::user::UserId;
+
+use super::super::shared::db_err;
+use super::rows::{ProviderConnectionRow, row_to_connection};
+
+pub struct SqliteProviderConnectionQueryRepository {
+    pool: SqlitePool,
+}
+
+impl SqliteProviderConnectionQueryRepository {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::ProviderConnectionQueryPort for SqliteProviderConnectionQueryRepository {
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<ProviderConnection>, DomainError> {
+        let rows = sqlx::query_as::<_, ProviderConnectionRow>(
+            "SELECT * FROM provider_connections WHERE user_id = ? ORDER BY provider",
+        )
+        .bind(user_id.value().to_string())
+        .fetch_all(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        rows.into_iter().map(row_to_connection).collect()
+    }
+
+    async fn find_by_user_and_provider(
+        &self,
+        user_id: &UserId,
+        provider: &ProviderName,
+    ) -> Result<Option<ProviderConnection>, DomainError> {
+        let row = sqlx::query_as::<_, ProviderConnectionRow>(
+            "SELECT * FROM provider_connections WHERE user_id = ? AND provider = ?",
+        )
+        .bind(user_id.value().to_string())
+        .bind(provider.value())
+        .fetch_optional(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        row.map(row_to_connection).transpose()
+    }
+}
diff --git a/crates/adapters/sqlite/src/repositories/provider_connection/rows.rs b/crates/adapters/sqlite/src/repositories/provider_connection/rows.rs
new file mode 100644
index 0000000..257e8a6
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/provider_connection/rows.rs
@@ -0,0 +1,31 @@
+use domain::errors::DomainError;
+use domain::provider::{
+    EncryptedCredential, ProviderConnection, ProviderConnectionData, ProviderConnectionId,
+    ProviderName,
+};
+use domain::user::UserId;
+
+#[derive(sqlx::FromRow)]
+pub struct ProviderConnectionRow {
+    pub id: String,
+    pub user_id: String,
+    pub provider: String,
+    pub credential: Vec<u8>,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+pub fn row_to_connection(row: ProviderConnectionRow) -> Result<ProviderConnection, DomainError> {
+    let malformed = || DomainError::InvalidInput("stored provider connection is malformed".into());
+
+    Ok(ProviderConnection::from_persistence(
+        ProviderConnectionData {
+            id: ProviderConnectionId::from_uuid(row.id.parse().map_err(|_| malformed())?),
+            user_id: UserId::from_uuid(row.user_id.parse().map_err(|_| malformed())?),
+            provider: ProviderName::from_persistence(row.provider),
+            credential: EncryptedCredential::from_persistence(row.credential),
+            created_at: row.created_at.parse().map_err(|_| malformed())?,
+            updated_at: row.updated_at.parse().map_err(|_| malformed())?,
+        },
+    ))
+}
diff --git a/crates/adapters/sqlite/src/repositories/rejection/mod.rs b/crates/adapters/sqlite/src/repositories/rejection/mod.rs
new file mode 100644
index 0000000..7475816
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/rejection/mod.rs
@@ -0,0 +1,4 @@
+mod repository;
+mod rows;
+
+pub use repository::SqliteRejectionRepository;
diff --git a/crates/adapters/sqlite/src/repositories/rejection/repository.rs b/crates/adapters/sqlite/src/repositories/rejection/repository.rs
new file mode 100644
index 0000000..fa6f38a
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/rejection/repository.rs
@@ -0,0 +1,100 @@
+use sqlx::SqlitePool;
+
+use domain::errors::DomainError;
+use domain::rejection::RejectedMetric;
+use domain::user::UserId;
+
+use super::super::shared::db_err;
+use super::rows::{RejectionRow, readable};
+
+pub struct SqliteRejectionRepository {
+    pool: SqlitePool,
+    kept_per_user: usize,
+}
+
+impl SqliteRejectionRepository {
+    pub fn new(pool: SqlitePool, kept_per_user: usize) -> Self {
+        Self {
+            pool,
+            kept_per_user,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::RejectionCommandPort for SqliteRejectionRepository {
+    async fn record(&self, rejections: &[RejectedMetric]) -> Result<(), DomainError> {
+        let mut tx = self.pool.begin().await.map_err(db_err)?;
+
+        for rejected in rejections {
+            sqlx::query(
+                "INSERT INTO metric_rejections
+                 (id, user_id, origin, provider, date, kind, value, reason, recorded_at)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            )
+            .bind(rejected.id().value().to_string())
+            .bind(rejected.user_id().value().to_string())
+            .bind(rejected.origin().name())
+            .bind(rejected.detail().provider().map(|name| name.value()))
+            .bind(rejected.detail().date().map(|date| date.to_string()))
+            .bind(rejected.detail().kind())
+            .bind(rejected.detail().value())
+            .bind(rejected.reason())
+            .bind(rejected.recorded_at().to_rfc3339())
+            .execute(&mut *tx)
+            .await
+            .map_err(db_err)?;
+        }
+
+        for owner in owners(rejections) {
+            sqlx::query(
+                "DELETE FROM metric_rejections WHERE user_id = ? AND id NOT IN (
+                     SELECT id FROM metric_rejections WHERE user_id = ?
+                     ORDER BY recorded_at DESC, id DESC LIMIT ?
+                 )",
+            )
+            .bind(&owner)
+            .bind(&owner)
+            .bind(self.kept_per_user as i64)
+            .execute(&mut *tx)
+            .await
+            .map_err(db_err)?;
+        }
+
+        tx.commit().await.map_err(db_err)?;
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl domain::ports::RejectionQueryPort for SqliteRejectionRepository {
+    async fn find_recent_by_user(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<RejectedMetric>, DomainError> {
+        let rows: Vec<RejectionRow> = sqlx::query_as(
+            "SELECT id, user_id, origin, provider, date, kind, value, reason, recorded_at
+             FROM metric_rejections WHERE user_id = ?
+             ORDER BY recorded_at DESC, id DESC LIMIT ?",
+        )
+        .bind(user_id.value().to_string())
+        .bind(self.kept_per_user as i64)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(db_err)?;
+
+        Ok(rows.iter().filter_map(readable).collect())
+    }
+}
+
+fn owners(rejections: &[RejectedMetric]) -> Vec<String> {
+    let mut owners: Vec<String> = rejections
+        .iter()
+        .map(|rejected| rejected.user_id().value().to_string())
+        .collect();
+    owners.sort();
+    owners.dedup();
+
+    owners
+}
diff --git a/crates/adapters/sqlite/src/repositories/rejection/rows.rs b/crates/adapters/sqlite/src/repositories/rejection/rows.rs
new file mode 100644
index 0000000..27f2af1
--- /dev/null
+++ b/crates/adapters/sqlite/src/repositories/rejection/rows.rs
@@ -0,0 +1,50 @@
+use domain::entry::Date;
+use domain::provider::ProviderName;
+use domain::rejection::{
+    RejectedMetric, RejectedMetricData, RejectionDetail, RejectionId, RejectionOrigin,
+};
+use domain::user::UserId;
+
+#[derive(sqlx::FromRow)]
+pub struct RejectionRow {
+    pub id: String,
+    pub user_id: String,
+    pub origin: String,
+    pub provider: Option<String>,
+    pub date: Option<String>,
+    pub kind: String,
+    pub value: Option<i64>,
+    pub reason: String,
+    pub recorded_at: String,
+}
+
+pub fn readable(row: &RejectionRow) -> Option<RejectedMetric> {
+    let origin = RejectionOrigin::from_name(&row.origin);
+
+    if origin.is_none() {
+        tracing::warn!(
+            rejection_id = %row.id,
+            origin = %row.origin,
+            "skipped a stored rejection this build cannot read"
+        );
+    }
+
+    let date = match &row.date {
+        None => None,
+        Some(day) => Some(Date::from_persistence(day.parse().ok()?)),
+    };
+
+    Some(RejectedMetric::from_persistence(RejectedMetricData {
+        id: RejectionId::from_uuid(row.id.parse().ok()?),
+        user_id: UserId::from_uuid(row.user_id.parse().ok()?),
+        origin: origin?,
+        detail: RejectionDetail::new(
+            row.provider.clone().map(ProviderName::from_persistence),
+            date,
+            row.kind.clone(),
+            row.value,
+        ),
+        reason: row.reason.clone(),
+        recorded_at: row.recorded_at.parse().ok()?,
+    }))
+}
diff --git a/crates/adapters/sqlite/src/repositories/user/query.rs b/crates/adapters/sqlite/src/repositories/user/query.rs
index ccb1619..d6219aa 100644
--- a/crates/adapters/sqlite/src/repositories/user/query.rs
+++ b/crates/adapters/sqlite/src/repositories/user/query.rs
@@ -24,7 +24,7 @@ impl domain::ports::UserQueryPort for SqliteUserQueryRepository {
             .fetch_optional(&self.pool)
             .await
             .map_err(db_err)?;
-        Ok(row.map(UserRow::into_domain))
+        row.map(UserRow::into_domain).transpose()
     }
 
     async fn find_by_username(&self, username: &Username) -> Result<Option<User>, DomainError> {
@@ -33,7 +33,7 @@ impl domain::ports::UserQueryPort for SqliteUserQueryRepository {
             .fetch_optional(&self.pool)
             .await
             .map_err(db_err)?;
-        Ok(row.map(UserRow::into_domain))
+        row.map(UserRow::into_domain).transpose()
     }
 
     async fn find_by_email(&self, email: &Email) -> Result<Option<User>, DomainError> {
@@ -42,6 +42,6 @@ impl domain::ports::UserQueryPort for SqliteUserQueryRepository {
             .fetch_optional(&self.pool)
             .await
             .map_err(db_err)?;
-        Ok(row.map(UserRow::into_domain))
+        row.map(UserRow::into_domain).transpose()
     }
 }
diff --git a/crates/adapters/sqlite/src/repositories/user/rows.rs b/crates/adapters/sqlite/src/repositories/user/rows.rs
index 85b676d..c06ec2f 100644
--- a/crates/adapters/sqlite/src/repositories/user/rows.rs
+++ b/crates/adapters/sqlite/src/repositories/user/rows.rs
@@ -1,3 +1,4 @@
+use domain::errors::DomainError;
 use domain::user::{
     DisplayName, Email, PasswordHash, Timezone, User, UserData, UserId, UserRole, Username,
 };
@@ -16,22 +17,37 @@ pub struct UserRow {
 }
 
 impl UserRow {
-    pub fn into_domain(self) -> User {
+    pub fn into_domain(self) -> Result<User, DomainError> {
+        let malformed = || DomainError::InvalidInput("stored user row is malformed".into());
+
         let role = match self.role.as_str() {
             "Admin" => UserRole::Admin,
             _ => UserRole::User,
         };
 
-        User::from_persistence(UserData {
-            id: UserId::from_uuid(self.id.parse().unwrap()),
+        Ok(User::from_persistence(UserData {
+            id: UserId::from_uuid(self.id.parse().map_err(|_| malformed())?),
             username: Username::from_persistence(self.username),
             email: Email::from_persistence(self.email),
             password_hash: PasswordHash::new(self.password_hash),
             display_name: self.display_name.map(DisplayName::from_persistence),
-            timezone: self.timezone.map(Timezone::from_persistence),
+            timezone: self.timezone.as_deref().and_then(resolve_timezone),
             role,
-            created_at: self.created_at.parse().unwrap(),
-            updated_at: self.updated_at.parse().unwrap(),
-        })
+            created_at: self.created_at.parse().map_err(|_| malformed())?,
+            updated_at: self.updated_at.parse().map_err(|_| malformed())?,
+        }))
+    }
+}
+
+fn resolve_timezone(stored: &str) -> Option<Timezone> {
+    match Timezone::from_persistence(stored) {
+        Ok(timezone) => Some(timezone),
+        Err(_) => {
+            tracing::warn!(
+                timezone = stored,
+                "stored timezone is not in the IANA database, treating it as unset"
+            );
+            None
+        }
     }
 }
diff --git a/crates/adapters/sqlite/tests/api_token_test.rs b/crates/adapters/sqlite/tests/api_token_test.rs
new file mode 100644
index 0000000..935186a
--- /dev/null
+++ b/crates/adapters/sqlite/tests/api_token_test.rs
@@ -0,0 +1,198 @@
+use sqlx::sqlite::SqlitePoolOptions;
+
+use domain::api_token::{ApiToken, TokenDigest};
+use domain::ports::{ApiTokenCommandPort, ApiTokenQueryPort, CascadeDeletePort, UserCommandPort};
+use domain::provider::ProviderName;
+use domain::testing::test_user;
+use domain::user::{User, UserId};
+
+use sqlite::repositories::{
+    SqliteApiTokenCommandRepository, SqliteApiTokenQueryRepository, SqliteCascadeDeleteRepository,
+    SqliteUserCommandRepository,
+};
+
+async fn a_pool_with_a_user() -> (sqlx::SqlitePool, User) {
+    let pool = SqlitePoolOptions::new()
+        .max_connections(1)
+        .connect("sqlite::memory:")
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let user = test_user("alice");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&user)
+        .await
+        .unwrap();
+
+    (pool, user)
+}
+
+fn a_token(owner: &UserId, name: &str, digest: &str) -> ApiToken {
+    ApiToken::new(
+        owner.clone(),
+        ProviderName::new(name).unwrap(),
+        TokenDigest::from_persistence(digest.into()),
+    )
+}
+
+#[tokio::test]
+async fn a_token_is_found_by_the_digest_of_its_secret() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let token = a_token(user.id(), "iphone-shortcuts", "abc123");
+
+    SqliteApiTokenCommandRepository::new(pool.clone())
+        .save(&token)
+        .await
+        .unwrap();
+
+    let found = SqliteApiTokenQueryRepository::new(pool.clone())
+        .find_by_digest(&TokenDigest::from_persistence("abc123".into()))
+        .await
+        .unwrap()
+        .expect("the token should be found");
+
+    assert_eq!(found.id(), token.id());
+    assert_eq!(found.name().value(), "iphone-shortcuts");
+    assert!(found.last_used_at().is_none());
+}
+
+#[tokio::test]
+async fn a_digest_nobody_stored_finds_nothing() {
+    let (pool, _) = a_pool_with_a_user().await;
+
+    let found = SqliteApiTokenQueryRepository::new(pool.clone())
+        .find_by_digest(&TokenDigest::from_persistence("nothing".into()))
+        .await
+        .unwrap();
+
+    assert!(found.is_none());
+}
+
+#[tokio::test]
+async fn two_tokens_of_one_account_cannot_share_a_name() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let tokens = SqliteApiTokenCommandRepository::new(pool.clone());
+
+    tokens
+        .save(&a_token(user.id(), "iphone-shortcuts", "first"))
+        .await
+        .unwrap();
+
+    let again = tokens
+        .save(&a_token(user.id(), "iphone-shortcuts", "second"))
+        .await;
+
+    let refusal = again
+        .expect_err("a duplicate name must be refused")
+        .to_string();
+
+    assert!(
+        refusal.contains("already exists"),
+        "the refusal should say what is wrong, got: {refusal}"
+    );
+}
+
+#[tokio::test]
+async fn using_a_token_is_recorded_against_it() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let token = a_token(user.id(), "tasker", "abc123");
+    let tokens = SqliteApiTokenCommandRepository::new(pool.clone());
+    tokens.save(&token).await.unwrap();
+
+    tokens.mark_used(token.id()).await.unwrap();
+
+    let found = SqliteApiTokenQueryRepository::new(pool.clone())
+        .find_by_digest(&TokenDigest::from_persistence("abc123".into()))
+        .await
+        .unwrap()
+        .unwrap();
+
+    assert!(found.last_used_at().is_some());
+}
+
+#[tokio::test]
+async fn revoking_a_token_removes_it_for_good() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let token = a_token(user.id(), "tasker", "abc123");
+    let tokens = SqliteApiTokenCommandRepository::new(pool.clone());
+    tokens.save(&token).await.unwrap();
+
+    tokens.revoke(user.id(), token.id()).await.unwrap();
+
+    let found = SqliteApiTokenQueryRepository::new(pool.clone())
+        .find_by_digest(&TokenDigest::from_persistence("abc123".into()))
+        .await
+        .unwrap();
+
+    assert!(found.is_none());
+}
+
+#[tokio::test]
+async fn a_token_belonging_to_someone_else_cannot_be_revoked() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let token = a_token(user.id(), "tasker", "abc123");
+    let tokens = SqliteApiTokenCommandRepository::new(pool.clone());
+    tokens.save(&token).await.unwrap();
+
+    let attempt = tokens.revoke(&UserId::generate(), token.id()).await;
+
+    assert!(attempt.is_err());
+    assert!(
+        SqliteApiTokenQueryRepository::new(pool.clone())
+            .find_by_digest(&TokenDigest::from_persistence("abc123".into()))
+            .await
+            .unwrap()
+            .is_some()
+    );
+}
+
+#[tokio::test]
+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)
+         VALUES (?, ?, ?, ?, ?, ?, NULL)",
+    )
+    .bind(uuid::Uuid::new_v4().to_string())
+    .bind(user.id().value().to_string())
+    .bind("legacy")
+    .bind("abc123")
+    .bind("readEverything")
+    .bind(chrono::Utc::now().to_rfc3339())
+    .execute(&pool)
+    .await
+    .unwrap();
+
+    let found = SqliteApiTokenQueryRepository::new(pool.clone())
+        .find_by_digest(&TokenDigest::from_persistence("abc123".into()))
+        .await
+        .unwrap();
+
+    assert!(
+        found.is_none(),
+        "an unreadable scope must not grant anything"
+    );
+}
+
+#[tokio::test]
+async fn deleting_an_account_takes_its_tokens_with_it() {
+    let (pool, user) = a_pool_with_a_user().await;
+    SqliteApiTokenCommandRepository::new(pool.clone())
+        .save(&a_token(user.id(), "tasker", "abc123"))
+        .await
+        .unwrap();
+
+    SqliteCascadeDeleteRepository::new(pool.clone())
+        .delete_user_account(user.id())
+        .await
+        .unwrap();
+
+    let remaining: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM api_tokens")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+    assert_eq!(remaining.0, 0);
+}
diff --git a/crates/adapters/sqlite/tests/cascade_test.rs b/crates/adapters/sqlite/tests/cascade_test.rs
new file mode 100644
index 0000000..cb99d9f
--- /dev/null
+++ b/crates/adapters/sqlite/tests/cascade_test.rs
@@ -0,0 +1,285 @@
+use sqlx::SqlitePool;
+
+use domain::dimension::DimensionValue;
+use domain::entry::{Content, Mood, MoodEntry, MoodEntryId};
+use domain::location::Coordinates;
+use domain::ports::{EntryDimensionPort, MoodEntryCommandPort, UserCommandPort};
+use domain::song::Song;
+use domain::testing::test_user;
+use domain::user::{User, UserId};
+
+use sqlite::repositories::{
+    SqliteContentDimensionRepository, SqliteEntryCommandRepository,
+    SqliteLocationDimensionRepository, SqliteSongDimensionRepository, SqliteUserCommandRepository,
+};
+
+const EVERY_TABLE_THAT_HANGS_OFF_AN_ENTRY: [&str; 4] = [
+    "entry_content",
+    "entry_location",
+    "entry_song",
+    "entry_activities",
+];
+
+async fn a_file() -> String {
+    let name = format!("k-mood-cascade-{}.sqlite", uuid::Uuid::new_v4());
+
+    std::env::temp_dir()
+        .join(name)
+        .to_string_lossy()
+        .to_string()
+}
+
+async fn an_entry_with_every_dimension(pool: &SqlitePool) -> (User, MoodEntryId) {
+    let user = test_user("alice");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&user)
+        .await
+        .unwrap();
+
+    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();
+
+    SqliteContentDimensionRepository::new(pool.clone())
+        .save(
+            entry.id(),
+            &[DimensionValue::Content(Content::new("a note").unwrap())],
+        )
+        .await
+        .unwrap();
+    SqliteLocationDimensionRepository::new(pool.clone())
+        .save(
+            entry.id(),
+            &[DimensionValue::Location(
+                Coordinates::new(52.2297, 21.0122).unwrap(),
+            )],
+        )
+        .await
+        .unwrap();
+    SqliteSongDimensionRepository::new(pool.clone())
+        .save(
+            entry.id(),
+            &[DimensionValue::Song(
+                Song::new("Teardrop", "Massive Attack", None, None).unwrap(),
+            )],
+        )
+        .await
+        .unwrap();
+
+    (user, entry.id().clone())
+}
+
+async fn rows_in(pool: &SqlitePool, table: &str) -> i64 {
+    let counted: (i64,) =
+        sqlx::query_as(sqlx::AssertSqlSafe(format!("SELECT COUNT(*) FROM {table}")))
+            .fetch_one(pool)
+            .await
+            .unwrap();
+
+    counted.0
+}
+
+async fn dimension_rows(pool: &SqlitePool) -> i64 {
+    let mut total = 0;
+    for table in EVERY_TABLE_THAT_HANGS_OFF_AN_ENTRY {
+        total += rows_in(pool, table).await;
+    }
+
+    total
+}
+
+#[tokio::test]
+async fn foreign_keys_are_switched_on_for_every_connection_the_pool_hands_out() {
+    let path = a_file().await;
+    let pool = sqlite::create_pool(&format!("sqlite://{path}"))
+        .await
+        .unwrap();
+
+    for _ in 0..5 {
+        let on: (i64,) = sqlx::query_as("PRAGMA foreign_keys")
+            .fetch_one(&pool)
+            .await
+            .unwrap();
+
+        assert_eq!(
+            on.0, 1,
+            "sqlite ignores ON DELETE CASCADE silently when foreign keys are off"
+        );
+    }
+
+    remove(&path);
+}
+
+#[tokio::test]
+async fn deleting_an_entry_really_does_remove_its_dimension_rows() {
+    let path = a_file().await;
+    let pool = sqlite::create_pool(&format!("sqlite://{path}"))
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let (_, entry_id) = an_entry_with_every_dimension(&pool).await;
+    assert!(
+        dimension_rows(&pool).await >= 3,
+        "the dimensions were not stored"
+    );
+
+    SqliteEntryCommandRepository::new(pool.clone())
+        .delete(&entry_id)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        dimension_rows(&pool).await,
+        0,
+        "ON DELETE CASCADE did not fire"
+    );
+
+    remove(&path);
+}
+
+#[tokio::test]
+async fn a_dimension_row_cannot_be_written_for_an_entry_that_does_not_exist() {
+    let path = a_file().await;
+    let pool = sqlite::create_pool(&format!("sqlite://{path}"))
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let refused = SqliteContentDimensionRepository::new(pool.clone())
+        .save(
+            &MoodEntryId::generate(),
+            &[DimensionValue::Content(Content::new("orphan").unwrap())],
+        )
+        .await;
+
+    assert!(
+        refused.is_err(),
+        "a foreign key that is not enforced is not a foreign key"
+    );
+
+    remove(&path);
+}
+
+#[tokio::test]
+async fn deleting_an_account_removes_everything_that_hangs_off_it() {
+    use domain::ports::CascadeDeletePort;
+    use sqlite::repositories::SqliteCascadeDeleteRepository;
+
+    let path = a_file().await;
+    let pool = sqlite::create_pool(&format!("sqlite://{path}"))
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let (user, _) = an_entry_with_every_dimension(&pool).await;
+
+    SqliteCascadeDeleteRepository::new(pool.clone())
+        .delete_user_account(user.id())
+        .await
+        .unwrap();
+
+    assert_eq!(rows_in(&pool, "users").await, 0);
+    assert_eq!(rows_in(&pool, "mood_entries").await, 0);
+    assert_eq!(
+        dimension_rows(&pool).await,
+        0,
+        "the cascade must reach through the entry to its dimensions"
+    );
+
+    remove(&path);
+}
+
+#[tokio::test]
+async fn the_oldest_tables_do_not_cascade_from_users_which_is_why_they_are_deleted_by_hand() {
+    let path = a_file().await;
+    let pool = sqlite::create_pool(&format!("sqlite://{path}"))
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let (user, _) = an_entry_with_every_dimension(&pool).await;
+
+    let refused = sqlx::query("DELETE FROM users WHERE id = ?")
+        .bind(user.id().value().to_string())
+        .execute(&pool)
+        .await;
+
+    assert!(
+        refused.is_err(),
+        "mood_entries references users without ON DELETE CASCADE, so the repository must \
+         delete the older tables itself. If this now succeeds, the schema gained a cascade \
+         and those manual deletes are redundant."
+    );
+
+    remove(&path);
+}
+
+#[tokio::test]
+async fn every_table_added_since_does_cascade_from_users() {
+    let path = a_file().await;
+    let pool = sqlite::create_pool(&format!("sqlite://{path}"))
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let cascading = [
+        "provider_connections",
+        "daily_metrics",
+        "api_tokens",
+        "metric_rejections",
+        "cycle_starts",
+        "user_preferences",
+    ];
+
+    for table in cascading {
+        let sql: (String,) =
+            sqlx::query_as("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?")
+                .bind(table)
+                .fetch_one(&pool)
+                .await
+                .unwrap();
+
+        assert!(
+            sql.0.contains("REFERENCES users(id) ON DELETE CASCADE"),
+            "{table} should be removed by the database when its account goes"
+        );
+    }
+
+    remove(&path);
+}
+
+#[tokio::test]
+async fn an_entry_cannot_belong_to_an_account_that_does_not_exist() {
+    let path = a_file().await;
+    let pool = sqlite::create_pool(&format!("sqlite://{path}"))
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let orphan = MoodEntry::new(
+        UserId::generate(),
+        Mood::Good,
+        chrono::DateTime::parse_from_rfc3339("2026-08-20T12:00:00+02:00").unwrap(),
+    );
+
+    let refused = SqliteEntryCommandRepository::new(pool.clone())
+        .save(&orphan)
+        .await;
+
+    assert!(refused.is_err(), "an entry with no owner should be refused");
+
+    remove(&path);
+}
+
+fn remove(path: &str) {
+    let _ = std::fs::remove_file(path);
+    let _ = std::fs::remove_file(format!("{path}-wal"));
+    let _ = std::fs::remove_file(format!("{path}-shm"));
+}
diff --git a/crates/adapters/sqlite/tests/cycle_test.rs b/crates/adapters/sqlite/tests/cycle_test.rs
new file mode 100644
index 0000000..6bc1e8d
--- /dev/null
+++ b/crates/adapters/sqlite/tests/cycle_test.rs
@@ -0,0 +1,179 @@
+use sqlx::sqlite::SqlitePoolOptions;
+
+use domain::entry::Date;
+use domain::ports::{
+    CascadeDeletePort, CycleStartCommandPort, CycleStartQueryPort, UserCommandPort,
+    UserPreferencesCommandPort, UserPreferencesQueryPort,
+};
+use domain::testing::test_user;
+use domain::user::{User, UserId, UserPreferences};
+
+use sqlite::repositories::{
+    SqliteCascadeDeleteRepository, SqliteCycleStartRepository, SqliteUserCommandRepository,
+    SqliteUserPreferencesRepository,
+};
+
+async fn a_pool_with_a_user() -> (sqlx::SqlitePool, User) {
+    let pool = SqlitePoolOptions::new()
+        .max_connections(1)
+        .connect("sqlite::memory:")
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let user = test_user("alice");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&user)
+        .await
+        .unwrap();
+
+    (pool, user)
+}
+
+fn on(day: &str) -> Date {
+    Date::from_persistence(day.parse().unwrap())
+}
+
+#[tokio::test]
+async fn recording_the_same_start_twice_leaves_one_row() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let starts = SqliteCycleStartRepository::new(pool.clone());
+
+    starts.record(user.id(), &on("2026-01-01")).await.unwrap();
+    starts.record(user.id(), &on("2026-01-01")).await.unwrap();
+
+    let rows: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM cycle_starts")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+    assert_eq!(rows.0, 1);
+    assert_eq!(starts.find_by_user(user.id()).await.unwrap().len(), 1);
+}
+
+#[tokio::test]
+async fn starts_come_back_oldest_first() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let starts = SqliteCycleStartRepository::new(pool.clone());
+
+    for day in ["2026-02-26", "2026-01-01", "2026-01-29"] {
+        starts.record(user.id(), &on(day)).await.unwrap();
+    }
+
+    let found: Vec<String> = starts
+        .find_by_user(user.id())
+        .await
+        .unwrap()
+        .iter()
+        .map(|date| date.to_string())
+        .collect();
+
+    assert_eq!(found, ["2026-01-01", "2026-01-29", "2026-02-26"]);
+}
+
+#[tokio::test]
+async fn forgetting_a_start_removes_only_that_one() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let starts = SqliteCycleStartRepository::new(pool.clone());
+    starts.record(user.id(), &on("2026-01-01")).await.unwrap();
+    starts.record(user.id(), &on("2026-01-29")).await.unwrap();
+
+    starts.forget(user.id(), &on("2026-01-01")).await.unwrap();
+
+    let found: Vec<String> = starts
+        .find_by_user(user.id())
+        .await
+        .unwrap()
+        .iter()
+        .map(|date| date.to_string())
+        .collect();
+
+    assert_eq!(found, ["2026-01-29"]);
+}
+
+#[tokio::test]
+async fn one_accounts_starts_are_not_anothers() {
+    let (pool, mine) = a_pool_with_a_user().await;
+    let starts = SqliteCycleStartRepository::new(pool.clone());
+
+    starts.record(mine.id(), &on("2026-01-01")).await.unwrap();
+
+    assert!(
+        starts
+            .find_by_user(&UserId::generate())
+            .await
+            .unwrap()
+            .is_empty()
+    );
+}
+
+#[tokio::test]
+async fn an_account_with_no_stored_preference_has_none_to_read() {
+    let (pool, user) = a_pool_with_a_user().await;
+
+    let found = SqliteUserPreferencesRepository::new(pool.clone())
+        .find_by_user(user.id())
+        .await
+        .unwrap();
+
+    assert!(
+        found.is_none(),
+        "the default belongs to the domain, not the row"
+    );
+}
+
+#[tokio::test]
+async fn a_preference_survives_being_written_twice() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let preferences = SqliteUserPreferencesRepository::new(pool.clone());
+
+    let mut held = UserPreferences::off_by_default(user.id().clone());
+    held.track_cycle(true);
+    preferences.save(&held).await.unwrap();
+
+    held.track_cycle(false);
+    preferences.save(&held).await.unwrap();
+
+    let found = preferences.find_by_user(user.id()).await.unwrap().unwrap();
+
+    assert!(!found.tracks_cycle());
+
+    let rows: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM user_preferences")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(rows.0, 1);
+}
+
+#[tokio::test]
+async fn deleting_an_account_takes_its_cycle_and_preferences_with_it() {
+    let (pool, user) = a_pool_with_a_user().await;
+    SqliteCycleStartRepository::new(pool.clone())
+        .record(user.id(), &on("2026-01-01"))
+        .await
+        .unwrap();
+
+    let mut held = UserPreferences::off_by_default(user.id().clone());
+    held.track_cycle(true);
+    SqliteUserPreferencesRepository::new(pool.clone())
+        .save(&held)
+        .await
+        .unwrap();
+
+    SqliteCascadeDeleteRepository::new(pool.clone())
+        .delete_user_account(user.id())
+        .await
+        .unwrap();
+
+    let starts: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM cycle_starts")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    let preferences: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM user_preferences")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+    assert_eq!(starts.0, 0);
+    assert_eq!(preferences.0, 0);
+}
diff --git a/crates/adapters/sqlite/tests/daily_metric_test.rs b/crates/adapters/sqlite/tests/daily_metric_test.rs
new file mode 100644
index 0000000..da77b4b
--- /dev/null
+++ b/crates/adapters/sqlite/tests/daily_metric_test.rs
@@ -0,0 +1,445 @@
+use sqlx::sqlite::SqlitePoolOptions;
+
+use domain::entry::{Date, DateSpan};
+use domain::metric::{DailyMetric, Hrv, MetricKind, MetricValue, Source, Steps};
+use domain::ports::{
+    CascadeDeletePort, DailyMetricCommandPort, DailyMetricQueryPort, UserCommandPort,
+};
+use domain::provider::ProviderName;
+use domain::testing::test_user;
+use domain::user::UserId;
+
+use sqlite::repositories::{
+    SqliteCascadeDeleteRepository, SqliteDailyMetricCommandRepository,
+    SqliteDailyMetricQueryRepository, SqliteRejectionRepository, SqliteUserCommandRepository,
+};
+
+const REJECTIONS_KEPT: usize = 200;
+
+fn a_trace(pool: sqlx::SqlitePool) -> std::sync::Arc<dyn domain::ports::RejectionCommandPort> {
+    std::sync::Arc::new(SqliteRejectionRepository::new(pool, REJECTIONS_KEPT))
+}
+
+async fn a_pool_with_a_user() -> (sqlx::SqlitePool, UserId) {
+    let pool = SqlitePoolOptions::new()
+        .max_connections(1)
+        .connect("sqlite::memory:")
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let user = test_user("alice");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&user)
+        .await
+        .unwrap();
+
+    (pool, user.id().clone())
+}
+
+fn on(day: &str) -> Date {
+    Date::from_persistence(day.parse().unwrap())
+}
+
+fn steps(count: u32) -> MetricValue {
+    MetricValue::Steps(Steps::new(count).unwrap())
+}
+
+fn from_provider() -> Source {
+    Source::Provider(ProviderName::new("healthkit").unwrap())
+}
+
+async fn stored_for(pool: &sqlx::SqlitePool, user_id: &UserId, day: &str) -> Vec<DailyMetric> {
+    let span = DateSpan::new(on(day), on(day)).unwrap();
+    SqliteDailyMetricQueryRepository::new(pool.clone(), a_trace(pool.clone()))
+        .find_by_span(user_id, &span)
+        .await
+        .unwrap()
+}
+
+#[tokio::test]
+async fn restating_a_date_replaces_the_row_rather_than_adding_one() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+    let metrics = SqliteDailyMetricCommandRepository::new(pool.clone());
+
+    for count in [8_000, 8_412] {
+        metrics
+            .save(&[DailyMetric::new(
+                user_id.clone(),
+                on("2026-08-20"),
+                steps(count),
+                Source::Manual,
+            )])
+            .await
+            .unwrap();
+    }
+
+    let stored = stored_for(&pool, &user_id, "2026-08-20").await;
+
+    assert_eq!(stored.len(), 1);
+    assert_eq!(stored[0].value(), &steps(8_412));
+}
+
+#[tokio::test]
+async fn an_import_leaves_a_count_the_user_stated_alone() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+    let metrics = SqliteDailyMetricCommandRepository::new(pool.clone());
+
+    metrics
+        .save(&[DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-20"),
+            steps(8_412),
+            Source::Manual,
+        )])
+        .await
+        .unwrap();
+    metrics
+        .save(&[DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-20"),
+            steps(1_000),
+            from_provider(),
+        )])
+        .await
+        .unwrap();
+
+    let stored = stored_for(&pool, &user_id, "2026-08-20").await;
+
+    assert_eq!(stored.len(), 1);
+    assert_eq!(stored[0].value(), &steps(8_412));
+    assert_eq!(stored[0].source(), &Source::Manual);
+}
+
+#[tokio::test]
+async fn a_count_the_user_states_replaces_what_a_provider_reported() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+    let metrics = SqliteDailyMetricCommandRepository::new(pool.clone());
+
+    metrics
+        .save(&[DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-20"),
+            steps(1_000),
+            from_provider(),
+        )])
+        .await
+        .unwrap();
+    metrics
+        .save(&[DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-20"),
+            steps(8_412),
+            Source::Manual,
+        )])
+        .await
+        .unwrap();
+
+    let stored = stored_for(&pool, &user_id, "2026-08-20").await;
+
+    assert_eq!(stored[0].value(), &steps(8_412));
+    assert_eq!(stored[0].source(), &Source::Manual);
+}
+
+#[tokio::test]
+async fn a_provider_is_remembered_as_the_source() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+
+    SqliteDailyMetricCommandRepository::new(pool.clone())
+        .save(&[DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-20"),
+            steps(1_000),
+            from_provider(),
+        )])
+        .await
+        .unwrap();
+
+    let stored = stored_for(&pool, &user_id, "2026-08-20").await;
+
+    assert_eq!(stored[0].source(), &from_provider());
+}
+
+#[tokio::test]
+async fn a_row_of_a_kind_this_build_does_not_know_is_skipped_and_its_neighbours_survive() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+
+    SqliteDailyMetricCommandRepository::new(pool.clone())
+        .save(&[DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-20"),
+            steps(8_412),
+            Source::Manual,
+        )])
+        .await
+        .unwrap();
+
+    sqlx::query("INSERT INTO daily_metrics (user_id, date, kind, value, provider) VALUES (?, ?, ?, ?, NULL)")
+        .bind(user_id.value().to_string())
+        .bind("2026-08-20")
+        .bind("telepathy")
+        .bind(42)
+        .execute(&pool)
+        .await
+        .unwrap();
+
+    let stored = stored_for(&pool, &user_id, "2026-08-20").await;
+
+    assert_eq!(stored.len(), 1);
+    assert_eq!(stored[0].value(), &steps(8_412));
+}
+
+#[tokio::test]
+async fn a_value_outside_its_range_is_skipped_and_its_neighbours_survive() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+
+    SqliteDailyMetricCommandRepository::new(pool.clone())
+        .save(&[DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-19"),
+            steps(8_412),
+            Source::Manual,
+        )])
+        .await
+        .unwrap();
+
+    sqlx::query("INSERT INTO daily_metrics (user_id, date, kind, value, provider) VALUES (?, ?, ?, ?, NULL)")
+        .bind(user_id.value().to_string())
+        .bind("2026-08-20")
+        .bind("steps")
+        .bind(900_000)
+        .execute(&pool)
+        .await
+        .unwrap();
+
+    let span = DateSpan::new(on("2026-08-19"), on("2026-08-20")).unwrap();
+    let stored = SqliteDailyMetricQueryRepository::new(pool.clone(), a_trace(pool.clone()))
+        .find_by_span(&user_id, &span)
+        .await
+        .unwrap();
+
+    assert_eq!(stored.len(), 1);
+    assert_eq!(stored[0].date(), &on("2026-08-19"));
+}
+
+#[tokio::test]
+async fn days_outside_the_span_are_not_returned() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+    let metrics = SqliteDailyMetricCommandRepository::new(pool.clone());
+
+    for day in ["2026-07-31", "2026-08-01", "2026-08-31", "2026-09-01"] {
+        metrics
+            .save(&[DailyMetric::new(
+                user_id.clone(),
+                on(day),
+                steps(8_412),
+                Source::Manual,
+            )])
+            .await
+            .unwrap();
+    }
+
+    let span = DateSpan::new(on("2026-08-01"), on("2026-08-31")).unwrap();
+    let stored = SqliteDailyMetricQueryRepository::new(pool.clone(), a_trace(pool.clone()))
+        .find_by_span(&user_id, &span)
+        .await
+        .unwrap();
+
+    let days: Vec<String> = stored
+        .iter()
+        .map(|metric| metric.date().to_string())
+        .collect();
+
+    assert_eq!(days, ["2026-08-01", "2026-08-31"]);
+}
+
+#[tokio::test]
+async fn clearing_a_users_data_removes_their_days() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+
+    SqliteDailyMetricCommandRepository::new(pool.clone())
+        .save(&[DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-20"),
+            steps(8_412),
+            Source::Manual,
+        )])
+        .await
+        .unwrap();
+
+    SqliteCascadeDeleteRepository::new(pool.clone())
+        .delete_all_user_data(&user_id)
+        .await
+        .unwrap();
+
+    assert!(stored_for(&pool, &user_id, "2026-08-20").await.is_empty());
+}
+
+#[tokio::test]
+async fn deleting_an_account_removes_its_days() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+
+    SqliteDailyMetricCommandRepository::new(pool.clone())
+        .save(&[DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-20"),
+            steps(8_412),
+            Source::Manual,
+        )])
+        .await
+        .unwrap();
+
+    SqliteCascadeDeleteRepository::new(pool.clone())
+        .delete_user_account(&user_id)
+        .await
+        .unwrap();
+
+    let remaining: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM daily_metrics")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+    assert_eq!(remaining.0, 0);
+}
+
+#[tokio::test]
+async fn clearing_a_kind_deletes_only_that_row() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+    let metrics = SqliteDailyMetricCommandRepository::new(pool.clone());
+
+    metrics
+        .save(&[
+            DailyMetric::new(
+                user_id.clone(),
+                on("2026-08-20"),
+                steps(8_412),
+                Source::Manual,
+            ),
+            DailyMetric::new(
+                user_id.clone(),
+                on("2026-08-20"),
+                MetricValue::Hrv(Hrv::new(61).unwrap()),
+                Source::Manual,
+            ),
+            DailyMetric::new(
+                user_id.clone(),
+                on("2026-08-21"),
+                steps(9_000),
+                Source::Manual,
+            ),
+        ])
+        .await
+        .unwrap();
+
+    metrics
+        .delete(&user_id, &on("2026-08-20"), &[MetricKind::Steps])
+        .await
+        .unwrap();
+
+    let remaining = stored_for(&pool, &user_id, "2026-08-20").await;
+
+    assert_eq!(remaining.len(), 1);
+    assert_eq!(remaining[0].kind(), MetricKind::Hrv);
+    assert_eq!(stored_for(&pool, &user_id, "2026-08-21").await.len(), 1);
+}
+
+#[tokio::test]
+async fn clearing_a_kind_that_was_never_stored_is_not_an_error() {
+    let (pool, user_id) = a_pool_with_a_user().await;
+
+    SqliteDailyMetricCommandRepository::new(pool.clone())
+        .delete(&user_id, &on("2026-08-20"), &[MetricKind::Steps])
+        .await
+        .unwrap();
+
+    assert!(stored_for(&pool, &user_id, "2026-08-20").await.is_empty());
+}
+
+#[tokio::test]
+async fn clearing_a_kind_leaves_another_accounts_day_alone() {
+    let (pool, mine) = a_pool_with_a_user().await;
+    let theirs = test_user("bob");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&theirs)
+        .await
+        .unwrap();
+
+    let metrics = SqliteDailyMetricCommandRepository::new(pool.clone());
+    for owner in [&mine, theirs.id()] {
+        metrics
+            .save(&[DailyMetric::new(
+                owner.clone(),
+                on("2026-08-20"),
+                steps(8_412),
+                Source::Manual,
+            )])
+            .await
+            .unwrap();
+    }
+
+    metrics
+        .delete(&mine, &on("2026-08-20"), &[MetricKind::Steps])
+        .await
+        .unwrap();
+
+    assert!(stored_for(&pool, &mine, "2026-08-20").await.is_empty());
+    assert_eq!(
+        stored_for(&pool, theirs.id(), "2026-08-20").await.len(),
+        1,
+        "the other account's day was cleared too"
+    );
+}
+
+#[tokio::test]
+async fn a_stored_row_this_build_cannot_read_lands_in_the_rejection_trace() {
+    use domain::ports::RejectionQueryPort;
+    use domain::rejection::RejectionOrigin;
+
+    let (pool, user_id) = a_pool_with_a_user().await;
+
+    SqliteDailyMetricCommandRepository::new(pool.clone())
+        .save(&[DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-19"),
+            steps(8_412),
+            Source::Manual,
+        )])
+        .await
+        .unwrap();
+
+    for (kind, value) in [("telepathy", 42), ("steps", 900_000)] {
+        sqlx::query(
+            "INSERT INTO daily_metrics (user_id, date, kind, value, provider) VALUES (?, ?, ?, ?, NULL)",
+        )
+        .bind(user_id.value().to_string())
+        .bind("2026-08-20")
+        .bind(kind)
+        .bind(value)
+        .execute(&pool)
+        .await
+        .unwrap();
+    }
+
+    let span = DateSpan::new(on("2026-08-19"), on("2026-08-20")).unwrap();
+    let readable = SqliteDailyMetricQueryRepository::new(pool.clone(), a_trace(pool.clone()))
+        .find_by_span(&user_id, &span)
+        .await
+        .unwrap();
+
+    let trace = SqliteRejectionRepository::new(pool.clone(), REJECTIONS_KEPT)
+        .find_recent_by_user(&user_id)
+        .await
+        .unwrap();
+
+    assert_eq!(readable.len(), 1, "the good row still comes back");
+    assert_eq!(trace.len(), 2, "both unreadable rows are recorded");
+    assert!(
+        trace
+            .iter()
+            .all(|entry| entry.origin() == RejectionOrigin::StoredRow)
+    );
+
+    let mut kinds: Vec<&str> = trace.iter().map(|entry| entry.detail().kind()).collect();
+    kinds.sort_unstable();
+    assert_eq!(kinds, ["steps", "telepathy"]);
+}
diff --git a/crates/adapters/sqlite/tests/job_test.rs b/crates/adapters/sqlite/tests/job_test.rs
new file mode 100644
index 0000000..bbb97fb
--- /dev/null
+++ b/crates/adapters/sqlite/tests/job_test.rs
@@ -0,0 +1,213 @@
+use sqlx::sqlite::SqlitePoolOptions;
+
+use domain::entry::MoodEntryId;
+use domain::job::{JobKind, JobStatus, JobSubject};
+use domain::ports::{JobQueueCommandPort, JobQueueQueryPort};
+
+use sqlite::repositories::SqliteJobQueueRepository;
+
+const KIND: JobKind = JobKind::BackfillRecordingIdentity;
+
+async fn a_queue() -> (sqlx::SqlitePool, SqliteJobQueueRepository) {
+    let pool = SqlitePoolOptions::new()
+        .max_connections(1)
+        .connect("sqlite::memory:")
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    (pool.clone(), SqliteJobQueueRepository::new(pool))
+}
+
+fn about(entry_id: &MoodEntryId) -> JobSubject {
+    JobSubject::Entry(entry_id.clone())
+}
+
+async fn status_of(pool: &sqlx::SqlitePool) -> Vec<(String, i64, Option<String>)> {
+    sqlx::query_as("SELECT status, attempts, last_error FROM jobs ORDER BY enqueued_at")
+        .fetch_all(pool)
+        .await
+        .unwrap()
+}
+
+#[tokio::test]
+async fn the_same_work_cannot_be_queued_twice() {
+    let (pool, queue) = a_queue().await;
+    let subject = about(&MoodEntryId::generate());
+
+    assert!(queue.enqueue(KIND, &subject).await.unwrap());
+    assert!(!queue.enqueue(KIND, &subject).await.unwrap());
+
+    let rows: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM jobs")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(rows.0, 1);
+}
+
+#[tokio::test]
+async fn claiming_marks_a_job_as_running_so_another_worker_leaves_it_alone() {
+    let (pool, queue) = a_queue().await;
+    queue
+        .enqueue(KIND, &about(&MoodEntryId::generate()))
+        .await
+        .unwrap();
+
+    let claimed = queue.claim(KIND, 10).await.unwrap();
+    let claimed_again = queue.claim(KIND, 10).await.unwrap();
+
+    assert_eq!(claimed.len(), 1);
+    assert!(
+        claimed_again.is_empty(),
+        "a running job is not claimed twice"
+    );
+    assert_eq!(status_of(&pool).await[0].0, JobStatus::Running.name());
+}
+
+#[tokio::test]
+async fn claiming_is_bounded_and_takes_the_oldest_first() {
+    let (_, queue) = a_queue().await;
+    for _ in 0..5 {
+        queue
+            .enqueue(KIND, &about(&MoodEntryId::generate()))
+            .await
+            .unwrap();
+    }
+
+    let claimed = queue.claim(KIND, 2).await.unwrap();
+
+    assert_eq!(claimed.len(), 2);
+}
+
+#[tokio::test]
+async fn finishing_a_job_removes_it() {
+    let (pool, queue) = a_queue().await;
+    queue
+        .enqueue(KIND, &about(&MoodEntryId::generate()))
+        .await
+        .unwrap();
+    let claimed = queue.claim(KIND, 1).await.unwrap();
+
+    queue.finish(claimed[0].id()).await.unwrap();
+
+    assert!(status_of(&pool).await.is_empty());
+}
+
+#[tokio::test]
+async fn releasing_a_job_counts_the_attempt_and_keeps_the_reason() {
+    let (pool, queue) = a_queue().await;
+    queue
+        .enqueue(KIND, &about(&MoodEntryId::generate()))
+        .await
+        .unwrap();
+    let claimed = queue.claim(KIND, 1).await.unwrap();
+
+    queue
+        .release(claimed[0].id(), "musicbrainz timed out")
+        .await
+        .unwrap();
+
+    let stored = status_of(&pool).await;
+    assert_eq!(stored[0].0, JobStatus::Pending.name());
+    assert_eq!(stored[0].1, 1);
+    assert_eq!(stored[0].2.as_deref(), Some("musicbrainz timed out"));
+    assert_eq!(
+        queue.claim(KIND, 1).await.unwrap().len(),
+        1,
+        "and it is claimable again"
+    );
+}
+
+#[tokio::test]
+async fn an_exhausted_job_is_never_claimed_but_can_still_be_seen() {
+    let (_, queue) = a_queue().await;
+    queue
+        .enqueue(KIND, &about(&MoodEntryId::generate()))
+        .await
+        .unwrap();
+    let claimed = queue.claim(KIND, 1).await.unwrap();
+
+    queue.exhaust(claimed[0].id(), "gave up").await.unwrap();
+
+    assert!(queue.claim(KIND, 10).await.unwrap().is_empty());
+    let visible = queue.find_exhausted(10).await.unwrap();
+    assert_eq!(visible.len(), 1);
+    assert_eq!(visible[0].last_error(), Some("gave up"));
+}
+
+#[tokio::test]
+async fn a_job_left_running_by_a_dead_worker_becomes_claimable_again() {
+    let (_, queue) = a_queue().await;
+    queue
+        .enqueue(KIND, &about(&MoodEntryId::generate()))
+        .await
+        .unwrap();
+    queue.claim(KIND, 1).await.unwrap();
+
+    let reclaimed = queue.reclaim_stalled(0).await.unwrap();
+
+    assert_eq!(reclaimed, 1);
+    assert_eq!(queue.claim(KIND, 1).await.unwrap().len(), 1);
+}
+
+#[tokio::test]
+async fn a_job_still_being_worked_on_is_not_reclaimed() {
+    let (_, queue) = a_queue().await;
+    queue
+        .enqueue(KIND, &about(&MoodEntryId::generate()))
+        .await
+        .unwrap();
+    queue.claim(KIND, 1).await.unwrap();
+
+    let reclaimed = queue.reclaim_stalled(300).await.unwrap();
+
+    assert_eq!(reclaimed, 0, "five minutes have not passed");
+}
+
+#[tokio::test]
+async fn a_row_of_a_kind_this_build_does_not_know_is_never_claimed() {
+    let (pool, queue) = a_queue().await;
+
+    sqlx::query(
+        "INSERT INTO jobs (id, kind, subject, status, attempts, last_error, enqueued_at, updated_at)
+         VALUES (?, 'summonRain', ?, 'pending', 0, NULL, ?, ?)",
+    )
+    .bind(uuid::Uuid::new_v4().to_string())
+    .bind(uuid::Uuid::new_v4().to_string())
+    .bind(chrono::Utc::now().to_rfc3339())
+    .bind(chrono::Utc::now().to_rfc3339())
+    .execute(&pool)
+    .await
+    .unwrap();
+
+    assert!(queue.claim(KIND, 10).await.unwrap().is_empty());
+}
+
+#[tokio::test]
+async fn a_job_this_build_cannot_read_is_given_up_on_rather_than_claimed_forever() {
+    let (pool, queue) = a_queue().await;
+
+    sqlx::query(
+        "INSERT INTO jobs (id, kind, subject, status, attempts, last_error, enqueued_at, updated_at)
+         VALUES (?, 'backfillRecordingIdentity', ?, 'pending', 0, NULL, 'the day before yesterday', ?)",
+    )
+    .bind(uuid::Uuid::new_v4().to_string())
+    .bind(uuid::Uuid::new_v4().to_string())
+    .bind(chrono::Utc::now().to_rfc3339())
+    .execute(&pool)
+    .await
+    .unwrap();
+
+    assert!(queue.claim(KIND, 10).await.unwrap().is_empty());
+
+    let stored = status_of(&pool).await;
+    assert_eq!(
+        stored[0].0,
+        JobStatus::Exhausted.name(),
+        "an unreadable job must stop churning through claim and reclaim"
+    );
+    assert!(stored[0].2.is_some(), "and must say why it was given up on");
+
+    assert_eq!(queue.reclaim_stalled(0).await.unwrap(), 0);
+    assert!(queue.claim(KIND, 10).await.unwrap().is_empty());
+}
diff --git a/crates/adapters/sqlite/tests/migration_check.rs b/crates/adapters/sqlite/tests/migration_check.rs
new file mode 100644
index 0000000..099c04f
--- /dev/null
+++ b/crates/adapters/sqlite/tests/migration_check.rs
@@ -0,0 +1,142 @@
+use sqlx::sqlite::SqlitePoolOptions;
+
+async fn fresh_pool() -> sqlx::SqlitePool {
+    SqlitePoolOptions::new()
+        .max_connections(1)
+        .connect("sqlite::memory:")
+        .await
+        .unwrap()
+}
+
+async fn column_names(pool: &sqlx::SqlitePool, table: &str) -> Vec<String> {
+    let rows: Vec<(String,)> = sqlx::query_as("SELECT name FROM pragma_table_info(?) ORDER BY cid")
+        .bind(table)
+        .fetch_all(pool)
+        .await
+        .unwrap();
+    rows.into_iter().map(|row| row.0).collect()
+}
+
+async fn applied_count(pool: &sqlx::SqlitePool) -> i64 {
+    let row: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM schema_migrations")
+        .fetch_one(pool)
+        .await
+        .unwrap();
+    row.0
+}
+
+#[tokio::test]
+async fn every_migration_applies_exactly_once_however_often_the_server_restarts() {
+    let pool = fresh_pool().await;
+
+    sqlite::run_migrations(&pool).await.unwrap();
+    let after_first_boot = applied_count(&pool).await;
+
+    sqlite::run_migrations(&pool).await.unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+    let after_further_boots = applied_count(&pool).await;
+
+    assert!(after_first_boot > 0, "no migrations were applied at all");
+    assert_eq!(after_first_boot, after_further_boots);
+}
+
+#[tokio::test]
+async fn mood_entries_no_longer_carries_content() {
+    let pool = fresh_pool().await;
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    assert_eq!(
+        column_names(&pool, "mood_entries").await,
+        [
+            "id",
+            "user_id",
+            "mood",
+            "logged_at",
+            "created_at",
+            "updated_at"
+        ]
+    );
+    assert_eq!(
+        column_names(&pool, "entry_content").await,
+        ["entry_id", "content"]
+    );
+}
+
+fn a_shared_file() -> String {
+    let name = format!("k-mood-migrating-{}.sqlite", uuid::Uuid::new_v4());
+
+    std::env::temp_dir()
+        .join(name)
+        .to_string_lossy()
+        .to_string()
+}
+
+fn forget(path: &str) {
+    let _ = std::fs::remove_file(path);
+    let _ = std::fs::remove_file(format!("{path}-wal"));
+    let _ = std::fs::remove_file(format!("{path}-shm"));
+}
+
+#[tokio::test]
+async fn two_processes_starting_together_both_migrate_successfully() {
+    let path = a_shared_file();
+    let url = format!("sqlite://{path}");
+
+    let server = sqlite::create_pool(&url).await.unwrap();
+    let worker = sqlite::create_pool(&url).await.unwrap();
+
+    let (migrating_server, migrating_worker) = tokio::join!(
+        tokio::spawn({
+            let pool = server.clone();
+            async move { sqlite::run_migrations(&pool).await }
+        }),
+        tokio::spawn({
+            let pool = worker.clone();
+            async move { sqlite::run_migrations(&pool).await }
+        }),
+    );
+
+    let by_the_server = migrating_server.unwrap();
+    let by_the_worker = migrating_worker.unwrap();
+
+    assert!(
+        by_the_server.is_ok(),
+        "the server could not start alongside the worker: {by_the_server:?}"
+    );
+    assert!(
+        by_the_worker.is_ok(),
+        "the worker could not start alongside the server: {by_the_worker:?}"
+    );
+
+    let applied = applied_count(&server).await;
+    let names: Vec<(String,)> = sqlx::query_as("SELECT name FROM schema_migrations")
+        .fetch_all(&server)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        applied as usize,
+        names.len(),
+        "no migration is recorded twice"
+    );
+    assert!(applied > 0);
+
+    forget(&path);
+}
+
+#[tokio::test]
+async fn a_process_joining_a_migrated_database_applies_nothing() {
+    let path = a_shared_file();
+    let url = format!("sqlite://{path}");
+
+    let first = sqlite::create_pool(&url).await.unwrap();
+    sqlite::run_migrations(&first).await.unwrap();
+    let already_applied = applied_count(&first).await;
+
+    let second = sqlite::create_pool(&url).await.unwrap();
+    sqlite::run_migrations(&second).await.unwrap();
+
+    assert_eq!(applied_count(&second).await, already_applied);
+
+    forget(&path);
+}
diff --git a/crates/adapters/sqlite/tests/rejection_test.rs b/crates/adapters/sqlite/tests/rejection_test.rs
new file mode 100644
index 0000000..2c42e8b
--- /dev/null
+++ b/crates/adapters/sqlite/tests/rejection_test.rs
@@ -0,0 +1,217 @@
+use sqlx::sqlite::SqlitePoolOptions;
+
+use domain::entry::Date;
+use domain::ports::{CascadeDeletePort, RejectionCommandPort, RejectionQueryPort, UserCommandPort};
+use domain::provider::ProviderName;
+use domain::rejection::{RejectedMetric, RejectionDetail, RejectionOrigin};
+use domain::testing::test_user;
+use domain::user::{User, UserId};
+
+use sqlite::repositories::{
+    SqliteCascadeDeleteRepository, SqliteRejectionRepository, SqliteUserCommandRepository,
+};
+
+const KEPT: usize = 5;
+
+async fn a_pool_with_a_user() -> (sqlx::SqlitePool, User) {
+    let pool = SqlitePoolOptions::new()
+        .max_connections(1)
+        .connect("sqlite::memory:")
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let user = test_user("alice");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&user)
+        .await
+        .unwrap();
+
+    (pool, user)
+}
+
+fn rejected(owner: &UserId, kind: &str, reason: &str) -> RejectedMetric {
+    RejectedMetric::new(
+        owner.clone(),
+        RejectionOrigin::Import,
+        RejectionDetail::new(
+            Some(ProviderName::new("healthkit").unwrap()),
+            Some(Date::from_persistence("2026-08-20".parse().unwrap())),
+            kind,
+            Some(9_999),
+        ),
+        reason,
+    )
+}
+
+#[tokio::test]
+async fn a_recorded_rejection_comes_back_with_everything_needed_to_diagnose_it() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let trace = SqliteRejectionRepository::new(pool.clone(), KEPT);
+
+    trace
+        .record(&[rejected(
+            user.id(),
+            "hrv",
+            "heart rate variability must be between 1 and 300",
+        )])
+        .await
+        .unwrap();
+
+    let found = trace.find_recent_by_user(user.id()).await.unwrap();
+
+    assert_eq!(found.len(), 1);
+    assert_eq!(found[0].origin(), RejectionOrigin::Import);
+    assert_eq!(found[0].detail().kind(), "hrv");
+    assert_eq!(found[0].detail().value(), Some(9_999));
+    assert_eq!(found[0].detail().date().unwrap().to_string(), "2026-08-20");
+    assert_eq!(found[0].detail().provider().unwrap().value(), "healthkit");
+    assert!(found[0].reason().contains("between 1 and 300"));
+}
+
+#[tokio::test]
+async fn only_the_most_recent_rejections_are_kept() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let trace = SqliteRejectionRepository::new(pool.clone(), KEPT);
+
+    for number in 0..12 {
+        trace
+            .record(&[rejected(user.id(), "hrv", &format!("failure {number}"))])
+            .await
+            .unwrap();
+    }
+
+    let found = trace.find_recent_by_user(user.id()).await.unwrap();
+
+    assert_eq!(found.len(), KEPT);
+
+    let total: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM metric_rejections")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(total.0, KEPT as i64, "older rows should have been pruned");
+}
+
+#[tokio::test]
+async fn one_accounts_rejections_are_never_shown_to_another() {
+    let (pool, mine) = a_pool_with_a_user().await;
+    let theirs = test_user("bob");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&theirs)
+        .await
+        .unwrap();
+
+    let trace = SqliteRejectionRepository::new(pool.clone(), KEPT);
+    trace
+        .record(&[rejected(mine.id(), "hrv", "mine")])
+        .await
+        .unwrap();
+    trace
+        .record(&[rejected(theirs.id(), "steps", "theirs")])
+        .await
+        .unwrap();
+
+    let found = trace.find_recent_by_user(mine.id()).await.unwrap();
+
+    assert_eq!(found.len(), 1);
+    assert_eq!(found[0].reason(), "mine");
+}
+
+#[tokio::test]
+async fn pruning_one_account_leaves_anothers_alone() {
+    let (pool, mine) = a_pool_with_a_user().await;
+    let theirs = test_user("bob");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&theirs)
+        .await
+        .unwrap();
+
+    let trace = SqliteRejectionRepository::new(pool.clone(), KEPT);
+    trace
+        .record(&[rejected(theirs.id(), "steps", "theirs")])
+        .await
+        .unwrap();
+
+    for number in 0..12 {
+        trace
+            .record(&[rejected(mine.id(), "hrv", &format!("failure {number}"))])
+            .await
+            .unwrap();
+    }
+
+    assert_eq!(
+        trace.find_recent_by_user(theirs.id()).await.unwrap().len(),
+        1
+    );
+}
+
+#[tokio::test]
+async fn a_rejection_with_no_date_is_still_recorded() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let trace = SqliteRejectionRepository::new(pool.clone(), KEPT);
+
+    trace
+        .record(&[RejectedMetric::new(
+            user.id().clone(),
+            RejectionOrigin::Import,
+            RejectionDetail::new(None, None, "steps", None),
+            "yesterday is not a date",
+        )])
+        .await
+        .unwrap();
+
+    let found = trace.find_recent_by_user(user.id()).await.unwrap();
+
+    assert_eq!(found.len(), 1);
+    assert!(found[0].detail().date().is_none());
+    assert!(found[0].detail().provider().is_none());
+    assert!(found[0].detail().value().is_none());
+}
+
+#[tokio::test]
+async fn a_row_with_an_origin_this_build_does_not_know_is_skipped() {
+    let (pool, user) = a_pool_with_a_user().await;
+    let trace = SqliteRejectionRepository::new(pool.clone(), KEPT);
+    trace
+        .record(&[rejected(user.id(), "hrv", "readable")])
+        .await
+        .unwrap();
+
+    sqlx::query(
+        "INSERT INTO metric_rejections
+         (id, user_id, origin, provider, date, kind, value, reason, recorded_at)
+         VALUES (?, ?, 'telepathy', NULL, NULL, 'steps', NULL, 'from the future', ?)",
+    )
+    .bind(uuid::Uuid::new_v4().to_string())
+    .bind(user.id().value().to_string())
+    .bind(chrono::Utc::now().to_rfc3339())
+    .execute(&pool)
+    .await
+    .unwrap();
+
+    let found = trace.find_recent_by_user(user.id()).await.unwrap();
+
+    assert_eq!(found.len(), 1);
+    assert_eq!(found[0].reason(), "readable");
+}
+
+#[tokio::test]
+async fn deleting_an_account_takes_its_rejections_with_it() {
+    let (pool, user) = a_pool_with_a_user().await;
+    SqliteRejectionRepository::new(pool.clone(), KEPT)
+        .record(&[rejected(user.id(), "hrv", "whatever")])
+        .await
+        .unwrap();
+
+    SqliteCascadeDeleteRepository::new(pool.clone())
+        .delete_user_account(user.id())
+        .await
+        .unwrap();
+
+    let remaining: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM metric_rejections")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+    assert_eq!(remaining.0, 0);
+}
diff --git a/crates/adapters/sqlite/tests/two_writers_test.rs b/crates/adapters/sqlite/tests/two_writers_test.rs
new file mode 100644
index 0000000..0fe5890
--- /dev/null
+++ b/crates/adapters/sqlite/tests/two_writers_test.rs
@@ -0,0 +1,118 @@
+use domain::entry::MoodEntryId;
+use domain::job::{JobKind, JobSubject};
+use domain::ports::JobQueueCommandPort;
+
+use sqlite::repositories::SqliteJobQueueRepository;
+
+const KIND: JobKind = JobKind::BackfillRecordingIdentity;
+
+fn a_file() -> String {
+    let name = format!("k-mood-two-writers-{}.sqlite", uuid::Uuid::new_v4());
+
+    std::env::temp_dir()
+        .join(name)
+        .to_string_lossy()
+        .to_string()
+}
+
+#[tokio::test]
+async fn two_processes_writing_one_file_both_succeed() {
+    let path = a_file();
+    let url = format!("sqlite://{path}");
+
+    let server = sqlite::create_pool(&url).await.unwrap();
+    sqlite::run_migrations(&server).await.unwrap();
+
+    let worker = sqlite::create_pool(&url).await.unwrap();
+
+    let enqueuing = tokio::spawn({
+        let queue = SqliteJobQueueRepository::new(server.clone());
+        async move {
+            for _ in 0..80 {
+                queue
+                    .enqueue(KIND, &JobSubject::Entry(MoodEntryId::generate()))
+                    .await
+                    .expect("the server's write should not be refused");
+            }
+        }
+    });
+
+    let working = tokio::spawn({
+        let queue = SqliteJobQueueRepository::new(worker.clone());
+        async move {
+            let mut claimed = 0;
+            for _ in 0..80 {
+                let batch = queue
+                    .claim(KIND, 5)
+                    .await
+                    .expect("the worker's write should not be refused");
+
+                for job in &batch {
+                    queue
+                        .finish(job.id())
+                        .await
+                        .expect("finishing should not be refused");
+                }
+
+                claimed += batch.len();
+            }
+
+            claimed
+        }
+    });
+
+    enqueuing.await.unwrap();
+    let claimed = working.await.unwrap();
+
+    assert!(claimed > 0, "the worker never saw any of the server's work");
+
+    let _ = std::fs::remove_file(&path);
+    let _ = std::fs::remove_file(format!("{path}-wal"));
+    let _ = std::fs::remove_file(format!("{path}-shm"));
+}
+
+#[tokio::test]
+async fn a_writer_waits_for_a_held_lock_rather_than_being_refused() {
+    let path = a_file();
+    let url = format!("sqlite://{path}");
+
+    let holder = sqlite::create_pool(&url).await.unwrap();
+    sqlite::run_migrations(&holder).await.unwrap();
+    let other = sqlite::create_pool(&url).await.unwrap();
+
+    let mut held = holder.begin().await.unwrap();
+    sqlx::query(
+        "INSERT INTO jobs (id, kind, subject, status, attempts, last_error, enqueued_at, updated_at)
+         VALUES (?, 'backfillRecordingIdentity', ?, 'pending', 0, NULL, ?, ?)",
+    )
+    .bind(uuid::Uuid::new_v4().to_string())
+    .bind(uuid::Uuid::new_v4().to_string())
+    .bind(chrono::Utc::now().to_rfc3339())
+    .bind(chrono::Utc::now().to_rfc3339())
+    .execute(&mut *held)
+    .await
+    .unwrap();
+
+    let waiting = tokio::spawn({
+        let queue = SqliteJobQueueRepository::new(other);
+        async move {
+            queue
+                .enqueue(KIND, &JobSubject::Entry(MoodEntryId::generate()))
+                .await
+        }
+    });
+
+    tokio::time::sleep(std::time::Duration::from_millis(400)).await;
+    held.commit().await.unwrap();
+
+    let written = waiting.await.unwrap();
+
+    assert!(
+        written.is_ok(),
+        "the second writer was refused instead of waiting: {written:?}"
+    );
+
+    let _ = std::fs::remove_file(&path);
+    let _ = std::fs::remove_file(format!("{path}-wal"));
+    let _ = std::fs::remove_file(format!("{path}-shm"));
+}
diff --git a/crates/adapters/sqlite/tests/weather_dimension_test.rs b/crates/adapters/sqlite/tests/weather_dimension_test.rs
new file mode 100644
index 0000000..a008d27
--- /dev/null
+++ b/crates/adapters/sqlite/tests/weather_dimension_test.rs
@@ -0,0 +1,294 @@
+use sqlx::sqlite::SqlitePoolOptions;
+
+use domain::dimension::{DimensionKind, DimensionValue};
+use domain::entry::{Mood, MoodEntry, MoodEntryId};
+use domain::location::Coordinates;
+use domain::ports::{EntryDimensionPort, MoodEntryCommandPort, UserCommandPort};
+use domain::provider::ProviderName;
+use domain::testing::test_user;
+use domain::weather::{Celsius, Condition, Weather};
+
+use sqlite::repositories::{
+    SqliteEntryCommandRepository, SqliteLocationDimensionRepository, SqliteUserCommandRepository,
+    SqliteWeatherDimensionRepository,
+};
+
+async fn an_entry() -> (sqlx::SqlitePool, MoodEntryId) {
+    let pool = SqlitePoolOptions::new()
+        .max_connections(1)
+        .connect("sqlite::memory:")
+        .await
+        .unwrap();
+    sqlite::run_migrations(&pool).await.unwrap();
+
+    let user = test_user("alice");
+    SqliteUserCommandRepository::new(pool.clone())
+        .save(&user)
+        .await
+        .unwrap();
+
+    let entry = MoodEntry::new(
+        user.id().clone(),
+        Mood::Good,
+        chrono::DateTime::parse_from_rfc3339("2026-08-20T14:00:00+02:00").unwrap(),
+    );
+    SqliteEntryCommandRepository::new(pool.clone())
+        .save(&entry)
+        .await
+        .unwrap();
+
+    (pool, entry.id().clone())
+}
+
+fn observed(condition: Condition, degrees: f64) -> DimensionValue {
+    DimensionValue::Weather(Weather::new(
+        condition,
+        Celsius::new(degrees).unwrap(),
+        ProviderName::new("open-meteo").unwrap(),
+    ))
+}
+
+async fn weather_of(pool: &sqlx::SqlitePool, entry_id: &MoodEntryId) -> Option<DimensionValue> {
+    SqliteWeatherDimensionRepository::new(pool.clone())
+        .load(std::slice::from_ref(entry_id))
+        .await
+        .unwrap()
+        .remove(entry_id)
+}
+
+#[tokio::test]
+async fn observed_weather_is_stored_and_read_back_whole() {
+    let (pool, entry_id) = an_entry().await;
+    let weather = SqliteWeatherDimensionRepository::new(pool.clone());
+
+    weather
+        .save(&entry_id, &[observed(Condition::Rain, 11.5)])
+        .await
+        .unwrap();
+
+    let Some(DimensionValue::Weather(stored)) = weather_of(&pool, &entry_id).await else {
+        panic!("the weather was not stored");
+    };
+
+    assert_eq!(stored.condition(), Condition::Rain);
+    assert!((stored.temperature().value() - 11.5).abs() < f64::EPSILON);
+    assert_eq!(stored.observed_by().value(), "open-meteo");
+}
+
+#[tokio::test]
+async fn editing_an_entry_cannot_erase_what_a_provider_observed() {
+    let (pool, entry_id) = an_entry().await;
+    let weather = SqliteWeatherDimensionRepository::new(pool.clone());
+    weather
+        .save(&entry_id, &[observed(Condition::Rain, 11.5)])
+        .await
+        .unwrap();
+
+    let an_edit_that_says_nothing_about_weather = vec![DimensionValue::Location(
+        Coordinates::new(52.2297, 21.0122).unwrap(),
+    )];
+    weather
+        .save(&entry_id, &an_edit_that_says_nothing_about_weather)
+        .await
+        .unwrap();
+
+    assert!(
+        weather_of(&pool, &entry_id).await.is_some(),
+        "weather is observed, not stated: an edit that omits it is not a request to delete it"
+    );
+}
+
+#[tokio::test]
+async fn a_later_observation_replaces_an_earlier_one() {
+    let (pool, entry_id) = an_entry().await;
+    let weather = SqliteWeatherDimensionRepository::new(pool.clone());
+
+    weather
+        .save(&entry_id, &[observed(Condition::Clear, 20.0)])
+        .await
+        .unwrap();
+    weather
+        .save(&entry_id, &[observed(Condition::Snow, -2.0)])
+        .await
+        .unwrap();
+
+    let Some(DimensionValue::Weather(stored)) = weather_of(&pool, &entry_id).await else {
+        panic!("the weather was lost");
+    };
+
+    assert_eq!(stored.condition(), Condition::Snow);
+
+    let rows: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM entry_weather")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(rows.0, 1);
+}
+
+#[tokio::test]
+async fn a_condition_this_build_does_not_know_is_skipped() {
+    let (pool, entry_id) = an_entry().await;
+
+    sqlx::query(
+        "INSERT INTO entry_weather (entry_id, condition, temperature, observed_by)
+         VALUES (?, 'raining frogs', 11.5, 'open-meteo')",
+    )
+    .bind(entry_id.value().to_string())
+    .execute(&pool)
+    .await
+    .unwrap();
+
+    assert!(weather_of(&pool, &entry_id).await.is_none());
+}
+
+#[tokio::test]
+async fn deleting_an_entry_takes_its_weather_with_it() {
+    let (pool, entry_id) = an_entry().await;
+    SqliteWeatherDimensionRepository::new(pool.clone())
+        .save(&entry_id, &[observed(Condition::Rain, 11.5)])
+        .await
+        .unwrap();
+
+    SqliteEntryCommandRepository::new(pool.clone())
+        .delete(&entry_id)
+        .await
+        .unwrap();
+
+    let rows: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM entry_weather")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(rows.0, 0);
+}
+
+#[tokio::test]
+async fn weather_reports_its_own_kind() {
+    assert_eq!(observed(Condition::Fog, 3.0).kind(), DimensionKind::Weather);
+    let _ = SqliteLocationDimensionRepository::new;
+}
+
+#[tokio::test]
+async fn a_place_with_no_weather_is_backlogged_and_then_is_not() {
+    use domain::ports::WeatherBacklogQueryPort;
+    use sqlite::repositories::SqliteWeatherBacklogRepository;
+
+    let (pool, entry_id) = an_entry().await;
+
+    SqliteLocationDimensionRepository::new(pool.clone())
+        .save(
+            &entry_id,
+            &[DimensionValue::Location(
+                Coordinates::new(52.2297, 21.0122).unwrap(),
+            )],
+        )
+        .await
+        .unwrap();
+
+    let backlog = SqliteWeatherBacklogRepository::new(pool.clone());
+
+    let waiting = backlog.find_places_without_weather(50).await.unwrap();
+    assert_eq!(waiting.len(), 1);
+    assert_eq!(waiting[0].entry_id, entry_id);
+    assert!((waiting[0].coordinates.latitude().value() - 52.2297).abs() < 1e-9);
+
+    SqliteWeatherDimensionRepository::new(pool.clone())
+        .save(&entry_id, &[observed(Condition::Rain, 11.5)])
+        .await
+        .unwrap();
+
+    assert!(
+        backlog
+            .find_places_without_weather(50)
+            .await
+            .unwrap()
+            .is_empty(),
+        "an entry that now has weather is no longer waiting for any"
+    );
+}
+
+#[tokio::test]
+async fn only_entries_that_know_where_they_were_are_backlogged() {
+    use domain::ports::WeatherBacklogQueryPort;
+    use sqlite::repositories::SqliteWeatherBacklogRepository;
+
+    let (pool, somewhere_known) = an_entry().await;
+    SqliteLocationDimensionRepository::new(pool.clone())
+        .save(
+            &somewhere_known,
+            &[DimensionValue::Location(
+                Coordinates::new(52.2297, 21.0122).unwrap(),
+            )],
+        )
+        .await
+        .unwrap();
+
+    let owner: (String,) = sqlx::query_as("SELECT id FROM users LIMIT 1")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    let nowhere = MoodEntry::new(
+        domain::user::UserId::from_uuid(owner.0.parse().unwrap()),
+        Mood::Meh,
+        chrono::DateTime::parse_from_rfc3339("2026-08-21T09:00:00+02:00").unwrap(),
+    );
+    SqliteEntryCommandRepository::new(pool.clone())
+        .save(&nowhere)
+        .await
+        .unwrap();
+
+    let waiting = SqliteWeatherBacklogRepository::new(pool)
+        .find_places_without_weather(50)
+        .await
+        .unwrap();
+
+    let ids: Vec<&MoodEntryId> = waiting.iter().map(|place| &place.entry_id).collect();
+
+    assert_eq!(
+        ids,
+        [&somewhere_known],
+        "weather needs somewhere to have happened"
+    );
+}
+
+#[tokio::test]
+async fn the_backlog_is_bounded_by_what_is_asked_for() {
+    use domain::ports::WeatherBacklogQueryPort;
+    use sqlite::repositories::SqliteWeatherBacklogRepository;
+
+    let (pool, first) = an_entry().await;
+    let locations = SqliteLocationDimensionRepository::new(pool.clone());
+    let somewhere = DimensionValue::Location(Coordinates::new(52.2297, 21.0122).unwrap());
+    locations
+        .save(&first, std::slice::from_ref(&somewhere))
+        .await
+        .unwrap();
+
+    let owner: (String,) = sqlx::query_as("SELECT id FROM users LIMIT 1")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+    for hour in 0..5 {
+        let entry = MoodEntry::new(
+            domain::user::UserId::from_uuid(owner.0.parse().unwrap()),
+            Mood::Good,
+            chrono::DateTime::parse_from_rfc3339(&format!("2026-08-2{hour}T09:00:00+02:00"))
+                .unwrap(),
+        );
+        SqliteEntryCommandRepository::new(pool.clone())
+            .save(&entry)
+            .await
+            .unwrap();
+        locations
+            .save(entry.id(), std::slice::from_ref(&somewhere))
+            .await
+            .unwrap();
+    }
+
+    let waiting = SqliteWeatherBacklogRepository::new(pool)
+        .find_places_without_weather(3)
+        .await
+        .unwrap();
+
+    assert_eq!(waiting.len(), 3);
+}
diff --git a/crates/adapters/weather/Cargo.toml b/crates/adapters/weather/Cargo.toml
new file mode 100644
index 0000000..b428286
--- /dev/null
+++ b/crates/adapters/weather/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "weather"
+edition.workspace = true
+version.workspace = true
+
+[dependencies]
+domain.workspace = true
+async-trait.workspace = true
+chrono.workspace = true
+reqwest.workspace = true
+serde.workspace = true
+tracing.workspace = true
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
diff --git a/crates/adapters/weather/src/lib.rs b/crates/adapters/weather/src/lib.rs
new file mode 100644
index 0000000..65a240b
--- /dev/null
+++ b/crates/adapters/weather/src/lib.rs
@@ -0,0 +1,5 @@
+mod open_meteo;
+mod wmo;
+
+pub use open_meteo::OpenMeteoWeatherLookup;
+pub use wmo::condition_for;
diff --git a/crates/adapters/weather/src/open_meteo.rs b/crates/adapters/weather/src/open_meteo.rs
new file mode 100644
index 0000000..196fecb
--- /dev/null
+++ b/crates/adapters/weather/src/open_meteo.rs
@@ -0,0 +1,122 @@
+use chrono::{DateTime, FixedOffset};
+
+use domain::errors::DomainError;
+use domain::location::Coordinates;
+use domain::provider::ProviderName;
+use domain::weather::{Celsius, Weather};
+
+use super::wmo::condition_for;
+
+const ARCHIVE_URL: &str = "https://archive-api.open-meteo.com/v1/archive";
+const FORECAST_URL: &str = "https://api.open-meteo.com/v1/forecast";
+const PROVIDER: &str = "open-meteo";
+const HOURLY_FIELDS: &str = "temperature_2m,weather_code";
+const DAYS_THE_ARCHIVE_LAGS_BEHIND: i64 = 6;
+
+pub struct OpenMeteoWeatherLookup {
+    http: reqwest::Client,
+    provider: ProviderName,
+}
+
+impl OpenMeteoWeatherLookup {
+    pub fn new(http: reqwest::Client) -> Self {
+        Self {
+            http,
+            provider: ProviderName::from_persistence(PROVIDER.into()),
+        }
+    }
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct HourlyResponse {
+    hourly: Option<Hourly>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct Hourly {
+    time: Vec<String>,
+    #[serde(rename = "temperature_2m")]
+    temperature: Vec<Option<f64>>,
+    #[serde(rename = "weather_code")]
+    code: Vec<Option<u8>>,
+}
+
+#[async_trait::async_trait]
+impl domain::ports::WeatherLookupPort for OpenMeteoWeatherLookup {
+    fn provider(&self) -> &ProviderName {
+        &self.provider
+    }
+
+    async fn observed_at(
+        &self,
+        coordinates: &Coordinates,
+        instant: &DateTime<FixedOffset>,
+    ) -> Result<Option<Weather>, DomainError> {
+        let day = instant.date_naive().to_string();
+        let url = url_for(instant);
+
+        let response = self
+            .http
+            .get(url)
+            .query(&[
+                ("latitude", coordinates.latitude().value().to_string()),
+                ("longitude", coordinates.longitude().value().to_string()),
+                ("start_date", day.clone()),
+                ("end_date", day),
+                ("hourly", HOURLY_FIELDS.to_string()),
+                ("timezone", "UTC".to_string()),
+            ])
+            .send()
+            .await
+            .map_err(|error| {
+                DomainError::InvalidInput(format!("weather lookup failed: {error}"))
+            })?;
+
+        if !response.status().is_success() {
+            return Err(DomainError::InvalidInput(format!(
+                "the weather provider answered {}",
+                response.status()
+            )));
+        }
+
+        let hourly: HourlyResponse = response.json().await.map_err(|error| {
+            DomainError::InvalidInput(format!(
+                "the weather provider sent something unreadable: {error}"
+            ))
+        })?;
+
+        Ok(self.nearest_hour(hourly.hourly, instant))
+    }
+}
+
+impl OpenMeteoWeatherLookup {
+    fn nearest_hour(
+        &self,
+        hourly: Option<Hourly>,
+        instant: &DateTime<FixedOffset>,
+    ) -> Option<Weather> {
+        let hourly = hourly?;
+        let wanted = instant.naive_utc().format("%Y-%m-%dT%H:00").to_string();
+
+        let at = hourly.time.iter().position(|hour| hour == &wanted)?;
+
+        let code = (*hourly.code.get(at)?)?;
+        let degrees = (*hourly.temperature.get(at)?)?;
+
+        Some(Weather::new(
+            condition_for(code)?,
+            Celsius::new(degrees).ok()?,
+            self.provider.clone(),
+        ))
+    }
+}
+
+fn url_for(instant: &DateTime<FixedOffset>) -> &'static str {
+    let lag = chrono::Utc::now() - instant.with_timezone(&chrono::Utc);
+
+    if lag.num_days() >= DAYS_THE_ARCHIVE_LAGS_BEHIND {
+        return ARCHIVE_URL;
+    }
+
+    FORECAST_URL
+}
diff --git a/crates/adapters/weather/src/wmo.rs b/crates/adapters/weather/src/wmo.rs
new file mode 100644
index 0000000..2db5e41
--- /dev/null
+++ b/crates/adapters/weather/src/wmo.rs
@@ -0,0 +1,14 @@
+use domain::weather::Condition;
+
+pub fn condition_for(code: u8) -> Option<Condition> {
+    match code {
+        0..=1 => Some(Condition::Clear),
+        2..=3 => Some(Condition::Cloudy),
+        45..=48 => Some(Condition::Fog),
+        51..=57 => Some(Condition::Drizzle),
+        61..=67 | 80..=82 => Some(Condition::Rain),
+        71..=77 | 85..=86 => Some(Condition::Snow),
+        95..=99 => Some(Condition::Thunderstorm),
+        _ => None,
+    }
+}
diff --git a/crates/adapters/weather/tests/wmo_test.rs b/crates/adapters/weather/tests/wmo_test.rs
new file mode 100644
index 0000000..d8d5653
--- /dev/null
+++ b/crates/adapters/weather/tests/wmo_test.rs
@@ -0,0 +1,60 @@
+use domain::weather::Condition;
+
+use weather::condition_for;
+
+#[test]
+fn the_documented_wmo_codes_map_onto_the_domains_vocabulary() {
+    let expected = [
+        (0, Condition::Clear),
+        (1, Condition::Clear),
+        (2, Condition::Cloudy),
+        (3, Condition::Cloudy),
+        (45, Condition::Fog),
+        (48, Condition::Fog),
+        (51, Condition::Drizzle),
+        (55, Condition::Drizzle),
+        (61, Condition::Rain),
+        (65, Condition::Rain),
+        (66, Condition::Rain),
+        (80, Condition::Rain),
+        (82, Condition::Rain),
+        (71, Condition::Snow),
+        (75, Condition::Snow),
+        (77, Condition::Snow),
+        (85, Condition::Snow),
+        (86, Condition::Snow),
+        (95, Condition::Thunderstorm),
+        (99, Condition::Thunderstorm),
+    ];
+
+    for (code, condition) in expected {
+        assert_eq!(
+            condition_for(code),
+            Some(condition),
+            "wmo code {code} should be {condition:?}"
+        );
+    }
+}
+
+#[test]
+fn a_code_the_provider_never_documents_maps_to_nothing() {
+    for code in [4, 20, 44, 50, 60, 70, 90, 100, 255] {
+        assert_eq!(
+            condition_for(code),
+            None,
+            "wmo code {code} is not documented"
+        );
+    }
+}
+
+#[test]
+fn every_condition_in_the_vocabulary_is_reachable_from_some_code() {
+    let reached: Vec<Condition> = (0..=99).filter_map(condition_for).collect();
+
+    for condition in Condition::ALL {
+        assert!(
+            reached.contains(&condition),
+            "{condition:?} cannot be produced by any wmo code"
+        );
+    }
+}
diff --git a/crates/adapters/web-push/src/lib.rs b/crates/adapters/web-push/src/lib.rs
index bbcfd95..c5fbd96 100644
--- a/crates/adapters/web-push/src/lib.rs
+++ b/crates/adapters/web-push/src/lib.rs
@@ -7,7 +7,7 @@ use web_push::{
 
 use config::PushConfig;
 use domain::errors::DomainError;
-use domain::ports::PushSubscriptionQueryPort;
+use domain::ports::{PushSubscriptionCommandPort, PushSubscriptionQueryPort};
 use domain::push::PushSubscription;
 use domain::user::UserId;
 
@@ -16,12 +16,24 @@ pub struct WebPushSender {
     vapid_private_key: String,
     vapid_subject: String,
     subscription_query: Arc<dyn PushSubscriptionQueryPort>,
+    subscription_command: Arc<dyn PushSubscriptionCommandPort>,
+}
+
+/// What happened to a single subscription during a send.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Delivery {
+    Sent,
+    /// The subscription is permanently unusable and has been dropped.
+    Removed,
+    /// Transient failure; the subscription is kept for the next attempt.
+    Failed,
 }
 
 impl WebPushSender {
     pub fn new(
         config: &PushConfig,
         subscription_query: Arc<dyn PushSubscriptionQueryPort>,
+        subscription_command: Arc<dyn PushSubscriptionCommandPort>,
     ) -> Result<Self, DomainError> {
         let private_key = required_config(&config.vapid_private_key, "vapid_private_key")?;
         let subject = required_config(&config.vapid_subject, "vapid_subject")?;
@@ -35,6 +47,7 @@ impl WebPushSender {
             vapid_private_key: private_key.to_string(),
             vapid_subject: subject.to_string(),
             subscription_query,
+            subscription_command,
         })
     }
 
@@ -64,20 +77,72 @@ impl WebPushSender {
             .map_err(|e| DomainError::InvalidInput(format!("failed to sign push message: {e}")))
     }
 
-    async fn deliver(&self, sub: &PushSubscription, payload: &str) -> Result<(), DomainError> {
-        let subscription_info = SubscriptionInfo::new(sub.endpoint(), sub.p256dh(), sub.auth());
-        let signature = self.sign_for_subscription(&subscription_info)?;
-        let message = build_push_message(&subscription_info, signature, payload)?;
-        let req = into_reqwest(&self.client, message);
+    async fn deliver(&self, sub: &PushSubscription, payload: &str) -> Delivery {
+        // Subscriptions stored before the SPA switched to base64url hold standard
+        // base64 keys; web-push only accepts base64url, so normalise on read.
+        let subscription_info = SubscriptionInfo::new(
+            sub.endpoint().to_string(),
+            normalize_base64url(sub.p256dh()),
+            normalize_base64url(sub.auth()),
+        );
 
-        match req.send().await {
-            Ok(response) => log_response(response, sub).await,
+        let message = match self
+            .sign_for_subscription(&subscription_info)
+            .and_then(|sig| build_push_message(&subscription_info, sig, payload))
+        {
+            Ok(message) => message,
+            Err(e) => {
+                tracing::warn!(
+                    endpoint = sub.endpoint(),
+                    error = %e,
+                    "push subscription has unusable keys, dropping it"
+                );
+                self.forget(sub).await;
+                return Delivery::Removed;
+            }
+        };
+
+        match into_reqwest(&self.client, message).send().await {
+            Ok(response) => self.handle_response(response, sub).await,
             Err(e) => {
                 tracing::warn!(endpoint = sub.endpoint(), error = %e, "failed to send push");
+                Delivery::Failed
             }
         }
+    }
 
-        Ok(())
+    async fn handle_response(
+        &self,
+        response: reqwest::Response,
+        sub: &PushSubscription,
+    ) -> Delivery {
+        let status = response.status();
+
+        if status.is_success() {
+            tracing::info!(endpoint = sub.endpoint(), "push notification sent");
+            return Delivery::Sent;
+        }
+
+        let body = response.text().await.unwrap_or_default();
+        tracing::warn!(endpoint = sub.endpoint(), %status, body, "push endpoint rejected");
+
+        // 404/410 mean the push service has retired this endpoint for good.
+        if status == reqwest::StatusCode::NOT_FOUND || status == reqwest::StatusCode::GONE {
+            self.forget(sub).await;
+            return Delivery::Removed;
+        }
+
+        Delivery::Failed
+    }
+
+    async fn forget(&self, sub: &PushSubscription) {
+        if let Err(e) = self
+            .subscription_command
+            .delete_by_endpoint(sub.endpoint())
+            .await
+        {
+            tracing::warn!(endpoint = sub.endpoint(), error = %e, "failed to drop push subscription");
+        }
     }
 }
 
@@ -92,9 +157,26 @@ impl domain::ports::ReminderSenderPort for WebPushSender {
         }
 
         let payload = reminder_payload();
+        let mut sent = 0usize;
+        let mut removed = 0usize;
+        let mut failed = 0usize;
 
+        // One broken subscription must never stop the others from being delivered.
         for sub in &subscriptions {
-            self.deliver(sub, &payload).await?;
+            match self.deliver(sub, &payload).await {
+                Delivery::Sent => sent += 1,
+                Delivery::Removed => removed += 1,
+                Delivery::Failed => failed += 1,
+            }
+        }
+
+        tracing::info!(%user_id, sent, removed, failed, "push reminder dispatched");
+
+        if sent == 0 {
+            return Err(DomainError::InvalidInput(format!(
+                "no push notification could be delivered ({removed} stale subscription(s) dropped, \
+                 {failed} failed); re-enable notifications on your devices"
+            )));
         }
 
         Ok(())
@@ -126,6 +208,20 @@ fn base64_url_encode(input: &[u8]) -> String {
     base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(input)
 }
 
+/// Rewrite a standard-base64 key into the unpadded base64url form web-push expects.
+/// Already-base64url input passes through unchanged.
+fn normalize_base64url(key: &str) -> String {
+    key.trim()
+        .trim_end_matches('=')
+        .chars()
+        .map(|c| match c {
+            '+' => '-',
+            '/' => '_',
+            other => other,
+        })
+        .collect()
+}
+
 fn reminder_payload() -> String {
     serde_json::json!({
         "title": "K-Mood",
@@ -177,12 +273,53 @@ fn into_reqwest(client: &reqwest::Client, message: WebPushMessage) -> reqwest::R
     req
 }
 
-async fn log_response(response: reqwest::Response, sub: &PushSubscription) {
-    let status = response.status();
-    if status.is_success() {
-        tracing::info!(endpoint = sub.endpoint(), "push notification sent");
-    } else {
-        let body = response.text().await.unwrap_or_default();
-        tracing::warn!(endpoint = sub.endpoint(), %status, body, "push endpoint rejected");
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // A real browser key, in both encodings the SPA has used.
+    const P256DH_URL: &str =
+        "BIM-sgr6FjcgJEXAWF1FysKt3Ua19-HfezOPbDVCpvQvGjvH4ITJCVqIZycQO9LFrJA3cLwDgZzf__tpMu9sJMs";
+    const P256DH_STD: &str =
+        "BIM+sgr6FjcgJEXAWF1FysKt3Ua19+HfezOPbDVCpvQvGjvH4ITJCVqIZycQO9LFrJA3cLwDgZzf//tpMu9sJMs=";
+    const AUTH_URL: &str = "q5Ph0_85t6y2GhRWxzDnyw";
+    const AUTH_STD: &str = "q5Ph0/85t6y2GhRWxzDnyw==";
+    const ENDPOINT: &str = "https://jmt17.google.com/fcm/send/eLUei3g4D0M";
+
+    #[test]
+    fn normalizes_legacy_standard_base64_keys() {
+        assert_eq!(normalize_base64url(P256DH_STD), P256DH_URL);
+        assert_eq!(normalize_base64url(AUTH_STD), AUTH_URL);
+    }
+
+    #[test]
+    fn leaves_base64url_keys_untouched() {
+        assert_eq!(normalize_base64url(P256DH_URL), P256DH_URL);
+        assert_eq!(normalize_base64url(AUTH_URL), AUTH_URL);
+    }
+
+    /// Legacy rows used to abort the whole send with "invalid cryptographic keys".
+    #[test]
+    fn legacy_keys_encrypt_after_normalization() {
+        for (p256dh, auth) in [(P256DH_STD, AUTH_STD), (P256DH_URL, AUTH_URL)] {
+            let info = SubscriptionInfo::new(
+                ENDPOINT.to_string(),
+                normalize_base64url(p256dh),
+                normalize_base64url(auth),
+            );
+            let payload = reminder_payload();
+            let mut builder = WebPushMessageBuilder::new(&info);
+            builder.set_payload(ContentEncoding::Aes128Gcm, payload.as_bytes());
+            assert!(builder.build().is_ok(), "failed for {p256dh}");
+        }
+    }
+
+    #[test]
+    fn raw_standard_base64_keys_are_rejected_by_web_push() {
+        let info = SubscriptionInfo::new(ENDPOINT, P256DH_STD, AUTH_STD);
+        let payload = reminder_payload();
+        let mut builder = WebPushMessageBuilder::new(&info);
+        builder.set_payload(ContentEncoding::Aes128Gcm, payload.as_bytes());
+        assert!(builder.build().is_err());
     }
 }
diff --git a/crates/api-types/Cargo.toml b/crates/api-types/Cargo.toml
index 7048233..6cd2f32 100644
--- a/crates/api-types/Cargo.toml
+++ b/crates/api-types/Cargo.toml
@@ -11,4 +11,8 @@ serde.workspace = true
 thiserror.workspace = true
 uuid.workspace = true
 chrono.workspace = true
+serde_json.workspace = true
 utoipa.workspace = true
+
+[dev-dependencies]
+serde_json.workspace = true
diff --git a/crates/api-types/src/dimension.rs b/crates/api-types/src/dimension.rs
new file mode 100644
index 0000000..d8f331d
--- /dev/null
+++ b/crates/api-types/src/dimension.rs
@@ -0,0 +1,141 @@
+use domain::dimension::DimensionValue;
+use domain::entry::Content;
+use domain::location::Coordinates;
+use domain::provider::ProviderName;
+use domain::song::{RecordingId, Song};
+use domain::weather::{Celsius, Condition, Weather};
+
+use crate::errors::ApiValidationError;
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, utoipa::ToSchema)]
+#[serde(
+    tag = "kind",
+    rename_all = "camelCase",
+    rename_all_fields = "camelCase"
+)]
+pub enum DimensionPayload {
+    Content {
+        text: String,
+    },
+    Activities {
+        ids: Vec<String>,
+    },
+    Photos {
+        ids: Vec<String>,
+    },
+    VoiceMemos {
+        ids: Vec<String>,
+    },
+    Location {
+        latitude: f64,
+        longitude: f64,
+    },
+    Song {
+        title: String,
+        artist: String,
+        #[serde(skip_serializing_if = "Option::is_none", default)]
+        album: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none", default)]
+        recording_id: Option<String>,
+    },
+    Weather {
+        condition: String,
+        temperature: f64,
+        observed_by: String,
+    },
+}
+
+impl From<&DimensionValue> for DimensionPayload {
+    fn from(value: &DimensionValue) -> Self {
+        match value {
+            DimensionValue::Content(content) => Self::Content {
+                text: content.value().to_string(),
+            },
+            DimensionValue::Activities(ids) => Self::Activities {
+                ids: ids.iter().map(|id| id.value().to_string()).collect(),
+            },
+            DimensionValue::Photos(ids) => Self::Photos {
+                ids: ids.iter().map(|id| id.value().to_string()).collect(),
+            },
+            DimensionValue::VoiceMemos(ids) => Self::VoiceMemos {
+                ids: ids.iter().map(|id| id.value().to_string()).collect(),
+            },
+            DimensionValue::Location(coordinates) => Self::Location {
+                latitude: coordinates.latitude().value(),
+                longitude: coordinates.longitude().value(),
+            },
+            DimensionValue::Weather(weather) => Self::Weather {
+                condition: weather.condition().name().to_string(),
+                temperature: weather.temperature().value(),
+                observed_by: weather.observed_by().value().to_string(),
+            },
+            DimensionValue::Song(song) => Self::Song {
+                title: song.title().value().to_string(),
+                artist: song.artist().value().to_string(),
+                album: song.album().map(|album| album.value().to_string()),
+                recording_id: song.recording_id().map(|id| id.value().to_string()),
+            },
+        }
+    }
+}
+
+impl DimensionPayload {
+    pub fn is_empty(&self) -> bool {
+        match self {
+            Self::Content { text } => text.trim().is_empty(),
+            Self::Activities { ids } | Self::Photos { ids } | Self::VoiceMemos { ids } => {
+                ids.is_empty()
+            }
+            Self::Location { .. } | Self::Song { .. } | Self::Weather { .. } => false,
+        }
+    }
+
+    pub fn into_dimension(self) -> Result<DimensionValue, ApiValidationError> {
+        match self {
+            Self::Content { text } => Ok(DimensionValue::Content(Content::new(text)?)),
+            Self::Activities { ids } => Ok(DimensionValue::activities(all_ids(&ids)?)),
+            Self::Photos { ids } => Ok(DimensionValue::Photos(all_ids(&ids)?)),
+            Self::VoiceMemos { ids } => Ok(DimensionValue::VoiceMemos(all_ids(&ids)?)),
+            Self::Location {
+                latitude,
+                longitude,
+            } => Ok(DimensionValue::Location(Coordinates::new(
+                latitude, longitude,
+            )?)),
+            Self::Weather {
+                condition,
+                temperature,
+                observed_by,
+            } => {
+                let condition = Condition::from_name(&condition).ok_or_else(|| {
+                    ApiValidationError::Invalid(format!("unknown weather condition: {condition}"))
+                })?;
+
+                Ok(DimensionValue::Weather(Weather::new(
+                    condition,
+                    Celsius::new(temperature)?,
+                    ProviderName::new(observed_by)?,
+                )))
+            }
+            Self::Song {
+                title,
+                artist,
+                album,
+                recording_id,
+            } => {
+                let recording_id = recording_id.as_deref().map(RecordingId::new).transpose()?;
+
+                Ok(DimensionValue::Song(Song::new(
+                    title,
+                    artist,
+                    album,
+                    recording_id,
+                )?))
+            }
+        }
+    }
+}
+
+fn all_ids<T: From<uuid::Uuid>>(ids: &[String]) -> Result<Vec<T>, ApiValidationError> {
+    crate::mappers::shared::parse_uuids_as(ids, ids.len(), "identifiers")
+}
diff --git a/crates/api-types/src/lib.rs b/crates/api-types/src/lib.rs
index b4c8664..2d48b8a 100644
--- a/crates/api-types/src/lib.rs
+++ b/crates/api-types/src/lib.rs
@@ -1,3 +1,4 @@
+pub mod dimension;
 pub mod errors;
 pub mod mappers;
 pub mod requests;
diff --git a/crates/api-types/src/mappers/api_token.rs b/crates/api-types/src/mappers/api_token.rs
new file mode 100644
index 0000000..fd22111
--- /dev/null
+++ b/crates/api-types/src/mappers/api_token.rs
@@ -0,0 +1,24 @@
+use domain::api_token::{ApiToken, MintedApiToken};
+
+use crate::responses::{ApiTokenResponse, MintedApiTokenResponse};
+
+impl From<ApiToken> for ApiTokenResponse {
+    fn from(token: ApiToken) -> Self {
+        Self {
+            id: token.id().value().to_string(),
+            name: token.name().value().to_string(),
+            scope: token.scope().name().to_string(),
+            created_at: *token.created_at(),
+            last_used_at: token.last_used_at().copied(),
+        }
+    }
+}
+
+impl From<MintedApiToken> for MintedApiTokenResponse {
+    fn from(minted: MintedApiToken) -> Self {
+        Self {
+            secret: minted.secret().to_string(),
+            token: minted.token().clone().into(),
+        }
+    }
+}
diff --git a/crates/api-types/src/mappers/bulk.rs b/crates/api-types/src/mappers/bulk.rs
index 997f506..63ea047 100644
--- a/crates/api-types/src/mappers/bulk.rs
+++ b/crates/api-types/src/mappers/bulk.rs
@@ -5,7 +5,7 @@ use application::import::use_cases::import_entries::ImportResult;
 
 use crate::errors::ApiValidationError;
 use crate::requests::ReplaceActivityRequest;
-use crate::responses::{CorrelationResponse, ImportResultResponse};
+use crate::responses::ImportResultResponse;
 
 impl ReplaceActivityRequest {
     pub fn into_parts(
@@ -18,16 +18,6 @@ impl ReplaceActivityRequest {
     }
 }
 
-pub fn correlation_response(
-    activity_id: ActivityId,
-    correlation: Option<f64>,
-) -> CorrelationResponse {
-    CorrelationResponse {
-        activity_id: activity_id.value(),
-        correlation,
-    }
-}
-
 impl From<ImportResult> for ImportResultResponse {
     fn from(result: ImportResult) -> Self {
         Self {
diff --git a/crates/api-types/src/mappers/calendar.rs b/crates/api-types/src/mappers/calendar.rs
index 5ea68c8..7424002 100644
--- a/crates/api-types/src/mappers/calendar.rs
+++ b/crates/api-types/src/mappers/calendar.rs
@@ -5,9 +5,11 @@ use crate::responses::{CalendarDayResponse, EntryResponse};
 impl From<CalendarDay> for CalendarDayResponse {
     fn from(day: CalendarDay) -> Self {
         Self {
-            date: day.date,
-            dominant_mood: day.dominant_mood.map(|m| m.value()),
-            dominant_mood_label: day.dominant_mood.map(|m| format!("{m:?}")),
+            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())),
+            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/correlation.rs b/crates/api-types/src/mappers/correlation.rs
new file mode 100644
index 0000000..b7d57d4
--- /dev/null
+++ b/crates/api-types/src/mappers/correlation.rs
@@ -0,0 +1,45 @@
+use application::correlation::use_cases::get_correlations::{CorrelationRow, Score};
+use domain::correlation::CorrelationInput;
+
+use crate::responses::{
+    AgreementResponse, CorrelationInputResponse, CorrelationRowResponse, StrategyScoreResponse,
+};
+
+impl From<CorrelationRow> for CorrelationRowResponse {
+    fn from(row: CorrelationRow) -> Self {
+        Self {
+            input: input_response(&row.input, row.label.clone()),
+            sample_size: row.sample_size,
+            agreement: AgreementResponse {
+                agreeing: row.agreement.agreeing(),
+                applicable: row.agreement.applicable(),
+            },
+            scores: row.scores.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<Score> for StrategyScoreResponse {
+    fn from(score: Score) -> Self {
+        Self {
+            strategy: score.strategy.name().to_string(),
+            coefficient: score.coefficient.value(),
+            held_up: score.held_up,
+        }
+    }
+}
+
+fn input_response(input: &CorrelationInput, label: Option<String>) -> CorrelationInputResponse {
+    match input {
+        CorrelationInput::Metric(kind) => CorrelationInputResponse::Metric {
+            metric: kind.name().to_string(),
+        },
+        CorrelationInput::MoonPhase => CorrelationInputResponse::MoonPhase,
+        CorrelationInput::CycleProgress => CorrelationInputResponse::CycleProgress,
+        CorrelationInput::Temperature => CorrelationInputResponse::Temperature,
+        CorrelationInput::Activity(id) => CorrelationInputResponse::Activity {
+            activity_id: id.value().to_string(),
+            name: label.unwrap_or_default(),
+        },
+    }
+}
diff --git a/crates/api-types/src/mappers/cycle.rs b/crates/api-types/src/mappers/cycle.rs
new file mode 100644
index 0000000..5671737
--- /dev/null
+++ b/crates/api-types/src/mappers/cycle.rs
@@ -0,0 +1,33 @@
+use application::cycle::use_cases::read_cycle::CycleView;
+use domain::cycle::CyclePosition;
+use domain::user::UserPreferences;
+
+use crate::responses::{CyclePositionResponse, CycleViewResponse, PreferencesResponse};
+
+impl From<CycleView> for CycleViewResponse {
+    fn from(view: CycleView) -> Self {
+        Self {
+            tracking: view.tracking,
+            starts: view.starts.iter().map(|date| date.to_string()).collect(),
+            today: view.today.map(Into::into),
+            usual_length: view.usual_length,
+        }
+    }
+}
+
+impl From<CyclePosition> for CyclePositionResponse {
+    fn from(position: CyclePosition) -> Self {
+        Self {
+            day: position.day().value(),
+            progress: position.progress(),
+        }
+    }
+}
+
+impl From<UserPreferences> for PreferencesResponse {
+    fn from(preferences: UserPreferences) -> Self {
+        Self {
+            tracks_cycle: preferences.tracks_cycle(),
+        }
+    }
+}
diff --git a/crates/api-types/src/mappers/entry.rs b/crates/api-types/src/mappers/entry.rs
index f5f716d..67f749b 100644
--- a/crates/api-types/src/mappers/entry.rs
+++ b/crates/api-types/src/mappers/entry.rs
@@ -1,7 +1,8 @@
 use chrono::Utc;
 
 use config::EntryConfig;
-use domain::entry::{Content, DateRange, Mood, MoodEntry, MoodEntryId};
+use domain::dimension::{ComposedEntry, DimensionValue};
+use domain::entry::{DateRange, Mood, MoodEntryId};
 use domain::user::UserId;
 
 use application::entry::commands::{CreateEntryCommand, UpdateEntryCommand};
@@ -9,11 +10,12 @@ use application::entry::queries::{
     FilterByActivityQuery, FilterByMoodQuery, ListEntriesQuery, MoodStatsQuery,
 };
 
+use crate::dimension::DimensionPayload;
 use crate::errors::ApiValidationError;
 use crate::requests::{CreateEntryRequest, DateRangeParams, ListEntriesParams, UpdateEntryRequest};
 use crate::responses::EntryResponse;
 
-use super::shared::{parse_datetime, parse_uuids_as, validate_content_length};
+use super::shared::{parse_datetime, validate_content_length};
 
 impl CreateEntryRequest {
     pub fn into_command(
@@ -26,31 +28,13 @@ impl CreateEntryRequest {
             Some(dt) => parse_datetime(&dt)?,
             None => Utc::now().fixed_offset(),
         };
-        let content = parse_content(self.content, config)?;
-        let activities = parse_uuids_as(
-            &self.activity_ids.unwrap_or_default(),
-            config.max_activities_per_entry,
-            "activities",
-        )?;
-        let photos = parse_uuids_as(
-            &self.photo_ids.unwrap_or_default(),
-            config.max_photos,
-            "photos",
-        )?;
-        let voice_memos = parse_uuids_as(
-            &self.voice_memo_ids.unwrap_or_default(),
-            config.max_voice_memos,
-            "voice memos",
-        )?;
+        let dimensions = parse_dimensions(self.dimensions, config)?;
 
         Ok(CreateEntryCommand {
             user_id,
             mood,
             logged_at,
-            activities,
-            content,
-            photos,
-            voice_memos,
+            dimensions,
         })
     }
 }
@@ -62,35 +46,14 @@ impl UpdateEntryRequest {
         config: &EntryConfig,
     ) -> Result<UpdateEntryCommand, ApiValidationError> {
         let mood = Mood::try_from(self.mood)?;
-        let logged_at = match self.logged_at {
-            Some(dt) => parse_datetime(&dt)?,
-            None => Utc::now().fixed_offset(),
-        };
-        let content = parse_content(self.content, config)?;
-        let activities = parse_uuids_as(
-            &self.activity_ids.unwrap_or_default(),
-            config.max_activities_per_entry,
-            "activities",
-        )?;
-        let photos = parse_uuids_as(
-            &self.photo_ids.unwrap_or_default(),
-            config.max_photos,
-            "photos",
-        )?;
-        let voice_memos = parse_uuids_as(
-            &self.voice_memo_ids.unwrap_or_default(),
-            config.max_voice_memos,
-            "voice memos",
-        )?;
+        let logged_at = self.logged_at.as_deref().map(parse_datetime).transpose()?;
+        let dimensions = parse_dimensions(self.dimensions, config)?;
 
         Ok(UpdateEntryCommand {
             entry_id,
             mood,
             logged_at,
-            activities,
-            content,
-            photos,
-            voice_memos,
+            dimensions,
         })
     }
 }
@@ -147,11 +110,9 @@ impl DateRangeParams {
     }
 }
 
-impl From<MoodEntry> for EntryResponse {
-    fn from(entry: MoodEntry) -> Self {
-        let photo_ids: Vec<uuid::Uuid> = entry.photos().iter().map(|p| p.value()).collect();
-        let voice_memo_ids: Vec<uuid::Uuid> =
-            entry.voice_memos().iter().map(|v| v.value()).collect();
+impl From<ComposedEntry> for EntryResponse {
+    fn from(composed: ComposedEntry) -> Self {
+        let entry = &composed.entry;
 
         Self {
             id: entry.id().value(),
@@ -159,33 +120,61 @@ impl From<MoodEntry> for EntryResponse {
             mood: entry.mood().value(),
             mood_label: format!("{:?}", entry.mood()),
             logged_at: *entry.logged_at(),
-            activities: entry.activities().iter().map(|a| a.value()).collect(),
-            content: entry.content().map(|c| c.value().to_string()),
-            photo_urls: photo_ids
+            photo_urls: composed
+                .photos()
                 .iter()
-                .map(|id| format!("/api/v1/media/photos/{id}"))
+                .map(|id| format!("/api/v1/media/photos/{}", id.value()))
                 .collect(),
-            photos: photo_ids,
-            voice_memo_urls: voice_memo_ids
+            voice_memo_urls: composed
+                .voice_memos()
                 .iter()
-                .map(|id| format!("/api/v1/media/voice-memos/{id}"))
+                .map(|id| format!("/api/v1/media/voice-memos/{}", id.value()))
                 .collect(),
-            voice_memos: voice_memo_ids,
+            dimensions: composed.dimensions.iter().map(Into::into).collect(),
             created_at: *entry.created_at(),
             updated_at: *entry.updated_at(),
         }
     }
 }
 
-fn parse_content(
-    content: Option<String>,
+fn parse_dimensions(
+    payloads: Option<Vec<DimensionPayload>>,
     config: &EntryConfig,
-) -> Result<Option<Content>, ApiValidationError> {
-    content
-        .filter(|s| !s.trim().is_empty())
-        .map(|text| {
-            validate_content_length(&text, config.max_content_length)?;
-            Content::new(text).map_err(ApiValidationError::from)
+) -> Result<Vec<DimensionValue>, ApiValidationError> {
+    payloads
+        .unwrap_or_default()
+        .into_iter()
+        .filter(|payload| !payload.is_empty())
+        .map(|payload| {
+            within_limits(&payload, config)?;
+            payload.into_dimension()
         })
-        .transpose()
+        .collect()
+}
+
+fn within_limits(
+    payload: &DimensionPayload,
+    config: &EntryConfig,
+) -> Result<(), ApiValidationError> {
+    let (held, most, label) = match payload {
+        DimensionPayload::Content { text } => {
+            return validate_content_length(text, config.max_content_length);
+        }
+        DimensionPayload::Activities { ids } => {
+            (ids.len(), config.max_activities_per_entry, "activities")
+        }
+        DimensionPayload::Photos { ids } => (ids.len(), config.max_photos, "photos"),
+        DimensionPayload::VoiceMemos { ids } => (ids.len(), config.max_voice_memos, "voice memos"),
+        DimensionPayload::Location { .. }
+        | DimensionPayload::Song { .. }
+        | DimensionPayload::Weather { .. } => return Ok(()),
+    };
+
+    if held > most {
+        return Err(ApiValidationError::Invalid(format!(
+            "too many {label}, maximum is {most}"
+        )));
+    }
+
+    Ok(())
 }
diff --git a/crates/api-types/src/mappers/import_metrics.rs b/crates/api-types/src/mappers/import_metrics.rs
new file mode 100644
index 0000000..1d808bf
--- /dev/null
+++ b/crates/api-types/src/mappers/import_metrics.rs
@@ -0,0 +1,68 @@
+use application::import::commands::{ImportedDay, ImportedMetric};
+use application::import::use_cases::import_daily_metrics::{ImportOutcome, RejectionSummary};
+use domain::rejection::RejectedMetric;
+
+use crate::requests::{ImportDailyMetricsRequest, ImportedDayPayload, ImportedMetricPayload};
+use crate::responses::{ImportOutcomeResponse, RejectedMetricResponse, RejectionResponse};
+
+impl ImportDailyMetricsRequest {
+    pub fn into_days(self) -> Vec<ImportedDay> {
+        self.days.into_iter().map(Into::into).collect()
+    }
+}
+
+impl From<ImportedDayPayload> for ImportedDay {
+    fn from(payload: ImportedDayPayload) -> Self {
+        Self {
+            date: payload.date,
+            metrics: payload.metrics.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<ImportedMetricPayload> for ImportedMetric {
+    fn from(payload: ImportedMetricPayload) -> Self {
+        Self {
+            kind: payload.kind,
+            value: payload.value,
+        }
+    }
+}
+
+impl From<ImportOutcome> for ImportOutcomeResponse {
+    fn from(outcome: ImportOutcome) -> Self {
+        Self {
+            accepted: outcome.accepted,
+            superseded: outcome.superseded,
+            rejected: outcome.rejected.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<RejectionSummary> for RejectedMetricResponse {
+    fn from(summary: RejectionSummary) -> Self {
+        Self {
+            date: summary.date,
+            kind: summary.kind,
+            reason: summary.reason,
+        }
+    }
+}
+
+impl From<RejectedMetric> for RejectionResponse {
+    fn from(rejected: RejectedMetric) -> Self {
+        Self {
+            id: rejected.id().value().to_string(),
+            origin: rejected.origin().name().to_string(),
+            provider: rejected
+                .detail()
+                .provider()
+                .map(|name| name.value().to_string()),
+            date: rejected.detail().date().map(|date| date.to_string()),
+            kind: rejected.detail().kind().to_string(),
+            value: rejected.detail().value(),
+            reason: rejected.reason().to_string(),
+            recorded_at: *rejected.recorded_at(),
+        }
+    }
+}
diff --git a/crates/api-types/src/mappers/metric.rs b/crates/api-types/src/mappers/metric.rs
new file mode 100644
index 0000000..5082e2a
--- /dev/null
+++ b/crates/api-types/src/mappers/metric.rs
@@ -0,0 +1,49 @@
+use application::metric::commands::MetricChange;
+use domain::entry::{Date, DateSpan};
+use domain::metric::{DailyMetric, MetricKind, MetricValue};
+
+use crate::errors::ApiValidationError;
+use crate::requests::{DateSpanParams, MetricPayload};
+use crate::responses::DailyMetricResponse;
+
+impl From<DailyMetric> for DailyMetricResponse {
+    fn from(metric: DailyMetric) -> Self {
+        Self {
+            date: metric.date().to_string(),
+            kind: metric.kind().name().to_string(),
+            value: metric.value().count(),
+            provider: metric
+                .source()
+                .provider()
+                .map(|name| name.value().to_string()),
+        }
+    }
+}
+
+impl MetricPayload {
+    pub fn into_change(self) -> Result<MetricChange, ApiValidationError> {
+        let kind = MetricKind::from_name(&self.kind).ok_or_else(|| {
+            ApiValidationError::Invalid(format!("unknown metric kind: {}", self.kind))
+        })?;
+
+        match self.value {
+            None => Ok(MetricChange::Cleared(kind)),
+            Some(count) => Ok(MetricChange::Stated(MetricValue::of_kind(kind, count)?)),
+        }
+    }
+}
+
+impl DateSpanParams {
+    pub fn into_span(self) -> Result<DateSpan, ApiValidationError> {
+        Ok(DateSpan::new(
+            parse_date(&self.from)?,
+            parse_date(&self.to)?,
+        )?)
+    }
+}
+
+pub fn parse_date(date: &str) -> Result<Date, ApiValidationError> {
+    date.parse()
+        .map(Date::from_persistence)
+        .map_err(|_| ApiValidationError::Invalid(format!("invalid date: {date}")))
+}
diff --git a/crates/api-types/src/mappers/mod.rs b/crates/api-types/src/mappers/mod.rs
index 2b0089e..c0905c3 100644
--- a/crates/api-types/src/mappers/mod.rs
+++ b/crates/api-types/src/mappers/mod.rs
@@ -1,11 +1,18 @@
 mod activity;
+mod api_token;
 mod bulk;
 mod calendar;
+mod correlation;
+mod cycle;
 mod entry;
+mod import_metrics;
 mod media;
+mod metric;
+mod provider;
 mod reminder;
+mod restore;
 pub mod shared;
 mod stats;
 mod user;
 
-pub use bulk::correlation_response;
+pub use metric::parse_date;
diff --git a/crates/api-types/src/mappers/provider.rs b/crates/api-types/src/mappers/provider.rs
new file mode 100644
index 0000000..8a5f555
--- /dev/null
+++ b/crates/api-types/src/mappers/provider.rs
@@ -0,0 +1,12 @@
+use application::provider::use_cases::list_connections::ConnectionSummary;
+
+use crate::responses::ProviderConnectionResponse;
+
+impl From<ConnectionSummary> for ProviderConnectionResponse {
+    fn from(summary: ConnectionSummary) -> Self {
+        Self {
+            provider: summary.provider.value().to_string(),
+            connected_at: summary.connected_at,
+        }
+    }
+}
diff --git a/crates/api-types/src/mappers/restore.rs b/crates/api-types/src/mappers/restore.rs
new file mode 100644
index 0000000..3341c3f
--- /dev/null
+++ b/crates/api-types/src/mappers/restore.rs
@@ -0,0 +1,17 @@
+use application::restore::use_cases::restore_backup::RestoreOutcome;
+
+use crate::responses::RestoreOutcomeResponse;
+
+impl From<RestoreOutcome> for RestoreOutcomeResponse {
+    fn from(outcome: RestoreOutcome) -> Self {
+        Self {
+            entries: outcome.entries,
+            metrics: outcome.metrics,
+            cycle_starts: outcome.cycle_starts,
+            activities: outcome.activities,
+            reminders: outcome.reminders,
+            media: outcome.media,
+            unreadable: outcome.unreadable,
+        }
+    }
+}
diff --git a/crates/api-types/src/requests/api_token.rs b/crates/api-types/src/requests/api_token.rs
new file mode 100644
index 0000000..3d139dc
--- /dev/null
+++ b/crates/api-types/src/requests/api_token.rs
@@ -0,0 +1,5 @@
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct MintApiTokenRequest {
+    pub name: String,
+}
diff --git a/crates/api-types/src/requests/cycle.rs b/crates/api-types/src/requests/cycle.rs
new file mode 100644
index 0000000..03418d4
--- /dev/null
+++ b/crates/api-types/src/requests/cycle.rs
@@ -0,0 +1,5 @@
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct SetPreferencesRequest {
+    pub tracks_cycle: bool,
+}
diff --git a/crates/api-types/src/requests/entry.rs b/crates/api-types/src/requests/entry.rs
index 3be6b04..52b2a76 100644
--- a/crates/api-types/src/requests/entry.rs
+++ b/crates/api-types/src/requests/entry.rs
@@ -3,10 +3,7 @@
 pub struct CreateEntryRequest {
     pub mood: u8,
     pub logged_at: Option<String>,
-    pub activity_ids: Option<Vec<String>>,
-    pub content: Option<String>,
-    pub photo_ids: Option<Vec<String>>,
-    pub voice_memo_ids: Option<Vec<String>>,
+    pub dimensions: Option<Vec<crate::dimension::DimensionPayload>>,
 }
 
 #[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
@@ -14,10 +11,7 @@ pub struct CreateEntryRequest {
 pub struct UpdateEntryRequest {
     pub mood: u8,
     pub logged_at: Option<String>,
-    pub activity_ids: Option<Vec<String>>,
-    pub content: Option<String>,
-    pub photo_ids: Option<Vec<String>>,
-    pub voice_memo_ids: Option<Vec<String>>,
+    pub dimensions: Option<Vec<crate::dimension::DimensionPayload>>,
 }
 
 #[derive(Debug, serde::Deserialize, utoipa::ToSchema, utoipa::IntoParams)]
diff --git a/crates/api-types/src/requests/import.rs b/crates/api-types/src/requests/import.rs
new file mode 100644
index 0000000..7c9ffb8
--- /dev/null
+++ b/crates/api-types/src/requests/import.rs
@@ -0,0 +1,19 @@
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ImportDailyMetricsRequest {
+    pub days: Vec<ImportedDayPayload>,
+}
+
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ImportedDayPayload {
+    pub date: String,
+    pub metrics: Vec<ImportedMetricPayload>,
+}
+
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ImportedMetricPayload {
+    pub kind: String,
+    pub value: Option<i64>,
+}
diff --git a/crates/api-types/src/requests/metric.rs b/crates/api-types/src/requests/metric.rs
new file mode 100644
index 0000000..c06f3a0
--- /dev/null
+++ b/crates/api-types/src/requests/metric.rs
@@ -0,0 +1,19 @@
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct SetDailyMetricsRequest {
+    pub metrics: Vec<MetricPayload>,
+}
+
+#[derive(Debug, serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+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 55e5aa5..755f165 100644
--- a/crates/api-types/src/requests/mod.rs
+++ b/crates/api-types/src/requests/mod.rs
@@ -1,14 +1,24 @@
 mod activity;
+mod api_token;
+mod cycle;
 mod entry;
+mod import;
+mod metric;
+mod provider;
 mod push;
 mod reminder;
 mod user;
 
 pub use activity::{CreateActivityRequest, RenameActivityRequest, SetCategoryRequest};
+pub use api_token::MintApiTokenRequest;
+pub use cycle::SetPreferencesRequest;
 pub use entry::{
     CreateEntryRequest, DateRangeParams, ListEntriesParams, ReplaceActivityRequest,
     UpdateEntryRequest,
 };
+pub use import::{ImportDailyMetricsRequest, ImportedDayPayload, ImportedMetricPayload};
+pub use metric::{DateSpanParams, MetricPayload, SetDailyMetricsRequest};
+pub use provider::ConnectProviderRequest;
 pub use push::{PushSubscribeRequest, PushUnsubscribeRequest};
 pub use reminder::{CreateReminderRequest, UpdateReminderRequest};
 pub use user::{ChangePasswordRequest, LoginRequest, RegisterRequest, UpdateProfileRequest};
diff --git a/crates/api-types/src/requests/provider.rs b/crates/api-types/src/requests/provider.rs
new file mode 100644
index 0000000..d344435
--- /dev/null
+++ b/crates/api-types/src/requests/provider.rs
@@ -0,0 +1,14 @@
+#[derive(serde::Deserialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ConnectProviderRequest {
+    #[schema(value_type = Object)]
+    pub credential: serde_json::Value,
+}
+
+impl std::fmt::Debug for ConnectProviderRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ConnectProviderRequest")
+            .field("credential", &"<redacted>")
+            .finish()
+    }
+}
diff --git a/crates/api-types/src/responses/api_token.rs b/crates/api-types/src/responses/api_token.rs
new file mode 100644
index 0000000..9055efc
--- /dev/null
+++ b/crates/api-types/src/responses/api_token.rs
@@ -0,0 +1,18 @@
+use chrono::{DateTime, Utc};
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiTokenResponse {
+    pub id: String,
+    pub name: String,
+    pub scope: String,
+    pub created_at: DateTime<Utc>,
+    pub last_used_at: Option<DateTime<Utc>>,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct MintedApiTokenResponse {
+    pub token: ApiTokenResponse,
+    pub secret: String,
+}
diff --git a/crates/api-types/src/responses/bulk.rs b/crates/api-types/src/responses/bulk.rs
index a573584..0143343 100644
--- a/crates/api-types/src/responses/bulk.rs
+++ b/crates/api-types/src/responses/bulk.rs
@@ -14,13 +14,6 @@ pub struct ImportResultResponse {
     pub errors: Vec<String>,
 }
 
-#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct CorrelationResponse {
-    pub activity_id: Uuid,
-    pub correlation: Option<f64>,
-}
-
 #[derive(Debug, serde::Serialize, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct MediaIdResponse {
diff --git a/crates/api-types/src/responses/calendar.rs b/crates/api-types/src/responses/calendar.rs
index 04dec56..4c8c806 100644
--- a/crates/api-types/src/responses/calendar.rs
+++ b/crates/api-types/src/responses/calendar.rs
@@ -7,6 +7,8 @@ use super::EntryResponse;
 pub struct CalendarDayResponse {
     pub date: NaiveDate,
     pub entries: Vec<EntryResponse>,
-    pub dominant_mood: Option<u8>,
-    pub dominant_mood_label: Option<String>,
+    pub day_mood: Option<f64>,
+    pub mood: Option<u8>,
+    pub mood_label: Option<String>,
+    pub cycle_day: Option<u16>,
 }
diff --git a/crates/api-types/src/responses/correlation.rs b/crates/api-types/src/responses/correlation.rs
new file mode 100644
index 0000000..41b24d4
--- /dev/null
+++ b/crates/api-types/src/responses/correlation.rs
@@ -0,0 +1,37 @@
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct CorrelationRowResponse {
+    pub input: CorrelationInputResponse,
+    pub sample_size: usize,
+    pub agreement: AgreementResponse,
+    pub scores: Vec<StrategyScoreResponse>,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(
+    tag = "kind",
+    rename_all = "camelCase",
+    rename_all_fields = "camelCase"
+)]
+pub enum CorrelationInputResponse {
+    Metric { metric: String },
+    MoonPhase,
+    CycleProgress,
+    Temperature,
+    Activity { activity_id: String, name: String },
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct AgreementResponse {
+    pub agreeing: usize,
+    pub applicable: usize,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct StrategyScoreResponse {
+    pub strategy: String,
+    pub coefficient: f64,
+    pub held_up: bool,
+}
diff --git a/crates/api-types/src/responses/cycle.rs b/crates/api-types/src/responses/cycle.rs
new file mode 100644
index 0000000..bdd556e
--- /dev/null
+++ b/crates/api-types/src/responses/cycle.rs
@@ -0,0 +1,21 @@
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct CycleViewResponse {
+    pub tracking: bool,
+    pub starts: Vec<String>,
+    pub today: Option<CyclePositionResponse>,
+    pub usual_length: i64,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct CyclePositionResponse {
+    pub day: u16,
+    pub progress: f64,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct PreferencesResponse {
+    pub tracks_cycle: bool,
+}
diff --git a/crates/api-types/src/responses/entry.rs b/crates/api-types/src/responses/entry.rs
index 10a3072..b31bdfa 100644
--- a/crates/api-types/src/responses/entry.rs
+++ b/crates/api-types/src/responses/entry.rs
@@ -9,11 +9,8 @@ pub struct EntryResponse {
     pub mood: u8,
     pub mood_label: String,
     pub logged_at: DateTime<FixedOffset>,
-    pub activities: Vec<Uuid>,
-    pub content: Option<String>,
-    pub photos: Vec<Uuid>,
+    pub dimensions: Vec<crate::dimension::DimensionPayload>,
     pub photo_urls: Vec<String>,
-    pub voice_memos: Vec<Uuid>,
     pub voice_memo_urls: Vec<String>,
     pub created_at: DateTime<Utc>,
     pub updated_at: DateTime<Utc>,
diff --git a/crates/api-types/src/responses/import.rs b/crates/api-types/src/responses/import.rs
new file mode 100644
index 0000000..cc6dcfa
--- /dev/null
+++ b/crates/api-types/src/responses/import.rs
@@ -0,0 +1,30 @@
+use chrono::{DateTime, Utc};
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ImportOutcomeResponse {
+    pub accepted: usize,
+    pub superseded: usize,
+    pub rejected: Vec<RejectedMetricResponse>,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct RejectedMetricResponse {
+    pub date: Option<String>,
+    pub kind: String,
+    pub reason: String,
+}
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct RejectionResponse {
+    pub id: String,
+    pub origin: String,
+    pub provider: Option<String>,
+    pub date: Option<String>,
+    pub kind: String,
+    pub value: Option<i64>,
+    pub reason: String,
+    pub recorded_at: DateTime<Utc>,
+}
diff --git a/crates/api-types/src/responses/metric.rs b/crates/api-types/src/responses/metric.rs
new file mode 100644
index 0000000..b5d11f2
--- /dev/null
+++ b/crates/api-types/src/responses/metric.rs
@@ -0,0 +1,9 @@
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct DailyMetricResponse {
+    pub date: String,
+    pub kind: String,
+    pub value: i64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+}
diff --git a/crates/api-types/src/responses/mod.rs b/crates/api-types/src/responses/mod.rs
index de29fe5..1bc0fc4 100644
--- a/crates/api-types/src/responses/mod.rs
+++ b/crates/api-types/src/responses/mod.rs
@@ -1,15 +1,31 @@
 mod activity;
+mod api_token;
 mod bulk;
 mod calendar;
+mod correlation;
+mod cycle;
 mod entry;
+mod import;
+mod metric;
+mod provider;
 mod reminder;
+mod restore;
 mod stats;
 mod user;
 
 pub use activity::ActivityResponse;
-pub use bulk::{BulkActionResponse, CorrelationResponse, ImportResultResponse, MediaIdResponse};
+pub use api_token::{ApiTokenResponse, MintedApiTokenResponse};
+pub use bulk::{BulkActionResponse, ImportResultResponse, MediaIdResponse};
 pub use calendar::CalendarDayResponse;
+pub use correlation::{
+    AgreementResponse, CorrelationInputResponse, CorrelationRowResponse, StrategyScoreResponse,
+};
+pub use cycle::{CyclePositionResponse, CycleViewResponse, PreferencesResponse};
 pub use entry::EntryResponse;
+pub use import::{ImportOutcomeResponse, RejectedMetricResponse, RejectionResponse};
+pub use metric::DailyMetricResponse;
+pub use provider::ProviderConnectionResponse;
 pub use reminder::{DayScheduleResponse, ReminderResponse};
+pub use restore::RestoreOutcomeResponse;
 pub use stats::{MoodFrequency, MoodStatsResponse};
 pub use user::UserResponse;
diff --git a/crates/api-types/src/responses/provider.rs b/crates/api-types/src/responses/provider.rs
new file mode 100644
index 0000000..294a4ef
--- /dev/null
+++ b/crates/api-types/src/responses/provider.rs
@@ -0,0 +1,8 @@
+use chrono::{DateTime, Utc};
+
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct ProviderConnectionResponse {
+    pub provider: String,
+    pub connected_at: DateTime<Utc>,
+}
diff --git a/crates/api-types/src/responses/restore.rs b/crates/api-types/src/responses/restore.rs
new file mode 100644
index 0000000..cc57706
--- /dev/null
+++ b/crates/api-types/src/responses/restore.rs
@@ -0,0 +1,11 @@
+#[derive(Debug, serde::Serialize, utoipa::ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct RestoreOutcomeResponse {
+    pub entries: usize,
+    pub metrics: usize,
+    pub cycle_starts: usize,
+    pub activities: usize,
+    pub reminders: usize,
+    pub media: usize,
+    pub unreadable: Vec<String>,
+}
diff --git a/crates/api-types/tests/dimension.rs b/crates/api-types/tests/dimension.rs
new file mode 100644
index 0000000..ac4b384
--- /dev/null
+++ b/crates/api-types/tests/dimension.rs
@@ -0,0 +1,2 @@
+#[path = "dimension/payload_test.rs"]
+mod payload_test;
diff --git a/crates/api-types/tests/dimension/payload_test.rs b/crates/api-types/tests/dimension/payload_test.rs
new file mode 100644
index 0000000..2bb9d83
--- /dev/null
+++ b/crates/api-types/tests/dimension/payload_test.rs
@@ -0,0 +1,79 @@
+use api_types::dimension::DimensionPayload;
+use api_types::requests::CreateEntryRequest;
+
+#[test]
+fn a_known_dimension_kind_is_accepted() {
+    let payload: DimensionPayload =
+        serde_json::from_str(r#"{"kind":"content","text":"went for a walk"}"#).unwrap();
+
+    assert!(matches!(payload, DimensionPayload::Content { text } if text == "went for a walk"));
+}
+
+#[test]
+fn an_unknown_dimension_kind_is_rejected() {
+    let result = serde_json::from_str::<DimensionPayload>(r#"{"kind":"telepathy","text":"hi"}"#);
+
+    assert!(result.is_err());
+}
+
+#[test]
+fn an_entry_request_carrying_an_unknown_dimension_kind_is_rejected() {
+    let result = serde_json::from_str::<CreateEntryRequest>(
+        r#"{"mood":4,"dimensions":[{"kind":"telepathy","text":"hi"}]}"#,
+    );
+
+    assert!(result.is_err());
+}
+
+#[test]
+fn an_entry_request_with_no_dimensions_is_accepted() {
+    let request: CreateEntryRequest = serde_json::from_str(r#"{"mood":4}"#).unwrap();
+
+    assert!(request.dimensions.is_none());
+}
+
+#[test]
+fn a_location_payload_carries_both_coordinates() {
+    let payload: DimensionPayload =
+        serde_json::from_str(r#"{"kind":"location","latitude":52.2297,"longitude":21.0122}"#)
+            .unwrap();
+
+    assert!(matches!(
+        payload,
+        DimensionPayload::Location { latitude, longitude }
+            if (latitude - 52.2297).abs() < f64::EPSILON
+                && (longitude - 21.0122).abs() < f64::EPSILON
+    ));
+}
+
+#[test]
+fn a_song_payload_needs_only_a_title_and_artist() {
+    let payload: DimensionPayload =
+        serde_json::from_str(r#"{"kind":"song","title":"Airbag","artist":"Radiohead"}"#).unwrap();
+
+    assert!(matches!(
+        payload,
+        DimensionPayload::Song {
+            album: None,
+            recording_id: None,
+            ..
+        }
+    ));
+}
+
+#[test]
+fn a_song_payload_carries_its_album_and_recording_id_when_present() {
+    let payload: DimensionPayload = serde_json::from_str(
+        r#"{"kind":"song","title":"Airbag","artist":"Radiohead","album":"OK Computer","recordingId":"f5c7e7a2-0000-4000-8000-000000000001"}"#,
+    )
+    .unwrap();
+
+    assert!(matches!(
+        payload,
+        DimensionPayload::Song {
+            album: Some(_),
+            recording_id: Some(_),
+            ..
+        }
+    ));
+}
diff --git a/crates/api-types/tests/entry.rs b/crates/api-types/tests/entry.rs
new file mode 100644
index 0000000..9ded8a9
--- /dev/null
+++ b/crates/api-types/tests/entry.rs
@@ -0,0 +1,2 @@
+#[path = "entry/update_request_test.rs"]
+mod update_request_test;
diff --git a/crates/api-types/tests/entry/update_request_test.rs b/crates/api-types/tests/entry/update_request_test.rs
new file mode 100644
index 0000000..97dc036
--- /dev/null
+++ b/crates/api-types/tests/entry/update_request_test.rs
@@ -0,0 +1,28 @@
+use config::EntryConfig;
+use domain::entry::MoodEntryId;
+
+use api_types::requests::UpdateEntryRequest;
+
+fn command_from(body: &str) -> application::entry::commands::UpdateEntryCommand {
+    let request: UpdateEntryRequest = serde_json::from_str(body).unwrap();
+    request
+        .into_command(MoodEntryId::generate(), &EntryConfig::default())
+        .unwrap()
+}
+
+#[test]
+fn an_update_omitting_logged_at_asks_for_no_date_change() {
+    let cmd = command_from(r#"{"mood":3}"#);
+
+    assert!(cmd.logged_at.is_none());
+}
+
+#[test]
+fn an_update_naming_logged_at_asks_to_move_the_entry() {
+    let cmd = command_from(r#"{"mood":3,"loggedAt":"2024-01-02T09:30:00+01:00"}"#);
+
+    assert_eq!(
+        cmd.logged_at.unwrap().to_rfc3339(),
+        "2024-01-02T09:30:00+01:00"
+    );
+}
diff --git a/crates/application/Cargo.toml b/crates/application/Cargo.toml
index 38bbd6d..a458378 100644
--- a/crates/application/Cargo.toml
+++ b/crates/application/Cargo.toml
@@ -15,4 +15,6 @@ tracing.workspace = true
 
 [dev-dependencies]
 domain = { workspace = true, features = ["test-helpers"] }
+exporter.workspace = true
+importer.workspace = true
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
diff --git a/crates/application/src/api_token/commands.rs b/crates/application/src/api_token/commands.rs
new file mode 100644
index 0000000..6aecd30
--- /dev/null
+++ b/crates/application/src/api_token/commands.rs
@@ -0,0 +1,8 @@
+use domain::provider::ProviderName;
+use domain::user::UserId;
+
+#[derive(Debug)]
+pub struct MintApiTokenCommand {
+    pub user_id: UserId,
+    pub name: ProviderName,
+}
diff --git a/crates/application/src/api_token/mod.rs b/crates/application/src/api_token/mod.rs
new file mode 100644
index 0000000..804f0ee
--- /dev/null
+++ b/crates/application/src/api_token/mod.rs
@@ -0,0 +1,2 @@
+pub mod commands;
+pub mod use_cases;
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
new file mode 100644
index 0000000..451efd5
--- /dev/null
+++ b/crates/application/src/api_token/use_cases/authenticate_api_token.rs
@@ -0,0 +1,30 @@
+use std::sync::Arc;
+
+use domain::api_token::ApiToken;
+use domain::errors::DomainError;
+use domain::ports::{ApiTokenCommandPort, ApiTokenQueryPort, ApiTokenSecretPort};
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub query: Arc<dyn ApiTokenQueryPort>,
+    pub command: Arc<dyn ApiTokenCommandPort>,
+    pub secrets: Arc<dyn ApiTokenSecretPort>,
+}
+
+#[tracing::instrument(skip(secret, deps))]
+pub async fn execute(secret: &str, deps: &Deps) -> Result<ApiToken, ApplicationError> {
+    let digest = deps.secrets.digest(secret);
+
+    let token = deps
+        .query
+        .find_by_digest(&digest)
+        .await?
+        .ok_or_else(|| DomainError::Unauthorized("this api token is not valid".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");
+    }
+
+    Ok(token)
+}
diff --git a/crates/application/src/api_token/use_cases/list_api_tokens.rs b/crates/application/src/api_token/use_cases/list_api_tokens.rs
new file mode 100644
index 0000000..822714a
--- /dev/null
+++ b/crates/application/src/api_token/use_cases/list_api_tokens.rs
@@ -0,0 +1,16 @@
+use std::sync::Arc;
+
+use domain::api_token::ApiToken;
+use domain::ports::ApiTokenQueryPort;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub query: Arc<dyn ApiTokenQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(user_id: UserId, deps: &Deps) -> Result<Vec<ApiToken>, ApplicationError> {
+    Ok(deps.query.find_by_user(&user_id).await?)
+}
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
new file mode 100644
index 0000000..a7fb9cc
--- /dev/null
+++ b/crates/application/src/api_token/use_cases/mint_api_token.rs
@@ -0,0 +1,28 @@
+use std::sync::Arc;
+
+use domain::api_token::{ApiToken, MintedApiToken};
+use domain::ports::{ApiTokenCommandPort, ApiTokenSecretPort};
+
+use crate::api_token::commands::MintApiTokenCommand;
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub command: Arc<dyn ApiTokenCommandPort>,
+    pub secrets: Arc<dyn ApiTokenSecretPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(
+    command: MintApiTokenCommand,
+    deps: &Deps,
+) -> Result<MintedApiToken, ApplicationError> {
+    let secret = deps.secrets.mint();
+    let digest = deps.secrets.digest(&secret);
+
+    let token = ApiToken::new(command.user_id, command.name, digest);
+    deps.command.save(&token).await?;
+
+    tracing::info!(token_id = %token.id(), name = token.name().value(), "minted an api token");
+
+    Ok(MintedApiToken::new(token, secret))
+}
diff --git a/crates/application/src/api_token/use_cases/mod.rs b/crates/application/src/api_token/use_cases/mod.rs
new file mode 100644
index 0000000..efc69d1
--- /dev/null
+++ b/crates/application/src/api_token/use_cases/mod.rs
@@ -0,0 +1,4 @@
+pub mod authenticate_api_token;
+pub mod list_api_tokens;
+pub mod mint_api_token;
+pub mod revoke_api_token;
diff --git a/crates/application/src/api_token/use_cases/revoke_api_token.rs b/crates/application/src/api_token/use_cases/revoke_api_token.rs
new file mode 100644
index 0000000..f91ec56
--- /dev/null
+++ b/crates/application/src/api_token/use_cases/revoke_api_token.rs
@@ -0,0 +1,20 @@
+use std::sync::Arc;
+
+use domain::api_token::ApiTokenId;
+use domain::ports::ApiTokenCommandPort;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub command: Arc<dyn ApiTokenCommandPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(user_id: UserId, id: ApiTokenId, deps: &Deps) -> Result<(), ApplicationError> {
+    deps.command.revoke(&user_id, &id).await?;
+
+    tracing::info!(%user_id, token_id = %id, "revoked an api token");
+
+    Ok(())
+}
diff --git a/crates/application/src/correlation/mod.rs b/crates/application/src/correlation/mod.rs
new file mode 100644
index 0000000..5a46417
--- /dev/null
+++ b/crates/application/src/correlation/mod.rs
@@ -0,0 +1,2 @@
+pub mod queries;
+pub mod use_cases;
diff --git a/crates/application/src/correlation/queries.rs b/crates/application/src/correlation/queries.rs
new file mode 100644
index 0000000..526afac
--- /dev/null
+++ b/crates/application/src/correlation/queries.rs
@@ -0,0 +1,10 @@
+use domain::entry::DateSpan;
+use domain::user::UserId;
+
+#[derive(Debug)]
+pub struct CorrelationQuery {
+    pub user_id: UserId,
+    pub span: DateSpan,
+    pub minimum_sample_size: usize,
+    pub false_discovery_rate: f64,
+}
diff --git a/crates/application/src/correlation/use_cases/get_correlations.rs b/crates/application/src/correlation/use_cases/get_correlations.rs
new file mode 100644
index 0000000..84a329e
--- /dev/null
+++ b/crates/application/src/correlation/use_cases/get_correlations.rs
@@ -0,0 +1,340 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::sync::Arc;
+
+use domain::activity::ActivityId;
+use domain::correlation::{
+    Adjustment, Agreement, Coefficient, CorrelationInput, CorrelationStrategy, Observation, PValue,
+    Tested,
+};
+use domain::entry::{Date, DayMood};
+use domain::metric::MetricKind;
+use domain::moon::MoonPhase;
+use domain::ports::{
+    ActivityQueryPort, CycleStartQueryPort, DailyMetricQueryPort, MoodEntryQueryPort,
+    UserPreferencesQueryPort, UserQueryPort,
+};
+use domain::user::{Timezone, UserId};
+
+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::errors::ApplicationError;
+use crate::user::preferences::preferences_of;
+
+const PRESENT: f64 = 1.0;
+const ABSENT: f64 = 0.0;
+
+pub struct Score {
+    pub strategy: CorrelationStrategy,
+    pub coefficient: Coefficient,
+    pub held_up: bool,
+}
+
+pub struct CorrelationRow {
+    pub input: CorrelationInput,
+    pub label: Option<String>,
+    pub sample_size: usize,
+    pub scores: Vec<Score>,
+    pub agreement: Agreement,
+}
+
+pub struct Deps {
+    pub entries: Arc<dyn MoodEntryQueryPort>,
+    pub metrics: Arc<dyn DailyMetricQueryPort>,
+    pub activities: Arc<dyn ActivityQueryPort>,
+    pub cycles: Arc<dyn CycleStartQueryPort>,
+    pub weather_store: Arc<dyn domain::ports::EntryDimensionPort>,
+    pub preferences: Arc<dyn UserPreferencesQueryPort>,
+    pub users: Arc<dyn UserQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(
+    query: CorrelationQuery,
+    deps: &Deps,
+) -> Result<Vec<CorrelationRow>, ApplicationError> {
+    let timezone = timezone_for(&query.user_id, &deps.users).await?;
+
+    let entries = deps
+        .entries
+        .find_by_date_range(&query.user_id, &instants_of(&query.span))
+        .await?;
+
+    let mut moods = day_moods(&entries, &timezone);
+    moods.retain(|date, _| query.span.contains(date));
+
+    let mut scored = metric_rows(&query, deps, &moods).await?;
+
+    let lunar = paired(&moods, |date| Some(MoonPhase::on(date).illumination()));
+    scored.push(row(
+        CorrelationInput::MoonPhase,
+        None,
+        &lunar,
+        query.minimum_sample_size,
+    ));
+
+    if let Some(cycle) = cycle_row(&query, deps, &moods).await? {
+        scored.push(cycle);
+    }
+
+    scored.push(temperature_row(&query, deps, &moods, &timezone).await?);
+
+    scored.extend(activity_rows(&query, deps, &moods, &timezone).await?);
+
+    Ok(mark_what_holds_up(scored, query.false_discovery_rate))
+}
+
+async fn metric_rows(
+    query: &CorrelationQuery,
+    deps: &Deps,
+    moods: &BTreeMap<Date, DayMood>,
+) -> Result<Vec<Pending>, ApplicationError> {
+    let metrics = deps
+        .metrics
+        .find_by_span(&query.user_id, &query.span)
+        .await?;
+
+    let mut by_kind: BTreeMap<MetricKind, BTreeMap<Date, f64>> = BTreeMap::new();
+    for metric in metrics {
+        by_kind
+            .entry(metric.kind())
+            .or_default()
+            .insert(*metric.date(), metric.value().count() as f64);
+    }
+
+    Ok(MetricKind::ALL
+        .into_iter()
+        .map(|kind| {
+            let values = by_kind.remove(&kind).unwrap_or_default();
+            let observations = paired(moods, |date| values.get(date).copied());
+
+            row(
+                CorrelationInput::Metric(kind),
+                None,
+                &observations,
+                query.minimum_sample_size,
+            )
+        })
+        .collect())
+}
+
+async fn cycle_row(
+    query: &CorrelationQuery,
+    deps: &Deps,
+    moods: &BTreeMap<Date, DayMood>,
+) -> Result<Option<Pending>, ApplicationError> {
+    let preferences = preferences_of(&query.user_id, &deps.preferences).await?;
+
+    if !preferences.tracks_cycle() {
+        return Ok(None);
+    }
+
+    let calendar = calendar_of(&query.user_id, &deps.cycles).await?;
+    let observations = paired(moods, |date| {
+        calendar
+            .position_on(date)
+            .map(|position| position.progress())
+    });
+
+    Ok(Some(row(
+        CorrelationInput::CycleProgress,
+        None,
+        &observations,
+        query.minimum_sample_size,
+    )))
+}
+
+async fn temperature_row(
+    query: &CorrelationQuery,
+    deps: &Deps,
+    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(),
+            );
+        }
+    }
+
+    let observations = paired(moods, |date| warmest.get(date).copied());
+
+    Ok(row(
+        CorrelationInput::Temperature,
+        None,
+        &observations,
+        query.minimum_sample_size,
+    ))
+}
+
+async fn activity_rows(
+    query: &CorrelationQuery,
+    deps: &Deps,
+    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());
+
+    for activity in catalog {
+        let days = days_tagged_with(&query.user_id, activity.id(), deps, timezone).await?;
+
+        if never_logged(&days, moods) {
+            continue;
+        }
+
+        let observations = paired(moods, |date| {
+            Some(if days.contains(date) { PRESENT } else { ABSENT })
+        });
+
+        rows.push(row(
+            CorrelationInput::Activity(activity.id().clone()),
+            Some(activity.name().value().to_string()),
+            &observations,
+            query.minimum_sample_size,
+        ));
+    }
+
+    Ok(rows)
+}
+
+fn never_logged(days: &BTreeSet<Date>, moods: &BTreeMap<Date, DayMood>) -> bool {
+    !days.iter().any(|date| moods.contains_key(date))
+}
+
+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 paired(
+    moods: &BTreeMap<Date, DayMood>,
+    value_on: impl Fn(&Date) -> Option<f64>,
+) -> Vec<Observation> {
+    moods
+        .iter()
+        .filter_map(|(date, mood)| value_on(date).map(|value| Observation::new(value, *mood)))
+        .collect()
+}
+
+struct Pending {
+    row: CorrelationRow,
+    significance: Vec<Option<PValue>>,
+}
+
+fn mark_what_holds_up(pending: Vec<Pending>, false_discovery_rate: f64) -> Vec<CorrelationRow> {
+    let mut pending = pending;
+    let places = scored_places(&pending);
+
+    let tested: Vec<Tested> = places
+        .iter()
+        .map(|(row_index, score_index)| {
+            let entry = &pending[*row_index];
+
+            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"),
+            }
+        })
+        .collect();
+
+    let adjustment = Adjustment::controlling_false_discovery_at(false_discovery_rate);
+
+    for (place, holds) in places.iter().zip(adjustment.holds_up_across(&tested)) {
+        pending[place.0].row.scores[place.1].held_up = holds;
+    }
+
+    pending.into_iter().map(|entry| entry.row).collect()
+}
+
+fn scored_places(pending: &[Pending]) -> Vec<(usize, usize)> {
+    pending
+        .iter()
+        .enumerate()
+        .flat_map(|(row_index, entry)| {
+            entry
+                .significance
+                .iter()
+                .enumerate()
+                .filter(|(_, p_value)| p_value.is_some())
+                .map(move |(score_index, _)| (row_index, score_index))
+        })
+        .collect()
+}
+
+fn row(
+    input: CorrelationInput,
+    label: Option<String>,
+    observations: &[Observation],
+    minimum_sample_size: usize,
+) -> Pending {
+    let sample_size = observations.len();
+    let applicable = CorrelationStrategy::ALL
+        .into_iter()
+        .filter(|strategy| strategy.can_score(&input))
+        .count();
+
+    let (scores, significance) = if sample_size < minimum_sample_size {
+        (Vec::new(), Vec::new())
+    } else {
+        scored(&input, observations)
+    };
+
+    let coefficients: Vec<Coefficient> = scores.iter().map(|score| score.coefficient).collect();
+
+    Pending {
+        row: CorrelationRow {
+            input,
+            label,
+            sample_size,
+            agreement: Agreement::of(&coefficients, applicable),
+            scores,
+        },
+        significance,
+    }
+}
+
+fn scored(
+    input: &CorrelationInput,
+    observations: &[Observation],
+) -> (Vec<Score>, Vec<Option<PValue>>) {
+    CorrelationStrategy::ALL
+        .into_iter()
+        .filter(|strategy| strategy.can_score(input))
+        .filter_map(|strategy| {
+            let coefficient = strategy.score(observations)?;
+
+            Some((
+                Score {
+                    strategy,
+                    coefficient,
+                    held_up: false,
+                },
+                strategy.significance(observations),
+            ))
+        })
+        .unzip()
+}
diff --git a/crates/application/src/correlation/use_cases/mod.rs b/crates/application/src/correlation/use_cases/mod.rs
new file mode 100644
index 0000000..fa8d26e
--- /dev/null
+++ b/crates/application/src/correlation/use_cases/mod.rs
@@ -0,0 +1 @@
+pub mod get_correlations;
diff --git a/crates/application/src/cycle/mod.rs b/crates/application/src/cycle/mod.rs
new file mode 100644
index 0000000..d07542b
--- /dev/null
+++ b/crates/application/src/cycle/mod.rs
@@ -0,0 +1 @@
+pub mod use_cases;
diff --git a/crates/application/src/cycle/use_cases/forget_cycle_start.rs b/crates/application/src/cycle/use_cases/forget_cycle_start.rs
new file mode 100644
index 0000000..a9ba957
--- /dev/null
+++ b/crates/application/src/cycle/use_cases/forget_cycle_start.rs
@@ -0,0 +1,18 @@
+use std::sync::Arc;
+
+use domain::entry::Date;
+use domain::ports::CycleStartCommandPort;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub command: Arc<dyn CycleStartCommandPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(user_id: UserId, date: Date, deps: &Deps) -> Result<(), ApplicationError> {
+    deps.command.forget(&user_id, &date).await?;
+
+    Ok(())
+}
diff --git a/crates/application/src/cycle/use_cases/mod.rs b/crates/application/src/cycle/use_cases/mod.rs
new file mode 100644
index 0000000..c13b12c
--- /dev/null
+++ b/crates/application/src/cycle/use_cases/mod.rs
@@ -0,0 +1,3 @@
+pub mod forget_cycle_start;
+pub mod read_cycle;
+pub mod record_cycle_start;
diff --git a/crates/application/src/cycle/use_cases/read_cycle.rs b/crates/application/src/cycle/use_cases/read_cycle.rs
new file mode 100644
index 0000000..91bb5e8
--- /dev/null
+++ b/crates/application/src/cycle/use_cases/read_cycle.rs
@@ -0,0 +1,55 @@
+use std::sync::Arc;
+
+use domain::cycle::{CycleCalendar, CyclePosition};
+use domain::entry::Date;
+use domain::ports::{CycleStartQueryPort, UserPreferencesQueryPort, UserQueryPort};
+use domain::user::UserId;
+
+use crate::day::{timezone_for, today_in};
+use crate::errors::ApplicationError;
+use crate::user::preferences::preferences_of;
+
+pub struct CycleView {
+    pub tracking: bool,
+    pub starts: Vec<Date>,
+    pub today: Option<CyclePosition>,
+    pub usual_length: i64,
+}
+
+pub struct Deps {
+    pub query: Arc<dyn CycleStartQueryPort>,
+    pub preferences: Arc<dyn UserPreferencesQueryPort>,
+    pub users: Arc<dyn UserQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(user_id: UserId, deps: &Deps) -> Result<CycleView, ApplicationError> {
+    let preferences = preferences_of(&user_id, &deps.preferences).await?;
+
+    if !preferences.tracks_cycle() {
+        return Ok(CycleView {
+            tracking: false,
+            starts: Vec::new(),
+            today: None,
+            usual_length: 0,
+        });
+    }
+
+    let calendar = calendar_of(&user_id, &deps.query).await?;
+    let timezone = timezone_for(&user_id, &deps.users).await?;
+    let today = calendar.position_on(&today_in(&timezone));
+
+    Ok(CycleView {
+        tracking: true,
+        starts: calendar.starts().to_vec(),
+        today,
+        usual_length: calendar.usual_length(),
+    })
+}
+
+pub async fn calendar_of(
+    user_id: &UserId,
+    query: &Arc<dyn CycleStartQueryPort>,
+) -> Result<CycleCalendar, ApplicationError> {
+    Ok(CycleCalendar::new(query.find_by_user(user_id).await?))
+}
diff --git a/crates/application/src/cycle/use_cases/record_cycle_start.rs b/crates/application/src/cycle/use_cases/record_cycle_start.rs
new file mode 100644
index 0000000..8765123
--- /dev/null
+++ b/crates/application/src/cycle/use_cases/record_cycle_start.rs
@@ -0,0 +1,28 @@
+use std::sync::Arc;
+
+use domain::entry::Date;
+use domain::ports::{CycleStartCommandPort, UserPreferencesQueryPort};
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+use crate::user::preferences::preferences_of;
+
+pub struct Deps {
+    pub command: Arc<dyn CycleStartCommandPort>,
+    pub preferences: Arc<dyn UserPreferencesQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(user_id: UserId, date: Date, deps: &Deps) -> Result<(), ApplicationError> {
+    let preferences = preferences_of(&user_id, &deps.preferences).await?;
+
+    if !preferences.tracks_cycle() {
+        return Err(ApplicationError::Validation(
+            "cycle tracking is off for this account: turn it on in settings first".into(),
+        ));
+    }
+
+    deps.command.record(&user_id, &date).await?;
+
+    Ok(())
+}
diff --git a/crates/application/src/day.rs b/crates/application/src/day.rs
new file mode 100644
index 0000000..1ee2b96
--- /dev/null
+++ b/crates/application/src/day.rs
@@ -0,0 +1,69 @@
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use chrono::{DateTime, FixedOffset, NaiveTime, Utc};
+
+use domain::entry::{Date, DateRange, DateSpan, DayMood, MoodEntry};
+use domain::errors::DomainError;
+use domain::ports::UserQueryPort;
+use domain::user::{Timezone, UserId};
+
+use crate::errors::ApplicationError;
+
+pub async fn timezone_for(
+    user_id: &UserId,
+    users: &Arc<dyn UserQueryPort>,
+) -> Result<Timezone, ApplicationError> {
+    let user = users
+        .find_by_id(user_id)
+        .await?
+        .ok_or_else(|| DomainError::NotFound("user not found".into()))?;
+
+    user.timezone().copied().ok_or_else(|| {
+        DomainError::InvalidInput(
+            "this account has no timezone set, so days cannot be resolved: set one in settings"
+                .into(),
+        )
+        .into()
+    })
+}
+
+pub fn today_in(timezone: &Timezone) -> Date {
+    Date::from_instant(&Utc::now().fixed_offset(), timezone)
+}
+
+pub fn date_of(entry: &MoodEntry, timezone: &Timezone) -> Date {
+    Date::from_instant(entry.logged_at(), timezone)
+}
+
+pub fn day_moods(entries: &[MoodEntry], timezone: &Timezone) -> BTreeMap<Date, DayMood> {
+    let mut moods: BTreeMap<Date, Vec<domain::entry::Mood>> = BTreeMap::new();
+
+    for entry in entries {
+        moods
+            .entry(date_of(entry, timezone))
+            .or_default()
+            .push(entry.mood());
+    }
+
+    moods
+        .into_iter()
+        .filter_map(|(date, moods)| DayMood::of(&moods).map(|mood| (date, mood)))
+        .collect()
+}
+
+pub fn instants_of(span: &DateSpan) -> DateRange {
+    let from = midnight_utc(&span.start().previous());
+    let to = midnight_utc(&span.end().next());
+
+    DateRange::new(from, to).unwrap_or_else(|_| {
+        DateRange::new(from, from).expect("a range of one instant is always valid")
+    })
+}
+
+fn midnight_utc(date: &Date) -> DateTime<FixedOffset> {
+    date.value()
+        .and_time(NaiveTime::MIN)
+        .and_utc()
+        .fixed_offset()
+}
diff --git a/crates/application/src/entry/commands.rs b/crates/application/src/entry/commands.rs
index 9ac2d4e..8ec4a62 100644
--- a/crates/application/src/entry/commands.rs
+++ b/crates/application/src/entry/commands.rs
@@ -1,8 +1,7 @@
 use chrono::{DateTime, FixedOffset};
 
-use domain::activity::ActivityId;
-use domain::attachment::{PhotoId, VoiceMemoId};
-use domain::entry::{Content, Mood, MoodEntryId};
+use domain::dimension::DimensionValue;
+use domain::entry::{Mood, MoodEntryId};
 use domain::user::UserId;
 
 #[derive(Debug)]
@@ -10,19 +9,13 @@ pub struct CreateEntryCommand {
     pub user_id: UserId,
     pub mood: Mood,
     pub logged_at: DateTime<FixedOffset>,
-    pub activities: Vec<ActivityId>,
-    pub content: Option<Content>,
-    pub photos: Vec<PhotoId>,
-    pub voice_memos: Vec<VoiceMemoId>,
+    pub dimensions: Vec<DimensionValue>,
 }
 
 #[derive(Debug)]
 pub struct UpdateEntryCommand {
     pub entry_id: MoodEntryId,
     pub mood: Mood,
-    pub logged_at: DateTime<FixedOffset>,
-    pub activities: Vec<ActivityId>,
-    pub content: Option<Content>,
-    pub photos: Vec<PhotoId>,
-    pub voice_memos: Vec<VoiceMemoId>,
+    pub logged_at: Option<DateTime<FixedOffset>>,
+    pub dimensions: Vec<DimensionValue>,
 }
diff --git a/crates/application/src/entry/composition.rs b/crates/application/src/entry/composition.rs
new file mode 100644
index 0000000..86464f9
--- /dev/null
+++ b/crates/application/src/entry/composition.rs
@@ -0,0 +1,44 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use domain::dimension::{ComposedEntry, DimensionValue};
+use domain::entry::{MoodEntry, MoodEntryId};
+use domain::ports::EntryDimensionPort;
+
+use crate::errors::ApplicationError;
+
+pub struct EntryComposer {
+    dimensions: Vec<Arc<dyn EntryDimensionPort>>,
+}
+
+impl EntryComposer {
+    pub fn new(dimensions: Vec<Arc<dyn EntryDimensionPort>>) -> Self {
+        Self { dimensions }
+    }
+}
+
+impl EntryComposer {
+    pub async fn compose(
+        &self,
+        entries: Vec<MoodEntry>,
+    ) -> Result<Vec<ComposedEntry>, ApplicationError> {
+        let entry_ids: Vec<MoodEntryId> = entries.iter().map(|e| e.id().clone()).collect();
+
+        let mut loaded: Vec<HashMap<MoodEntryId, DimensionValue>> =
+            Vec::with_capacity(self.dimensions.len());
+        for port in &self.dimensions {
+            loaded.push(port.load(&entry_ids).await?);
+        }
+
+        Ok(entries
+            .into_iter()
+            .map(|entry| {
+                let dimensions = loaded
+                    .iter()
+                    .filter_map(|by_entry| by_entry.get(entry.id()).cloned())
+                    .collect();
+                ComposedEntry { entry, dimensions }
+            })
+            .collect())
+    }
+}
diff --git a/crates/application/src/entry/mod.rs b/crates/application/src/entry/mod.rs
index 94236ed..ae5c46e 100644
--- a/crates/application/src/entry/mod.rs
+++ b/crates/application/src/entry/mod.rs
@@ -1,3 +1,4 @@
 pub mod commands;
+pub mod composition;
 pub mod queries;
 pub mod use_cases;
diff --git a/crates/application/src/entry/use_cases/create_entry.rs b/crates/application/src/entry/use_cases/create_entry.rs
index fd04fed..4117eae 100644
--- a/crates/application/src/entry/use_cases/create_entry.rs
+++ b/crates/application/src/entry/use_cases/create_entry.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use domain::entry::MoodEntry;
 use domain::events::{DomainEvent, EventEnvelope};
-use domain::ports::{EventPublisherPort, MoodEntryCommandPort};
+use domain::ports::{EntryDimensionPort, EventPublisherPort, MoodEntryCommandPort};
 
 use crate::errors::ApplicationError;
 
@@ -10,19 +10,18 @@ use super::super::commands::CreateEntryCommand;
 
 pub struct Deps {
     pub entries: Arc<dyn MoodEntryCommandPort>,
+    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
     pub events: Arc<dyn EventPublisherPort>,
 }
 
 #[tracing::instrument(skip(deps))]
 pub async fn execute(cmd: CreateEntryCommand, deps: &Deps) -> Result<MoodEntry, ApplicationError> {
-    let mut entry = MoodEntry::new(cmd.user_id, cmd.mood, cmd.logged_at);
-
-    entry.set_content(cmd.content);
-    entry.set_activities(cmd.activities);
-    entry.set_photos(cmd.photos);
-    entry.set_voice_memos(cmd.voice_memos);
+    let entry = MoodEntry::new(cmd.user_id, cmd.mood, cmd.logged_at);
 
     deps.entries.save(&entry).await?;
+    for port in &deps.dimensions {
+        port.save(entry.id(), &cmd.dimensions).await?;
+    }
 
     let event = DomainEvent::EntryCreated {
         entry_id: entry.id().clone(),
diff --git a/crates/application/src/entry/use_cases/delete_entries_by_date_range.rs b/crates/application/src/entry/use_cases/delete_entries_by_date_range.rs
index f8ddc5e..38d77ee 100644
--- a/crates/application/src/entry/use_cases/delete_entries_by_date_range.rs
+++ b/crates/application/src/entry/use_cases/delete_entries_by_date_range.rs
@@ -1,13 +1,18 @@
 use std::sync::Arc;
 
+use domain::dimension::ComposedEntry;
 use domain::entry::DateRange;
-use domain::ports::{CascadeDeletePort, MediaStoragePort};
+use domain::ports::{CascadeDeletePort, EntryDimensionPort, MediaStoragePort, MoodEntryQueryPort};
 use domain::user::UserId;
 
+use crate::entry::composition::EntryComposer;
 use crate::errors::ApplicationError;
+use crate::media::cleanup::delete_media_for;
 
 pub struct Deps {
     pub cascade: Arc<dyn CascadeDeletePort>,
+    pub query: Arc<dyn MoodEntryQueryPort>,
+    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
     pub media_storage: Arc<dyn MediaStoragePort>,
 }
 
@@ -17,23 +22,26 @@ pub async fn execute(
     range: &DateRange,
     deps: &Deps,
 ) -> Result<u64, ApplicationError> {
-    let entries = deps
+    let media = media_of_entries_about_to_be_deleted(&user_id, range, deps).await?;
+
+    let deleted = deps
         .cascade
         .delete_entries_in_range(&user_id, range)
         .await?;
 
-    for entry in &entries {
-        for photo_id in entry.photos() {
-            if let Err(e) = deps.media_storage.delete_photo(photo_id).await {
-                tracing::warn!(%e, "failed to delete photo blob");
-            }
-        }
-        for memo_id in entry.voice_memos() {
-            if let Err(e) = deps.media_storage.delete_voice_memo(memo_id).await {
-                tracing::warn!(%e, "failed to delete voice memo blob");
-            }
-        }
-    }
+    delete_media_for(&media, &deps.media_storage).await;
 
-    Ok(entries.len() as u64)
+    Ok(deleted.len() as u64)
+}
+
+async fn media_of_entries_about_to_be_deleted(
+    user_id: &UserId,
+    range: &DateRange,
+    deps: &Deps,
+) -> Result<Vec<ComposedEntry>, ApplicationError> {
+    let doomed = deps.query.find_by_date_range(user_id, range).await?;
+
+    EntryComposer::new(deps.dimensions.clone())
+        .compose(doomed)
+        .await
 }
diff --git a/crates/application/src/entry/use_cases/delete_entry.rs b/crates/application/src/entry/use_cases/delete_entry.rs
index cf96c59..6a8b185 100644
--- a/crates/application/src/entry/use_cases/delete_entry.rs
+++ b/crates/application/src/entry/use_cases/delete_entry.rs
@@ -4,16 +4,20 @@ use domain::entry::MoodEntryId;
 use domain::errors::DomainError;
 use domain::events::{DomainEvent, EventEnvelope};
 use domain::ports::{
-    EventPublisherPort, MediaStoragePort, MoodEntryCommandPort, MoodEntryQueryPort,
+    EntryDimensionPort, EventPublisherPort, MediaStoragePort, MoodEntryCommandPort,
+    MoodEntryQueryPort,
 };
 use domain::user::UserId;
 
 use crate::authorization::verify_ownership;
+use crate::entry::composition::EntryComposer;
 use crate::errors::ApplicationError;
+use crate::media::cleanup::delete_media_for;
 
 pub struct Deps {
     pub command: Arc<dyn MoodEntryCommandPort>,
     pub query: Arc<dyn MoodEntryQueryPort>,
+    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
     pub events: Arc<dyn EventPublisherPort>,
     pub media_storage: Arc<dyn MediaStoragePort>,
 }
@@ -32,23 +36,15 @@ pub async fn execute(
 
     verify_ownership(entry.user_id(), &caller_id)?;
 
-    for photo_id in entry.photos() {
-        if let Err(e) = deps.media_storage.delete_photo(photo_id).await {
-            tracing::warn!(%e, "failed to delete photo blob");
-        }
-    }
-    for memo_id in entry.voice_memos() {
-        if let Err(e) = deps.media_storage.delete_voice_memo(memo_id).await {
-            tracing::warn!(%e, "failed to delete voice memo blob");
-        }
-    }
+    let user_id = entry.user_id().clone();
+    let composed = EntryComposer::new(deps.dimensions.clone())
+        .compose(vec![entry])
+        .await?;
+    delete_media_for(&composed, &deps.media_storage).await;
 
     deps.command.delete(&entry_id).await?;
 
-    let event = DomainEvent::EntryDeleted {
-        entry_id,
-        user_id: entry.user_id().clone(),
-    };
+    let event = DomainEvent::EntryDeleted { entry_id, user_id };
     deps.events.publish(EventEnvelope::wrap(event)).await?;
 
     Ok(())
diff --git a/crates/application/src/entry/use_cases/get_activity_correlation.rs b/crates/application/src/entry/use_cases/get_activity_correlation.rs
deleted file mode 100644
index c18cfc3..0000000
--- a/crates/application/src/entry/use_cases/get_activity_correlation.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use std::sync::Arc;
-
-use domain::activity::ActivityId;
-use domain::entry::DateRange;
-use domain::ports::MoodEntryQueryPort;
-use domain::services::MoodAnalyzerService;
-use domain::user::UserId;
-
-use crate::errors::ApplicationError;
-
-pub struct Deps {
-    pub query: Arc<dyn MoodEntryQueryPort>,
-}
-
-#[tracing::instrument(skip(deps))]
-pub async fn execute(
-    user_id: UserId,
-    activity_id: ActivityId,
-    range: Option<DateRange>,
-    deps: &Deps,
-) -> Result<Option<f64>, ApplicationError> {
-    let entries = match range {
-        Some(range) => deps.query.find_by_date_range(&user_id, &range).await?,
-        None => deps.query.find_by_user(&user_id, None, None).await?,
-    };
-
-    Ok(MoodAnalyzerService::activity_mood_correlation(
-        &entries,
-        &activity_id,
-    ))
-}
diff --git a/crates/application/src/entry/use_cases/get_calendar.rs b/crates/application/src/entry/use_cases/get_calendar.rs
index 7b70c32..ed820e9 100644
--- a/crates/application/src/entry/use_cases/get_calendar.rs
+++ b/crates/application/src/entry/use_cases/get_calendar.rs
@@ -1,22 +1,34 @@
 use std::collections::BTreeMap;
 use std::sync::Arc;
 
-use chrono::NaiveDate;
-
-use domain::entry::{DateRange, Mood, MoodEntry};
-use domain::ports::MoodEntryQueryPort;
+use domain::cycle::CycleDay;
+use domain::dimension::ComposedEntry;
+use domain::entry::{Date, DateRange, DayMood};
+use domain::ports::{
+    CycleStartQueryPort, EntryDimensionPort, MoodEntryQueryPort, UserPreferencesQueryPort,
+    UserQueryPort,
+};
 use domain::user::UserId;
 
+use crate::cycle::use_cases::read_cycle::calendar_of;
+use crate::day::{date_of, timezone_for};
+use crate::entry::composition::EntryComposer;
 use crate::errors::ApplicationError;
+use crate::user::preferences::preferences_of;
 
 pub struct CalendarDay {
-    pub date: NaiveDate,
-    pub entries: Vec<MoodEntry>,
-    pub dominant_mood: Option<Mood>,
+    pub date: Date,
+    pub entries: Vec<ComposedEntry>,
+    pub day_mood: Option<DayMood>,
+    pub cycle_day: Option<CycleDay>,
 }
 
 pub struct Deps {
     pub query: Arc<dyn MoodEntryQueryPort>,
+    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
+    pub cycles: Arc<dyn CycleStartQueryPort>,
+    pub preferences: Arc<dyn UserPreferencesQueryPort>,
+    pub users: Arc<dyn UserQueryPort>,
 }
 
 #[tracing::instrument(skip(deps))]
@@ -26,21 +38,34 @@ pub async fn execute(
     deps: &Deps,
 ) -> Result<Vec<CalendarDay>, ApplicationError> {
     let entries = deps.query.find_by_date_range(&user_id, &range).await?;
+    let entries = EntryComposer::new(deps.dimensions.clone())
+        .compose(entries)
+        .await?;
 
-    let mut by_date: BTreeMap<NaiveDate, Vec<MoodEntry>> = BTreeMap::new();
+    let timezone = timezone_for(&user_id, &deps.users).await?;
+
+    let mut by_date: BTreeMap<Date, Vec<ComposedEntry>> = BTreeMap::new();
     for entry in entries {
-        let date = entry.logged_at().date_naive();
+        let date = date_of(&entry.entry, &timezone);
         by_date.entry(date).or_default().push(entry);
     }
 
+    let cycles = tracked_cycle(&user_id, deps).await?;
+
     let days = by_date
         .into_iter()
         .map(|(date, entries)| {
-            let dominant_mood = find_dominant_mood(&entries);
+            let day_mood = day_mood_of(&entries);
+            let cycle_day = cycles
+                .as_ref()
+                .and_then(|calendar| calendar.position_on(&date))
+                .map(|position| position.day());
+
             CalendarDay {
                 date,
                 entries,
-                dominant_mood,
+                day_mood,
+                cycle_day,
             }
         })
         .collect();
@@ -48,21 +73,21 @@ pub async fn execute(
     Ok(days)
 }
 
-fn find_dominant_mood(entries: &[MoodEntry]) -> Option<Mood> {
-    if entries.is_empty() {
-        return None;
+async fn tracked_cycle(
+    user_id: &domain::user::UserId,
+    deps: &Deps,
+) -> Result<Option<domain::cycle::CycleCalendar>, ApplicationError> {
+    let preferences = preferences_of(user_id, &deps.preferences).await?;
+
+    if !preferences.tracks_cycle() {
+        return Ok(None);
     }
 
-    let mut counts = [0u32; 5];
-    for entry in entries {
-        counts[entry.mood().value() as usize - 1] += 1;
-    }
-
-    let max_index = counts
-        .iter()
-        .enumerate()
-        .max_by_key(|(_, count)| *count)
-        .map(|(i, _)| i)?;
-
-    Mood::try_from(max_index as u8 + 1).ok()
+    Ok(Some(calendar_of(user_id, &deps.cycles).await?))
+}
+
+fn day_mood_of(entries: &[ComposedEntry]) -> Option<DayMood> {
+    let moods: Vec<_> = entries.iter().map(|entry| entry.entry.mood()).collect();
+
+    DayMood::of(&moods)
 }
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 cab027a..a510e5f 100644
--- a/crates/application/src/entry/use_cases/get_mood_stats.rs
+++ b/crates/application/src/entry/use_cases/get_mood_stats.rs
@@ -1,9 +1,10 @@
 use std::sync::Arc;
 
 use domain::entry::Mood;
-use domain::ports::MoodEntryQueryPort;
+use domain::ports::{MoodEntryQueryPort, UserQueryPort};
 use domain::services::MoodAnalyzerService;
 
+use crate::day::{date_of, timezone_for, today_in};
 use crate::errors::ApplicationError;
 
 use super::super::queries::MoodStatsQuery;
@@ -17,6 +18,7 @@ pub struct MoodStats {
 
 pub struct Deps {
     pub query: Arc<dyn MoodEntryQueryPort>,
+    pub users: Arc<dyn UserQueryPort>,
 }
 
 #[tracing::instrument(skip(deps))]
@@ -30,10 +32,16 @@ pub async fn execute(query: MoodStatsQuery, deps: &Deps) -> Result<MoodStats, Ap
         None => deps.query.find_by_user(&query.user_id, None, None).await?,
     };
 
+    let timezone = timezone_for(&query.user_id, &deps.users).await?;
+    let dates: Vec<_> = entries
+        .iter()
+        .map(|entry| date_of(entry, &timezone))
+        .collect();
+
     Ok(MoodStats {
         average: MoodAnalyzerService::average_mood(&entries),
         frequency: MoodAnalyzerService::mood_frequency(&entries),
-        current_streak: MoodAnalyzerService::current_streak(&entries),
+        current_streak: MoodAnalyzerService::current_streak(&dates, today_in(&timezone)),
         total_entries: entries.len(),
     })
 }
diff --git a/crates/application/src/entry/use_cases/mod.rs b/crates/application/src/entry/use_cases/mod.rs
index 53f93a4..cd590a7 100644
--- a/crates/application/src/entry/use_cases/mod.rs
+++ b/crates/application/src/entry/use_cases/mod.rs
@@ -3,7 +3,6 @@ pub mod delete_entries_by_date_range;
 pub mod delete_entry;
 pub mod filter_by_activity;
 pub mod filter_by_mood;
-pub mod get_activity_correlation;
 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 bef0ed4..95dc529 100644
--- a/crates/application/src/entry/use_cases/update_entry.rs
+++ b/crates/application/src/entry/use_cases/update_entry.rs
@@ -1,20 +1,24 @@
 use std::sync::Arc;
 
+use domain::dimension::lookup;
 use domain::entry::MoodEntry;
 use domain::errors::DomainError;
 use domain::events::{DomainEvent, EventEnvelope};
 use domain::ports::{
-    EventPublisherPort, MediaStoragePort, MoodEntryCommandPort, MoodEntryQueryPort,
+    EntryDimensionPort, EventPublisherPort, MediaStoragePort, MoodEntryCommandPort,
+    MoodEntryQueryPort,
 };
 use domain::user::UserId;
 
 use crate::authorization::verify_ownership;
+use crate::entry::composition::EntryComposer;
 use crate::errors::ApplicationError;
 
 use super::super::commands::UpdateEntryCommand;
 
 pub struct Deps {
     pub command: Arc<dyn MoodEntryCommandPort>,
+    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
     pub query: Arc<dyn MoodEntryQueryPort>,
     pub media_storage: Arc<dyn MediaStoragePort>,
     pub events: Arc<dyn EventPublisherPort>,
@@ -34,25 +38,29 @@ pub async fn execute(
 
     verify_ownership(entry.user_id(), &caller_id)?;
 
-    let old_photos = entry.photos().to_vec();
-    let old_memos = entry.voice_memos().to_vec();
+    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();
 
     entry.update_mood(cmd.mood);
-    entry.update_logged_at(cmd.logged_at);
-    entry.set_content(cmd.content);
-    entry.set_activities(cmd.activities);
-    entry.set_photos(cmd.photos);
-    entry.set_voice_memos(cmd.voice_memos);
+    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 !entry.photos().contains(photo_id)
+        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 !entry.voice_memos().contains(memo_id)
+        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");
@@ -60,6 +68,9 @@ pub async fn execute(
     }
 
     deps.command.save(&entry).await?;
+    for port in &deps.dimensions {
+        port.save(entry.id(), &cmd.dimensions).await?;
+    }
 
     let event = DomainEvent::EntryUpdated {
         entry_id: entry.id().clone(),
diff --git a/crates/application/src/export/use_cases/export_user_data.rs b/crates/application/src/export/use_cases/export_user_data.rs
deleted file mode 100644
index 2fc372c..0000000
--- a/crates/application/src/export/use_cases/export_user_data.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use std::sync::Arc;
-
-use domain::ports::{
-    ActivityQueryPort, ExportPort, MediaBlob, MediaStoragePort, MoodEntryQueryPort,
-    ReminderQueryPort, UserExport,
-};
-use domain::user::UserId;
-
-use crate::errors::ApplicationError;
-
-pub struct Deps {
-    pub entry_query: Arc<dyn MoodEntryQueryPort>,
-    pub activity_query: Arc<dyn ActivityQueryPort>,
-    pub reminder_query: Arc<dyn ReminderQueryPort>,
-    pub media_storage: Arc<dyn MediaStoragePort>,
-    pub exporter: Arc<dyn ExportPort>,
-}
-
-#[tracing::instrument(skip(deps))]
-pub async fn execute(user_id: UserId, deps: &Deps) -> Result<Vec<u8>, ApplicationError> {
-    let entries = deps.entry_query.find_by_user(&user_id, None, None).await?;
-    let activities = deps.activity_query.find_by_user(&user_id).await?;
-    let reminders = deps.reminder_query.find_by_user(&user_id).await?;
-
-    let mut photos = Vec::new();
-    let mut voice_memos = 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 {
-                    id: photo_id.value().to_string(),
-                    data: file.data,
-                });
-            }
-        }
-        for voice_memo_id in entry.voice_memos() {
-            if let Some(file) = deps.media_storage.get_voice_memo(voice_memo_id).await? {
-                voice_memos.push(MediaBlob {
-                    id: voice_memo_id.value().to_string(),
-                    data: file.data,
-                });
-            }
-        }
-    }
-
-    tracing::info!(
-        entries = entries.len(),
-        activities = activities.len(),
-        photos = photos.len(),
-        voice_memos = voice_memos.len(),
-        "exporting user data"
-    );
-
-    let export = UserExport {
-        entries,
-        activities,
-        reminders,
-        photos,
-        voice_memos,
-    };
-
-    let data = deps.exporter.export_user_data(&export).await?;
-    Ok(data)
-}
diff --git a/crates/application/src/export/use_cases/mod.rs b/crates/application/src/export/use_cases/mod.rs
index c3af63e..4949260 100644
--- a/crates/application/src/export/use_cases/mod.rs
+++ b/crates/application/src/export/use_cases/mod.rs
@@ -1 +1,2 @@
-pub mod export_user_data;
+pub mod write_backup;
+pub mod write_extract;
diff --git a/crates/application/src/export/use_cases/write_backup.rs b/crates/application/src/export/use_cases/write_backup.rs
new file mode 100644
index 0000000..9f2c680
--- /dev/null
+++ b/crates/application/src/export/use_cases/write_backup.rs
@@ -0,0 +1,108 @@
+use std::sync::Arc;
+
+use domain::cycle::CycleStartRestore;
+use domain::dimension::ComposedEntry;
+use domain::entry::DateSpan;
+use domain::ports::{
+    ActivityQueryPort, BackupMedia, BackupWriterPort, CycleStartQueryPort, DailyMetricQueryPort,
+    EntryDimensionPort, MediaBlob, MediaStoragePort, MoodEntryQueryPort, ReminderQueryPort,
+    UserPreferencesQueryPort,
+};
+use domain::user::UserId;
+
+use crate::entry::composition::EntryComposer;
+use crate::errors::ApplicationError;
+use crate::user::preferences::preferences_of;
+
+pub struct Deps {
+    pub entries: Arc<dyn MoodEntryQueryPort>,
+    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
+    pub activities: Arc<dyn ActivityQueryPort>,
+    pub reminders: Arc<dyn ReminderQueryPort>,
+    pub metrics: Arc<dyn DailyMetricQueryPort>,
+    pub cycles: Arc<dyn CycleStartQueryPort>,
+    pub preferences: Arc<dyn UserPreferencesQueryPort>,
+    pub media_storage: Arc<dyn MediaStoragePort>,
+    pub writer: Arc<dyn BackupWriterPort>,
+}
+
+#[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?)
+        .await?;
+
+    let media = gather_media(&entries, deps).await?;
+
+    let backup = domain::ports::UserBackup {
+        metrics: deps.metrics.find_by_span(&user_id, &everything()).await?,
+        cycle_starts: deps
+            .cycles
+            .find_by_user(&user_id)
+            .await?
+            .into_iter()
+            .map(CycleStartRestore::on)
+            .collect(),
+        activities: deps.activities.find_by_user(&user_id).await?,
+        reminders: deps.reminders.find_by_user(&user_id).await?,
+        preferences: preferences_of(&user_id, &deps.preferences).await?,
+        entries,
+        media,
+    };
+
+    tracing::info!(
+        entries = backup.entries.len(),
+        metrics = backup.metrics.len(),
+        cycle_starts = backup.cycle_starts.len(),
+        activities = backup.activities.len(),
+        reminders = backup.reminders.len(),
+        photos = backup.media.photos.len(),
+        voice_memos = backup.media.voice_memos.len(),
+        "writing a complete backup"
+    );
+
+    Ok(deps.writer.write(&backup).await?)
+}
+
+fn everything() -> DateSpan {
+    let first = domain::entry::Date::from_persistence(
+        chrono::NaiveDate::from_ymd_opt(1970, 1, 1).unwrap_or_default(),
+    );
+    let last = domain::entry::Date::from_persistence(
+        chrono::NaiveDate::from_ymd_opt(9999, 12, 31).unwrap_or_default(),
+    );
+
+    DateSpan::new(first, last).expect("1970 precedes 9999")
+}
+
+async fn gather_media(
+    entries: &[ComposedEntry],
+    deps: &Deps,
+) -> Result<BackupMedia, ApplicationError> {
+    let mut photos = Vec::new();
+    let mut voice_memos = 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 {
+                    id: photo_id.value().to_string(),
+                    data: file.data,
+                });
+            }
+        }
+        for memo_id in entry.voice_memos() {
+            if let Some(file) = deps.media_storage.get_voice_memo(memo_id).await? {
+                voice_memos.push(MediaBlob {
+                    id: memo_id.value().to_string(),
+                    data: file.data,
+                });
+            }
+        }
+    }
+
+    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
new file mode 100644
index 0000000..37d34c9
--- /dev/null
+++ b/crates/application/src/export/use_cases/write_extract.rs
@@ -0,0 +1,35 @@
+use std::sync::Arc;
+
+use domain::ports::{
+    ActivityQueryPort, EntryDimensionPort, ExtractWriterPort, MoodEntryQueryPort, SharedExtract,
+};
+use domain::user::UserId;
+
+use crate::entry::composition::EntryComposer;
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub entries: Arc<dyn MoodEntryQueryPort>,
+    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
+    pub activities: Arc<dyn ActivityQueryPort>,
+    pub writer: Arc<dyn ExtractWriterPort>,
+}
+
+#[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?)
+        .await?;
+
+    let extract = SharedExtract {
+        entries,
+        activities: deps.activities.find_by_user(&user_id).await?,
+    };
+
+    tracing::info!(
+        entries = extract.entries.len(),
+        "writing a shareable extract"
+    );
+
+    Ok(deps.writer.write(&extract).await?)
+}
diff --git a/crates/application/src/import/commands.rs b/crates/application/src/import/commands.rs
index fd8deb6..6385f4c 100644
--- a/crates/application/src/import/commands.rs
+++ b/crates/application/src/import/commands.rs
@@ -1,3 +1,4 @@
+use domain::provider::ProviderName;
 use domain::user::UserId;
 
 #[derive(Debug)]
@@ -5,3 +6,23 @@ pub struct ImportCommand {
     pub user_id: UserId,
     pub data: Vec<u8>,
 }
+
+#[derive(Debug)]
+pub struct ImportedMetric {
+    pub kind: String,
+    pub value: Option<i64>,
+}
+
+#[derive(Debug)]
+pub struct ImportedDay {
+    pub date: String,
+    pub metrics: Vec<ImportedMetric>,
+}
+
+#[derive(Debug)]
+pub struct ImportDailyMetricsCommand {
+    pub user_id: UserId,
+    pub provider: ProviderName,
+    pub days: Vec<ImportedDay>,
+    pub maximum_days: usize,
+}
diff --git a/crates/application/src/import/use_cases/import_daily_metrics.rs b/crates/application/src/import/use_cases/import_daily_metrics.rs
new file mode 100644
index 0000000..ea7edc1
--- /dev/null
+++ b/crates/application/src/import/use_cases/import_daily_metrics.rs
@@ -0,0 +1,150 @@
+use std::sync::Arc;
+
+use domain::entry::Date;
+use domain::metric::{DailyMetric, MetricKind, MetricValue, Source};
+use domain::ports::{DailyMetricCommandPort, RejectionCommandPort};
+use domain::provider::ProviderName;
+use domain::rejection::{RejectedMetric, RejectionDetail, RejectionOrigin};
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+use crate::import::commands::{ImportDailyMetricsCommand, ImportedDay, ImportedMetric};
+
+#[derive(Debug)]
+pub struct RejectionSummary {
+    pub date: Option<String>,
+    pub kind: String,
+    pub reason: String,
+}
+
+#[derive(Debug)]
+pub struct ImportOutcome {
+    pub accepted: usize,
+    pub superseded: usize,
+    pub rejected: Vec<RejectionSummary>,
+}
+
+pub struct Deps {
+    pub metrics: Arc<dyn DailyMetricCommandPort>,
+    pub rejections: Arc<dyn RejectionCommandPort>,
+}
+
+#[tracing::instrument(skip(deps), fields(days = command.days.len()))]
+pub async fn execute(
+    command: ImportDailyMetricsCommand,
+    deps: &Deps,
+) -> Result<ImportOutcome, ApplicationError> {
+    if command.days.len() > command.maximum_days {
+        return Err(ApplicationError::Validation(format!(
+            "an import may carry at most {} days, this one carries {}",
+            command.maximum_days,
+            command.days.len()
+        )));
+    }
+
+    let mut writable = Vec::new();
+    let mut refused = Vec::new();
+
+    for day in &command.days {
+        read_a_day(
+            day,
+            &command.user_id,
+            &command.provider,
+            &mut writable,
+            &mut refused,
+        );
+    }
+
+    let submitted = writable.len();
+    let written = deps.metrics.save(&writable).await?;
+
+    record(&refused, deps).await;
+
+    tracing::info!(
+        accepted = written,
+        superseded = submitted - written,
+        rejected = refused.len(),
+        provider = command.provider.value(),
+        "imported daily metrics"
+    );
+
+    Ok(ImportOutcome {
+        accepted: written,
+        superseded: submitted - written,
+        rejected: refused.iter().map(summarise).collect(),
+    })
+}
+
+fn read_a_day(
+    day: &ImportedDay,
+    user_id: &UserId,
+    provider: &ProviderName,
+    writable: &mut Vec<DailyMetric>,
+    refused: &mut Vec<RejectedMetric>,
+) {
+    let Some(date) = day.date.parse().ok().map(Date::from_persistence) else {
+        for metric in &day.metrics {
+            refused.push(rejection(
+                user_id,
+                RejectionDetail::new(Some(provider.clone()), None, &metric.kind, metric.value),
+                format!("{} is not a date", day.date),
+            ));
+        }
+
+        return;
+    };
+
+    for metric in &day.metrics {
+        match read_a_metric(metric) {
+            Ok(value) => writable.push(DailyMetric::new(
+                user_id.clone(),
+                date,
+                value,
+                Source::Provider(provider.clone()),
+            )),
+            Err(reason) => refused.push(rejection(
+                user_id,
+                RejectionDetail::new(
+                    Some(provider.clone()),
+                    Some(date),
+                    &metric.kind,
+                    metric.value,
+                ),
+                reason,
+            )),
+        }
+    }
+}
+
+fn read_a_metric(metric: &ImportedMetric) -> Result<MetricValue, String> {
+    let kind = MetricKind::from_name(&metric.kind)
+        .ok_or_else(|| format!("unknown metric kind: {}", metric.kind))?;
+
+    let Some(count) = metric.value else {
+        return Err("a provider cannot clear a reading: only the user can".into());
+    };
+
+    MetricValue::of_kind(kind, count).map_err(|error| error.to_string())
+}
+
+fn rejection(user_id: &UserId, detail: RejectionDetail, reason: String) -> RejectedMetric {
+    RejectedMetric::new(user_id.clone(), RejectionOrigin::Import, detail, reason)
+}
+
+fn summarise(rejected: &RejectedMetric) -> RejectionSummary {
+    RejectionSummary {
+        date: rejected.detail().date().map(|date| date.to_string()),
+        kind: rejected.detail().kind().to_string(),
+        reason: rejected.reason().to_string(),
+    }
+}
+
+async fn record(refused: &[RejectedMetric], deps: &Deps) {
+    if refused.is_empty() {
+        return;
+    }
+
+    if let Err(error) = deps.rejections.record(refused).await {
+        tracing::warn!(%error, "could not write to the rejection trace");
+    }
+}
diff --git a/crates/application/src/import/use_cases/import_entries.rs b/crates/application/src/import/use_cases/import_entries.rs
index 7afdf13..7ca3525 100644
--- a/crates/application/src/import/use_cases/import_entries.rs
+++ b/crates/application/src/import/use_cases/import_entries.rs
@@ -5,16 +5,19 @@ use chrono::FixedOffset;
 
 use config::PresetConfig;
 use domain::activity::{ActivityId, ActivityName, CategoryName};
+use domain::dimension::{ComposedEntry, DimensionValue};
 use domain::entry::{Content, Mood, MoodEntry};
 use domain::ports::{
-    ActivityCommandPort, ActivityQueryPort, ImportSourcePort, MoodEntryCommandPort,
-    MoodEntryQueryPort,
+    ActivityCommandPort, ActivityQueryPort, EntryDimensionPort, ImportSourcePort,
+    MoodEntryCommandPort, MoodEntryQueryPort, UserQueryPort,
 };
+use domain::user::Timezone;
 
 use crate::errors::ApplicationError;
 
 use super::super::commands::ImportCommand;
 
+#[derive(Debug)]
 pub struct ImportResult {
     pub imported: u64,
     pub skipped: u64,
@@ -27,6 +30,8 @@ pub struct Deps {
     pub entry_query: Arc<dyn MoodEntryQueryPort>,
     pub activity_command: Arc<dyn ActivityCommandPort>,
     pub activity_query: Arc<dyn ActivityQueryPort>,
+    pub dimensions: Vec<Arc<dyn EntryDimensionPort>>,
+    pub users: Arc<dyn UserQueryPort>,
     pub preset: PresetConfig,
 }
 
@@ -35,6 +40,8 @@ pub async fn execute(cmd: ImportCommand, deps: &Deps) -> Result<ImportResult, Ap
     let rows = deps.source.read_entries(&cmd.data).await?;
     tracing::info!(row_count = rows.len(), "parsed import data");
 
+    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)
@@ -68,6 +75,7 @@ pub async fn execute(cmd: ImportCommand, deps: &Deps) -> Result<ImportResult, Ap
             &mut activity_cache,
             &category_map,
             &existing_keys,
+            &timezone,
             deps,
         )
         .await
@@ -83,7 +91,18 @@ pub async fn execute(cmd: ImportCommand, deps: &Deps) -> Result<ImportResult, Ap
     }
 
     let imported = batch.len() as u64;
-    deps.entry_command.save_batch(&batch).await?;
+
+    let entries: Vec<MoodEntry> = batch
+        .iter()
+        .map(|composed| composed.entry.clone())
+        .collect();
+    deps.entry_command.save_batch(&entries).await?;
+
+    for composed in &batch {
+        for port in &deps.dimensions {
+            port.save(composed.entry.id(), &composed.dimensions).await?;
+        }
+    }
 
     tracing::info!(imported, skipped, "import completed");
 
@@ -100,10 +119,11 @@ async fn build_entry(
     activity_cache: &mut HashMap<String, ActivityId>,
     category_map: &HashMap<String, String>,
     existing_keys: &HashSet<(String, u8)>,
+    timezone: &Timezone,
     deps: &Deps,
-) -> Result<Option<MoodEntry>, ApplicationError> {
+) -> Result<Option<ComposedEntry>, ApplicationError> {
     let mood = Mood::try_from(row.mood)?;
-    let logged_at = parse_datetime(&row.date, &row.time)?;
+    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) {
@@ -117,13 +137,21 @@ async fn build_entry(
         activity_ids.push(id);
     }
 
-    let content = row.note.as_ref().and_then(|n| Content::new(n).ok());
+    let mut dimensions: Vec<DimensionValue> = row
+        .note
+        .as_ref()
+        .and_then(|note| Content::new(note).ok())
+        .map(DimensionValue::Content)
+        .into_iter()
+        .collect();
 
-    let mut entry = MoodEntry::new(user_id.clone(), mood, logged_at);
-    entry.set_activities(activity_ids);
-    entry.set_content(content);
+    if !activity_ids.is_empty() {
+        dimensions.push(DimensionValue::activities(activity_ids));
+    }
 
-    Ok(Some(entry))
+    let entry = MoodEntry::new(user_id.clone(), mood, logged_at);
+
+    Ok(Some(ComposedEntry { entry, dimensions }))
 }
 
 async fn resolve_activity(
@@ -152,16 +180,47 @@ async fn resolve_activity(
     Ok(id)
 }
 
-fn parse_datetime(
+fn the_users_own_wall_clock(
     date: &str,
     time: &str,
+    timezone: &Timezone,
 ) -> Result<chrono::DateTime<FixedOffset>, ApplicationError> {
-    let datetime_str = format!("{date} {time}");
+    let written = format!("{date} {time}");
 
-    let naive = chrono::NaiveDateTime::parse_from_str(&datetime_str, "%Y-%m-%d %I:%M %p")
-        .or_else(|_| chrono::NaiveDateTime::parse_from_str(&datetime_str, "%Y-%m-%d %H:%M"))
-        .map_err(|e| ApplicationError::Validation(format!("invalid date/time: {e}")))?;
+    let wall_clock = chrono::NaiveDateTime::parse_from_str(&written, "%Y-%m-%d %I:%M %p")
+        .or_else(|_| chrono::NaiveDateTime::parse_from_str(&written, "%Y-%m-%d %H:%M"))
+        .map_err(|error| ApplicationError::Validation(format!("invalid date/time: {error}")))?;
 
-    let offset = FixedOffset::east_opt(0).expect("UTC offset is always valid");
-    Ok(naive.and_local_timezone(offset).unwrap())
+    Ok(placed_in(wall_clock, timezone).fixed_offset())
+}
+
+fn placed_in(
+    wall_clock: chrono::NaiveDateTime,
+    timezone: &Timezone,
+) -> chrono::DateTime<chrono_tz::Tz> {
+    use chrono::offset::LocalResult;
+
+    match wall_clock.and_local_timezone(timezone.resolve()) {
+        LocalResult::Single(placed) => placed,
+        LocalResult::Ambiguous(earlier, _) => earlier,
+        LocalResult::None => an_hour_the_clocks_skipped(wall_clock, timezone),
+    }
+}
+
+fn an_hour_the_clocks_skipped(
+    wall_clock: chrono::NaiveDateTime,
+    timezone: &Timezone,
+) -> chrono::DateTime<chrono_tz::Tz> {
+    let after_the_jump = wall_clock + chrono::Duration::hours(1);
+
+    tracing::warn!(
+        wall_clock = %wall_clock,
+        timezone = timezone.value(),
+        "this wall clock time never happened, so the entry lands an hour later"
+    );
+
+    after_the_jump
+        .and_local_timezone(timezone.resolve())
+        .earliest()
+        .unwrap_or_else(|| wall_clock.and_utc().with_timezone(&timezone.resolve()))
 }
diff --git a/crates/application/src/import/use_cases/mod.rs b/crates/application/src/import/use_cases/mod.rs
index a295cd4..4581b39 100644
--- a/crates/application/src/import/use_cases/mod.rs
+++ b/crates/application/src/import/use_cases/mod.rs
@@ -1 +1,2 @@
+pub mod import_daily_metrics;
 pub mod import_entries;
diff --git a/crates/application/src/job/mod.rs b/crates/application/src/job/mod.rs
new file mode 100644
index 0000000..d07542b
--- /dev/null
+++ b/crates/application/src/job/mod.rs
@@ -0,0 +1 @@
+pub mod use_cases;
diff --git a/crates/application/src/job/use_cases/mod.rs b/crates/application/src/job/use_cases/mod.rs
new file mode 100644
index 0000000..5767cf5
--- /dev/null
+++ b/crates/application/src/job/use_cases/mod.rs
@@ -0,0 +1,3 @@
+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
new file mode 100644
index 0000000..849fd56
--- /dev/null
+++ b/crates/application/src/job/use_cases/run_due_jobs.rs
@@ -0,0 +1,170 @@
+use std::sync::Arc;
+
+use domain::dimension::DimensionValue;
+use domain::job::{Job, JobKind, JobSubject};
+use domain::ports::{
+    EntryDimensionPort, JobQueueCommandPort, RecordingBackfillQueryPort, RecordingLookupPort,
+    UnidentifiedSong, UnwatchedPlace, WeatherBacklogQueryPort, WeatherLookupPort,
+};
+
+use crate::errors::ApplicationError;
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct Worked {
+    pub finished: usize,
+    pub failed: usize,
+}
+
+pub struct Deps {
+    pub queue: Arc<dyn JobQueueCommandPort>,
+    pub backfill: Arc<dyn RecordingBackfillQueryPort>,
+    pub recordings: Arc<dyn RecordingLookupPort>,
+    pub places: Arc<dyn WeatherBacklogQueryPort>,
+    pub weather: Option<Arc<dyn WeatherLookupPort>>,
+    pub weather_store: Arc<dyn EntryDimensionPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(
+    most: usize,
+    most_attempts: u32,
+    deps: &Deps,
+) -> Result<Worked, ApplicationError> {
+    let mut claimed = Vec::new();
+
+    for kind in JobKind::ALL {
+        claimed.extend(deps.queue.claim(kind, most).await?);
+    }
+
+    let mut worked = Worked::default();
+
+    for job in claimed {
+        match attempt(&job, deps).await {
+            Ok(()) => {
+                deps.queue.finish(job.id()).await?;
+                worked.finished += 1;
+            }
+            Err(reason) => {
+                give_up_or_retry(&job, &reason, most_attempts, deps).await?;
+                worked.failed += 1;
+            }
+        }
+    }
+
+    Ok(worked)
+}
+
+async fn give_up_or_retry(
+    job: &Job,
+    reason: &str,
+    most_attempts: u32,
+    deps: &Deps,
+) -> Result<(), ApplicationError> {
+    let attempted = job.attempts() + 1;
+
+    if attempted < most_attempts {
+        deps.queue.release(job.id(), reason).await?;
+
+        return Ok(());
+    }
+
+    tracing::warn!(
+        job_id = %job.id(),
+        kind = job.kind().name(),
+        attempts = attempted,
+        reason,
+        "giving up on a job; it stays visible so it can be retried deliberately"
+    );
+
+    deps.queue.exhaust(job.id(), reason).await?;
+
+    Ok(())
+}
+
+async fn attempt(job: &Job, deps: &Deps) -> Result<(), String> {
+    match job.kind() {
+        JobKind::BackfillRecordingIdentity => backfill_recording_identity(job, deps).await,
+        JobKind::ObserveWeather => observe_weather(job, deps).await,
+    }
+}
+
+async fn observe_weather(job: &Job, deps: &Deps) -> Result<(), String> {
+    let JobSubject::Entry(entry_id) = job.subject();
+
+    let Some(lookup) = &deps.weather else {
+        return Err("weather lookups are switched off".into());
+    };
+
+    let waiting = deps
+        .places
+        .find_places_without_weather(usize::MAX)
+        .await
+        .map_err(|error| error.to_string())?;
+
+    let Some(place) = waiting.iter().find(|place| &place.entry_id == entry_id) else {
+        return Ok(());
+    };
+
+    let observed = lookup
+        .observed_at(&place.coordinates, &place.logged_at)
+        .await
+        .map_err(|error| error.to_string())?;
+
+    let Some(weather) = observed else {
+        tracing::debug!(entry_id = %entry_id, "the provider had no weather for this place and time");
+
+        return Ok(());
+    };
+
+    remember_weather(place, weather, deps).await
+}
+
+async fn remember_weather(
+    place: &UnwatchedPlace,
+    weather: domain::weather::Weather,
+    deps: &Deps,
+) -> Result<(), String> {
+    deps.weather_store
+        .save(&place.entry_id, &[DimensionValue::Weather(weather)])
+        .await
+        .map_err(|error| error.to_string())
+}
+
+async fn backfill_recording_identity(job: &Job, deps: &Deps) -> Result<(), String> {
+    let JobSubject::Entry(entry_id) = job.subject();
+
+    let waiting = deps
+        .backfill
+        .find_songs_without_a_recording(usize::MAX)
+        .await
+        .map_err(|error| error.to_string())?;
+
+    let Some(song) = waiting.iter().find(|song| &song.entry_id == entry_id) else {
+        return Ok(());
+    };
+
+    let found = deps
+        .recordings
+        .find_recording(&song.title, &song.artist)
+        .await
+        .map_err(|error| error.to_string())?;
+
+    let Some(recording_id) = found else {
+        tracing::debug!(title = %song.title, "no recording matched this song");
+
+        return Ok(());
+    };
+
+    remember(song, &recording_id, deps).await
+}
+
+async fn remember(
+    song: &UnidentifiedSong,
+    recording_id: &domain::song::RecordingId,
+    deps: &Deps,
+) -> Result<(), String> {
+    deps.backfill
+        .record_identity(&song.entry_id, recording_id)
+        .await
+        .map_err(|error| error.to_string())
+}
diff --git a/crates/application/src/job/use_cases/sweep_recording_backlog.rs b/crates/application/src/job/use_cases/sweep_recording_backlog.rs
new file mode 100644
index 0000000..73e6908
--- /dev/null
+++ b/crates/application/src/job/use_cases/sweep_recording_backlog.rs
@@ -0,0 +1,37 @@
+use std::sync::Arc;
+
+use domain::job::JobKind;
+use domain::ports::{JobQueueCommandPort, RecordingBackfillQueryPort};
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub backlog: Arc<dyn RecordingBackfillQueryPort>,
+    pub queue: Arc<dyn JobQueueCommandPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(most: usize, deps: &Deps) -> Result<usize, ApplicationError> {
+    let stranded = deps.backlog.find_songs_without_a_recording(most).await?;
+    let mut enqueued = 0;
+
+    for song in &stranded {
+        if deps
+            .queue
+            .enqueue(JobKind::BackfillRecordingIdentity, &song.subject())
+            .await?
+        {
+            enqueued += 1;
+        }
+    }
+
+    if enqueued > 0 {
+        tracing::info!(
+            enqueued,
+            found = stranded.len(),
+            "swept songs with no recording identity onto the queue"
+        );
+    }
+
+    Ok(enqueued)
+}
diff --git a/crates/application/src/job/use_cases/sweep_weather_backlog.rs b/crates/application/src/job/use_cases/sweep_weather_backlog.rs
new file mode 100644
index 0000000..d918335
--- /dev/null
+++ b/crates/application/src/job/use_cases/sweep_weather_backlog.rs
@@ -0,0 +1,37 @@
+use std::sync::Arc;
+
+use domain::job::JobKind;
+use domain::ports::{JobQueueCommandPort, WeatherBacklogQueryPort};
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub backlog: Arc<dyn WeatherBacklogQueryPort>,
+    pub queue: Arc<dyn JobQueueCommandPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(most: usize, deps: &Deps) -> Result<usize, ApplicationError> {
+    let stranded = deps.backlog.find_places_without_weather(most).await?;
+    let mut enqueued = 0;
+
+    for place in &stranded {
+        if deps
+            .queue
+            .enqueue(JobKind::ObserveWeather, &place.subject())
+            .await?
+        {
+            enqueued += 1;
+        }
+    }
+
+    if enqueued > 0 {
+        tracing::info!(
+            enqueued,
+            found = stranded.len(),
+            "swept places with no weather onto the queue"
+        );
+    }
+
+    Ok(enqueued)
+}
diff --git a/crates/application/src/lib.rs b/crates/application/src/lib.rs
index 1c10bcc..c128871 100644
--- a/crates/application/src/lib.rs
+++ b/crates/application/src/lib.rs
@@ -1,11 +1,19 @@
 pub mod activity;
+pub mod api_token;
 pub mod auth;
 pub mod authorization;
+pub mod correlation;
+pub mod cycle;
+pub mod day;
 pub mod entry;
 pub mod errors;
 pub mod export;
 pub mod import;
+pub mod job;
 pub mod media;
+pub mod metric;
+pub mod provider;
 pub mod push;
 pub mod reminder;
+pub mod restore;
 pub mod user;
diff --git a/crates/application/src/media/cleanup.rs b/crates/application/src/media/cleanup.rs
new file mode 100644
index 0000000..2e33016
--- /dev/null
+++ b/crates/application/src/media/cleanup.rs
@@ -0,0 +1,19 @@
+use std::sync::Arc;
+
+use domain::dimension::ComposedEntry;
+use domain::ports::MediaStoragePort;
+
+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");
+            }
+        }
+        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");
+            }
+        }
+    }
+}
diff --git a/crates/application/src/media/mod.rs b/crates/application/src/media/mod.rs
index d07542b..f6ac411 100644
--- a/crates/application/src/media/mod.rs
+++ b/crates/application/src/media/mod.rs
@@ -1 +1,2 @@
+pub mod cleanup;
 pub mod use_cases;
diff --git a/crates/application/src/metric/commands.rs b/crates/application/src/metric/commands.rs
new file mode 100644
index 0000000..d49cfec
--- /dev/null
+++ b/crates/application/src/metric/commands.rs
@@ -0,0 +1,26 @@
+use domain::entry::Date;
+use domain::metric::{MetricKind, MetricValue, Source};
+use domain::user::UserId;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MetricChange {
+    Stated(MetricValue),
+    Cleared(MetricKind),
+}
+
+impl MetricChange {
+    pub fn kind(&self) -> MetricKind {
+        match self {
+            Self::Stated(value) => value.kind(),
+            Self::Cleared(kind) => *kind,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SetDailyMetricsCommand {
+    pub user_id: UserId,
+    pub date: Date,
+    pub changes: Vec<MetricChange>,
+    pub source: Source,
+}
diff --git a/crates/application/src/metric/mod.rs b/crates/application/src/metric/mod.rs
new file mode 100644
index 0000000..804f0ee
--- /dev/null
+++ b/crates/application/src/metric/mod.rs
@@ -0,0 +1,2 @@
+pub mod commands;
+pub mod use_cases;
diff --git a/crates/application/src/metric/use_cases/list_daily_metrics.rs b/crates/application/src/metric/use_cases/list_daily_metrics.rs
new file mode 100644
index 0000000..afe3540
--- /dev/null
+++ b/crates/application/src/metric/use_cases/list_daily_metrics.rs
@@ -0,0 +1,21 @@
+use std::sync::Arc;
+
+use domain::entry::DateSpan;
+use domain::metric::DailyMetric;
+use domain::ports::DailyMetricQueryPort;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub metrics: Arc<dyn DailyMetricQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(
+    user_id: UserId,
+    span: DateSpan,
+    deps: &Deps,
+) -> Result<Vec<DailyMetric>, ApplicationError> {
+    Ok(deps.metrics.find_by_span(&user_id, &span).await?)
+}
diff --git a/crates/application/src/metric/use_cases/mod.rs b/crates/application/src/metric/use_cases/mod.rs
new file mode 100644
index 0000000..997b22d
--- /dev/null
+++ b/crates/application/src/metric/use_cases/mod.rs
@@ -0,0 +1,2 @@
+pub mod list_daily_metrics;
+pub mod set_daily_metrics;
diff --git a/crates/application/src/metric/use_cases/set_daily_metrics.rs b/crates/application/src/metric/use_cases/set_daily_metrics.rs
new file mode 100644
index 0000000..4b8e767
--- /dev/null
+++ b/crates/application/src/metric/use_cases/set_daily_metrics.rs
@@ -0,0 +1,101 @@
+use std::sync::Arc;
+
+use domain::metric::{DailyMetric, MetricKind};
+use domain::ports::{DailyMetricCommandPort, UserQueryPort};
+
+use crate::day::{timezone_for, today_in};
+use crate::errors::ApplicationError;
+use crate::metric::commands::{MetricChange, SetDailyMetricsCommand};
+
+pub struct Deps {
+    pub metrics: Arc<dyn DailyMetricCommandPort>,
+    pub users: Arc<dyn UserQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(command: SetDailyMetricsCommand, deps: &Deps) -> Result<(), ApplicationError> {
+    let timezone = timezone_for(&command.user_id, &deps.users).await?;
+
+    if command.date > today_in(&timezone) {
+        return Err(ApplicationError::Validation(format!(
+            "cannot record a metric for {}, which has not happened yet",
+            command.date
+        )));
+    }
+
+    reject_a_kind_named_twice(&command.changes)?;
+    reject_clearing_by_anyone_but_the_user(&command)?;
+
+    let cleared: Vec<MetricKind> = command
+        .changes
+        .iter()
+        .filter_map(|change| match change {
+            MetricChange::Cleared(kind) => Some(*kind),
+            MetricChange::Stated(_) => None,
+        })
+        .collect();
+
+    let stated: Vec<DailyMetric> = command
+        .changes
+        .iter()
+        .filter_map(|change| match change {
+            MetricChange::Stated(value) => Some(DailyMetric::new(
+                command.user_id.clone(),
+                command.date,
+                *value,
+                command.source.clone(),
+            )),
+            MetricChange::Cleared(_) => None,
+        })
+        .collect();
+
+    if !cleared.is_empty() {
+        deps.metrics
+            .delete(&command.user_id, &command.date, &cleared)
+            .await?;
+    }
+
+    if !stated.is_empty() {
+        deps.metrics.save(&stated).await?;
+    }
+
+    Ok(())
+}
+
+fn reject_clearing_by_anyone_but_the_user(
+    command: &SetDailyMetricsCommand,
+) -> Result<(), ApplicationError> {
+    if command.source.is_manual() {
+        return Ok(());
+    }
+
+    let clears = command
+        .changes
+        .iter()
+        .any(|change| matches!(change, MetricChange::Cleared(_)));
+
+    if clears {
+        return Err(ApplicationError::Validation(
+            "a provider cannot clear a reading: only the user can".into(),
+        ));
+    }
+
+    Ok(())
+}
+
+fn reject_a_kind_named_twice(changes: &[MetricChange]) -> Result<(), ApplicationError> {
+    for (position, change) in changes.iter().enumerate() {
+        let named_again = changes[position + 1..]
+            .iter()
+            .any(|later| later.kind() == change.kind());
+
+        if named_again {
+            return Err(ApplicationError::Validation(format!(
+                "{} appears more than once in the same request",
+                change.kind().name()
+            )));
+        }
+    }
+
+    Ok(())
+}
diff --git a/crates/application/src/provider/commands.rs b/crates/application/src/provider/commands.rs
new file mode 100644
index 0000000..fd784e4
--- /dev/null
+++ b/crates/application/src/provider/commands.rs
@@ -0,0 +1,18 @@
+use domain::provider::ProviderName;
+use domain::user::UserId;
+
+pub struct ConnectProviderCommand {
+    pub user_id: UserId,
+    pub provider: ProviderName,
+    pub credential: Vec<u8>,
+}
+
+impl std::fmt::Debug for ConnectProviderCommand {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ConnectProviderCommand")
+            .field("user_id", &self.user_id)
+            .field("provider", &self.provider)
+            .field("credential", &"<redacted>")
+            .finish()
+    }
+}
diff --git a/crates/application/src/provider/mod.rs b/crates/application/src/provider/mod.rs
new file mode 100644
index 0000000..804f0ee
--- /dev/null
+++ b/crates/application/src/provider/mod.rs
@@ -0,0 +1,2 @@
+pub mod commands;
+pub mod use_cases;
diff --git a/crates/application/src/provider/use_cases/connect_provider.rs b/crates/application/src/provider/use_cases/connect_provider.rs
new file mode 100644
index 0000000..486f493
--- /dev/null
+++ b/crates/application/src/provider/use_cases/connect_provider.rs
@@ -0,0 +1,23 @@
+use std::sync::Arc;
+
+use domain::ports::ProviderConnectionCommandPort;
+use domain::provider::{CredentialCipher, ProviderConnection};
+
+use crate::errors::ApplicationError;
+
+use super::super::commands::ConnectProviderCommand;
+
+pub struct Deps {
+    pub command: Arc<dyn ProviderConnectionCommandPort>,
+    pub cipher: Arc<dyn CredentialCipher>,
+}
+
+#[tracing::instrument(skip(deps, cmd), fields(provider = cmd.provider.value()))]
+pub async fn execute(cmd: ConnectProviderCommand, deps: &Deps) -> Result<(), ApplicationError> {
+    let credential = deps.cipher.encrypt(&cmd.credential)?;
+    let connection = ProviderConnection::new(cmd.user_id, cmd.provider, credential);
+
+    deps.command.save(&connection).await?;
+
+    Ok(())
+}
diff --git a/crates/application/src/provider/use_cases/disconnect_provider.rs b/crates/application/src/provider/use_cases/disconnect_provider.rs
new file mode 100644
index 0000000..4cc8a69
--- /dev/null
+++ b/crates/application/src/provider/use_cases/disconnect_provider.rs
@@ -0,0 +1,21 @@
+use std::sync::Arc;
+
+use domain::ports::ProviderConnectionCommandPort;
+use domain::provider::ProviderName;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub command: Arc<dyn ProviderConnectionCommandPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(
+    user_id: UserId,
+    provider: ProviderName,
+    deps: &Deps,
+) -> Result<(), ApplicationError> {
+    deps.command.delete(&user_id, &provider).await?;
+    Ok(())
+}
diff --git a/crates/application/src/provider/use_cases/get_now_playing.rs b/crates/application/src/provider/use_cases/get_now_playing.rs
new file mode 100644
index 0000000..cbedd47
--- /dev/null
+++ b/crates/application/src/provider/use_cases/get_now_playing.rs
@@ -0,0 +1,78 @@
+use std::sync::Arc;
+
+use domain::errors::DomainError;
+use domain::ports::{NowPlayingPort, ProviderConnectionQueryPort, RecordingLookupPort};
+use domain::provider::{CredentialCipher, ProviderName};
+use domain::song::Song;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub struct Deps {
+    pub query: Arc<dyn ProviderConnectionQueryPort>,
+    pub cipher: Arc<dyn CredentialCipher>,
+    pub now_playing: Arc<dyn NowPlayingPort>,
+    pub recordings: Arc<dyn RecordingLookupPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(user_id: UserId, deps: &Deps) -> Result<Option<Song>, ApplicationError> {
+    let provider = ProviderName::new(deps.now_playing.provider())?;
+
+    let connection = deps
+        .query
+        .find_by_user_and_provider(&user_id, &provider)
+        .await?
+        .ok_or_else(|| {
+            DomainError::NotFound(format!("no {} connection for this user", provider.value()))
+        })?;
+
+    let credential = deps.cipher.decrypt(connection.credential())?;
+
+    let asked = deps.now_playing.now_playing(&credential).await;
+
+    let Some(song) = unreachable_is_not_playing(asked, &provider) else {
+        return Ok(None);
+    };
+
+    Ok(Some(enrich(song, deps).await))
+}
+
+fn unreachable_is_not_playing(
+    asked: Result<Option<Song>, DomainError>,
+    provider: &ProviderName,
+) -> Option<Song> {
+    match asked {
+        Ok(playing) => playing,
+        Err(error) => {
+            tracing::warn!(
+                provider = provider.value(),
+                %error,
+                "could not ask what is playing, so nothing is offered"
+            );
+
+            None
+        }
+    }
+}
+
+async fn enrich(song: Song, deps: &Deps) -> Song {
+    if song.recording_id().is_some() {
+        return song;
+    }
+
+    let found = deps
+        .recordings
+        .find_recording(song.title().value(), song.artist().value())
+        .await;
+
+    match found {
+        Ok(Some(recording_id)) => Song::from_persistence(
+            song.title().clone(),
+            song.artist().clone(),
+            song.album().cloned(),
+            Some(recording_id),
+        ),
+        _ => song,
+    }
+}
diff --git a/crates/application/src/provider/use_cases/list_connections.rs b/crates/application/src/provider/use_cases/list_connections.rs
new file mode 100644
index 0000000..7070caf
--- /dev/null
+++ b/crates/application/src/provider/use_cases/list_connections.rs
@@ -0,0 +1,34 @@
+use std::sync::Arc;
+
+use chrono::{DateTime, Utc};
+
+use domain::ports::ProviderConnectionQueryPort;
+use domain::provider::ProviderName;
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+
+pub struct ConnectionSummary {
+    pub provider: ProviderName,
+    pub connected_at: DateTime<Utc>,
+}
+
+pub struct Deps {
+    pub query: Arc<dyn ProviderConnectionQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(
+    user_id: UserId,
+    deps: &Deps,
+) -> Result<Vec<ConnectionSummary>, ApplicationError> {
+    let connections = deps.query.find_by_user(&user_id).await?;
+
+    Ok(connections
+        .into_iter()
+        .map(|connection| ConnectionSummary {
+            provider: connection.provider().clone(),
+            connected_at: *connection.created_at(),
+        })
+        .collect())
+}
diff --git a/crates/application/src/provider/use_cases/mod.rs b/crates/application/src/provider/use_cases/mod.rs
new file mode 100644
index 0000000..994c3aa
--- /dev/null
+++ b/crates/application/src/provider/use_cases/mod.rs
@@ -0,0 +1,4 @@
+pub mod connect_provider;
+pub mod disconnect_provider;
+pub mod get_now_playing;
+pub mod list_connections;
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 3c599ff..ec3927e 100644
--- a/crates/application/src/reminder/use_cases/process_due_reminders.rs
+++ b/crates/application/src/reminder/use_cases/process_due_reminders.rs
@@ -23,11 +23,17 @@ pub async fn execute(deps: &Deps) -> Result<u64, ApplicationError> {
 
     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");
-            deps.sender.send_reminder(reminder.user_id()).await?;
-            sent_count += 1;
+            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")
+                }
+            }
         }
     }
 
@@ -48,27 +54,13 @@ async fn should_send(
         }
     };
 
-    let now = match user.timezone() {
-        Some(tz) => {
-            let tz: chrono_tz::Tz = match tz.value().parse() {
-                Ok(tz) => tz,
-                Err(_) => {
-                    tracing::warn!(
-                        user_id = %reminder.user_id(),
-                        timezone = tz.value(),
-                        "invalid timezone for user"
-                    );
-                    return Ok(false);
-                }
-            };
-            Utc::now().with_timezone(&tz)
-        }
-        None => {
-            tracing::debug!(user_id = %reminder.user_id(), "user has no timezone set, skipping reminder");
-            return Ok(false);
-        }
+    let Some(timezone) = user.timezone() else {
+        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,
diff --git a/crates/application/src/restore/commands.rs b/crates/application/src/restore/commands.rs
new file mode 100644
index 0000000..15a6c9a
--- /dev/null
+++ b/crates/application/src/restore/commands.rs
@@ -0,0 +1,15 @@
+use domain::user::UserId;
+
+pub struct RestoreBackupCommand {
+    pub user_id: UserId,
+    pub data: Vec<u8>,
+}
+
+impl std::fmt::Debug for RestoreBackupCommand {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RestoreBackupCommand")
+            .field("user_id", &self.user_id)
+            .field("bytes", &self.data.len())
+            .finish()
+    }
+}
diff --git a/crates/application/src/restore/mod.rs b/crates/application/src/restore/mod.rs
new file mode 100644
index 0000000..804f0ee
--- /dev/null
+++ b/crates/application/src/restore/mod.rs
@@ -0,0 +1,2 @@
+pub mod commands;
+pub mod use_cases;
diff --git a/crates/application/src/restore/use_cases/mod.rs b/crates/application/src/restore/use_cases/mod.rs
new file mode 100644
index 0000000..b56c5e9
--- /dev/null
+++ b/crates/application/src/restore/use_cases/mod.rs
@@ -0,0 +1 @@
+pub mod restore_backup;
diff --git a/crates/application/src/restore/use_cases/restore_backup.rs b/crates/application/src/restore/use_cases/restore_backup.rs
new file mode 100644
index 0000000..fb14c73
--- /dev/null
+++ b/crates/application/src/restore/use_cases/restore_backup.rs
@@ -0,0 +1,354 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use chrono::{NaiveTime, Weekday};
+
+use domain::activity::{Activity, ActivityId, ActivityName, CategoryName};
+use domain::attachment::{ContentType, MediaUpload, PhotoId, VoiceMemoId};
+use domain::dimension::DimensionValue;
+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,
+    RestorableReminder, UserPreferencesCommandPort, UserPreferencesQueryPort,
+};
+use domain::provider::ProviderName;
+use domain::reminder::{DaySchedule, Reminder};
+use domain::user::UserId;
+
+use crate::errors::ApplicationError;
+use crate::restore::commands::RestoreBackupCommand;
+use crate::user::preferences::preferences_of;
+
+const WEEK: [Weekday; 7] = [
+    Weekday::Mon,
+    Weekday::Tue,
+    Weekday::Wed,
+    Weekday::Thu,
+    Weekday::Fri,
+    Weekday::Sat,
+    Weekday::Sun,
+];
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct RestoreOutcome {
+    pub entries: usize,
+    pub metrics: usize,
+    pub cycle_starts: usize,
+    pub activities: usize,
+    pub reminders: usize,
+    pub media: usize,
+    pub unreadable: Vec<String>,
+}
+
+pub struct Deps {
+    pub reader: Arc<dyn BackupReaderPort>,
+    pub entry_command: Arc<dyn MoodEntryCommandPort>,
+    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 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>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(
+    command: RestoreBackupCommand,
+    deps: &Deps,
+) -> Result<RestoreOutcome, ApplicationError> {
+    let contents = deps.reader.read(&command.data).await?;
+    let user_id = command.user_id;
+    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 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?;
+    restore_cycle_starts(&user_id, &contents.cycle_starts, deps, &mut outcome).await?;
+    restore_reminders(&user_id, &contents.reminders, deps, &mut outcome).await?;
+    restore_preferences(&user_id, contents.tracks_cycle, deps).await?;
+
+    tracing::info!(
+        entries = outcome.entries,
+        metrics = outcome.metrics,
+        cycle_starts = outcome.cycle_starts,
+        activities = outcome.activities,
+        reminders = outcome.reminders,
+        media = outcome.media,
+        unreadable = outcome.unreadable.len(),
+        "restored a backup"
+    );
+
+    Ok(outcome)
+}
+
+async fn restore_activities(
+    user_id: &UserId,
+    backed_up: &[RestorableActivity],
+    deps: &Deps,
+    outcome: &mut RestoreOutcome,
+) -> Result<HashMap<String, ActivityId>, ApplicationError> {
+    let existing: HashMap<String, ActivityId> = deps
+        .activity_query
+        .find_by_user(user_id)
+        .await?
+        .iter()
+        .map(|activity| (activity.name().value().to_string(), activity.id().clone()))
+        .collect();
+
+    let mut renamed = HashMap::new();
+
+    for held in backed_up {
+        if let Some(already_here) = existing.get(&held.name) {
+            renamed.insert(held.id.clone(), already_here.clone());
+            continue;
+        }
+
+        let Ok(name) = ActivityName::new(&held.name) else {
+            outcome
+                .unreadable
+                .push(format!("activity {}: unusable name", held.name));
+            continue;
+        };
+
+        let category = held
+            .category
+            .as_ref()
+            .and_then(|category| CategoryName::new(category).ok());
+
+        let mut activity = Activity::new(user_id.clone(), name, category);
+        if held.archived {
+            let _ = activity.archive();
+        }
+
+        deps.activity_command.save(&activity).await?;
+        renamed.insert(held.id.clone(), activity.id().clone());
+        outcome.activities += 1;
+    }
+
+    Ok(renamed)
+}
+
+async fn restore_entries(
+    user_id: &UserId,
+    backed_up: &[RestorableEntry],
+    renamed: &Renamed,
+    deps: &Deps,
+    outcome: &mut RestoreOutcome,
+) -> Result<(), ApplicationError> {
+    for held in backed_up {
+        let Ok(logged_at) = chrono::DateTime::parse_from_rfc3339(&held.logged_at) else {
+            outcome
+                .unreadable
+                .push(format!("entry at {}: unreadable instant", held.logged_at));
+            continue;
+        };
+
+        let Ok(mood) = Mood::try_from(held.mood) else {
+            outcome
+                .unreadable
+                .push(format!("entry at {}: unreadable mood", held.logged_at));
+            continue;
+        };
+
+        let entry = MoodEntry::new(user_id.clone(), mood, logged_at);
+        deps.entry_command.save(&entry).await?;
+
+        let dimensions = rebuilt_dimensions(&held.dimensions, renamed);
+        for port in &deps.dimensions {
+            port.save(entry.id(), &dimensions).await?;
+        }
+
+        outcome.entries += 1;
+    }
+
+    Ok(())
+}
+
+pub struct Renamed {
+    activities: HashMap<String, ActivityId>,
+    media: HashMap<String, String>,
+}
+
+impl Renamed {
+    fn activity(&self, was: &ActivityId) -> Option<ActivityId> {
+        self.activities.get(&was.value().to_string()).cloned()
+    }
+
+    fn photo(&self, was: &PhotoId) -> Option<PhotoId> {
+        self.media
+            .get(&was.value().to_string())
+            .and_then(|now| now.parse().ok())
+            .map(PhotoId::from_uuid)
+    }
+
+    fn voice_memo(&self, was: &VoiceMemoId) -> Option<VoiceMemoId> {
+        self.media
+            .get(&was.value().to_string())
+            .and_then(|now| now.parse().ok())
+            .map(VoiceMemoId::from_uuid)
+    }
+}
+
+fn rebuilt_dimensions(dimensions: &[DimensionValue], renamed: &Renamed) -> Vec<DimensionValue> {
+    dimensions
+        .iter()
+        .map(|dimension| match dimension {
+            DimensionValue::Activities(ids) => DimensionValue::activities(
+                ids.iter().filter_map(|id| renamed.activity(id)).collect(),
+            ),
+            DimensionValue::Photos(ids) => {
+                DimensionValue::Photos(ids.iter().filter_map(|id| renamed.photo(id)).collect())
+            }
+            DimensionValue::VoiceMemos(ids) => DimensionValue::VoiceMemos(
+                ids.iter().filter_map(|id| renamed.voice_memo(id)).collect(),
+            ),
+            kept => kept.clone(),
+        })
+        .collect()
+}
+
+async fn restore_metrics(
+    user_id: &UserId,
+    backed_up: &[RestorableMetric],
+    deps: &Deps,
+    outcome: &mut RestoreOutcome,
+) -> Result<(), ApplicationError> {
+    let mut writable = Vec::new();
+
+    for held in backed_up {
+        let readable = MetricKind::from_name(&held.kind)
+            .and_then(|kind| MetricValue::of_kind(kind, held.value).ok())
+            .zip(held.date.parse().ok().map(Date::from_persistence));
+
+        let Some((value, date)) = readable else {
+            outcome
+                .unreadable
+                .push(format!("metric {} on {}", held.kind, held.date));
+            continue;
+        };
+
+        let source = match &held.provider {
+            None => Source::Manual,
+            Some(name) => match ProviderName::new(name) {
+                Ok(provider) => Source::Provider(provider),
+                Err(_) => Source::Manual,
+            },
+        };
+
+        writable.push(DailyMetric::new(user_id.clone(), date, value, source));
+    }
+
+    outcome.metrics = deps.metrics.save(&writable).await?;
+
+    Ok(())
+}
+
+async fn restore_cycle_starts(
+    user_id: &UserId,
+    backed_up: &[String],
+    deps: &Deps,
+    outcome: &mut RestoreOutcome,
+) -> Result<(), ApplicationError> {
+    for held in backed_up {
+        let Some(date) = held.parse().ok().map(Date::from_persistence) else {
+            outcome.unreadable.push(format!("cycle start {held}"));
+            continue;
+        };
+
+        deps.cycles.record(user_id, &date).await?;
+        outcome.cycle_starts += 1;
+    }
+
+    Ok(())
+}
+
+async fn restore_reminders(
+    user_id: &UserId,
+    backed_up: &[RestorableReminder],
+    deps: &Deps,
+    outcome: &mut RestoreOutcome,
+) -> Result<(), ApplicationError> {
+    for held in backed_up {
+        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);
+        }
+
+        let mut reminder = Reminder::new(user_id.clone(), schedule);
+        if held.enabled {
+            reminder.enable();
+        } else {
+            reminder.disable();
+        }
+
+        deps.reminder_command.save(&reminder).await?;
+        outcome.reminders += 1;
+    }
+
+    Ok(())
+}
+
+async fn restore_preferences(
+    user_id: &UserId,
+    tracks_cycle: bool,
+    deps: &Deps,
+) -> Result<(), ApplicationError> {
+    let mut preferences = preferences_of(user_id, &deps.preferences_query).await?;
+    preferences.track_cycle(tracks_cycle);
+
+    deps.preferences_command.save(&preferences).await?;
+
+    Ok(())
+}
+
+async fn restore_media(
+    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;
+        };
+
+        if let Ok(now) = deps.media_storage.store_photo(upload).await {
+            renamed.insert(was.clone(), now.value().to_string());
+            outcome.media += 1;
+        }
+    }
+
+    for (was, bytes) in &contents.voice_memos {
+        let Ok(upload) = memo_upload(bytes) else {
+            continue;
+        };
+
+        if let Ok(now) = deps.media_storage.store_voice_memo(upload).await {
+            renamed.insert(was.clone(), now.value().to_string());
+            outcome.media += 1;
+        }
+    }
+
+    renamed
+}
+
+fn photo_upload(bytes: &[u8]) -> Result<MediaUpload, domain::errors::DomainError> {
+    MediaUpload::new(bytes.to_vec(), ContentType::new("image/jpeg")?)
+}
+
+fn memo_upload(bytes: &[u8]) -> Result<MediaUpload, domain::errors::DomainError> {
+    MediaUpload::new(bytes.to_vec(), ContentType::new("audio/webm")?)
+}
diff --git a/crates/application/src/user/mod.rs b/crates/application/src/user/mod.rs
index 804f0ee..9fe53ab 100644
--- a/crates/application/src/user/mod.rs
+++ b/crates/application/src/user/mod.rs
@@ -1,2 +1,3 @@
 pub mod commands;
+pub mod preferences;
 pub mod use_cases;
diff --git a/crates/application/src/user/preferences.rs b/crates/application/src/user/preferences.rs
new file mode 100644
index 0000000..e7c498b
--- /dev/null
+++ b/crates/application/src/user/preferences.rs
@@ -0,0 +1,16 @@
+use std::sync::Arc;
+
+use domain::ports::UserPreferencesQueryPort;
+use domain::user::{UserId, UserPreferences};
+
+use crate::errors::ApplicationError;
+
+pub async fn preferences_of(
+    user_id: &UserId,
+    query: &Arc<dyn UserPreferencesQueryPort>,
+) -> Result<UserPreferences, ApplicationError> {
+    Ok(query
+        .find_by_user(user_id)
+        .await?
+        .unwrap_or_else(|| UserPreferences::off_by_default(user_id.clone())))
+}
diff --git a/crates/application/src/user/use_cases/clear_data.rs b/crates/application/src/user/use_cases/clear_data.rs
index c34f207..a34b33b 100644
--- a/crates/application/src/user/use_cases/clear_data.rs
+++ b/crates/application/src/user/use_cases/clear_data.rs
@@ -1,12 +1,15 @@
 use std::sync::Arc;
 
-use domain::ports::{CascadeDeletePort, MediaStoragePort, MoodEntryQueryPort};
+use domain::ports::{CascadeDeletePort, EntryDimensionPort, MediaStoragePort, MoodEntryQueryPort};
 use domain::user::UserId;
 
+use crate::entry::composition::EntryComposer;
 use crate::errors::ApplicationError;
+use crate::media::cleanup::delete_media_for;
 
 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>,
 }
@@ -15,18 +18,10 @@ pub struct 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?;
 
-    for entry in &entries {
-        for photo_id in entry.photos() {
-            if let Err(e) = deps.media_storage.delete_photo(photo_id).await {
-                tracing::warn!(%e, "failed to delete photo blob");
-            }
-        }
-        for memo_id in entry.voice_memos() {
-            if let Err(e) = deps.media_storage.delete_voice_memo(memo_id).await {
-                tracing::warn!(%e, "failed to delete voice memo blob");
-            }
-        }
-    }
+    let composed = EntryComposer::new(deps.dimensions.clone())
+        .compose(entries)
+        .await?;
+    delete_media_for(&composed, &deps.media_storage).await;
 
     deps.cascade.delete_all_user_data(&user_id).await?;
 
diff --git a/crates/application/src/user/use_cases/delete_user.rs b/crates/application/src/user/use_cases/delete_user.rs
index ad2dbb4..ea721c3 100644
--- a/crates/application/src/user/use_cases/delete_user.rs
+++ b/crates/application/src/user/use_cases/delete_user.rs
@@ -2,15 +2,19 @@ use std::sync::Arc;
 
 use domain::errors::DomainError;
 use domain::ports::{
-    CascadeDeletePort, EventPublisherPort, MediaStoragePort, MoodEntryQueryPort, UserQueryPort,
+    CascadeDeletePort, EntryDimensionPort, EventPublisherPort, MediaStoragePort,
+    MoodEntryQueryPort, UserQueryPort,
 };
 use domain::user::UserId;
 
+use crate::entry::composition::EntryComposer;
 use crate::errors::ApplicationError;
+use crate::media::cleanup::delete_media_for;
 
 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 events: Arc<dyn EventPublisherPort>,
@@ -24,18 +28,10 @@ pub async fn execute(user_id: UserId, deps: &Deps) -> Result<(), ApplicationErro
         .ok_or_else(|| DomainError::NotFound("user not found".into()))?;
 
     let entries = deps.entry_query.find_by_user(&user_id, None, None).await?;
-    for entry in &entries {
-        for photo_id in entry.photos() {
-            if let Err(e) = deps.media_storage.delete_photo(photo_id).await {
-                tracing::warn!(%e, "failed to delete photo blob");
-            }
-        }
-        for memo_id in entry.voice_memos() {
-            if let Err(e) = deps.media_storage.delete_voice_memo(memo_id).await {
-                tracing::warn!(%e, "failed to delete voice memo blob");
-            }
-        }
-    }
+    let composed = EntryComposer::new(deps.dimensions.clone())
+        .compose(entries)
+        .await?;
+    delete_media_for(&composed, &deps.media_storage).await;
 
     deps.cascade.delete_user_account(&user_id).await?;
 
diff --git a/crates/application/src/user/use_cases/mod.rs b/crates/application/src/user/use_cases/mod.rs
index b6b2fbb..ff2027e 100644
--- a/crates/application/src/user/use_cases/mod.rs
+++ b/crates/application/src/user/use_cases/mod.rs
@@ -3,4 +3,5 @@ pub mod clear_data;
 pub mod delete_user;
 pub mod get_profile;
 pub mod register;
+pub mod set_preferences;
 pub mod update_profile;
diff --git a/crates/application/src/user/use_cases/set_preferences.rs b/crates/application/src/user/use_cases/set_preferences.rs
new file mode 100644
index 0000000..ebcc359
--- /dev/null
+++ b/crates/application/src/user/use_cases/set_preferences.rs
@@ -0,0 +1,26 @@
+use std::sync::Arc;
+
+use domain::ports::{UserPreferencesCommandPort, UserPreferencesQueryPort};
+use domain::user::{UserId, UserPreferences};
+
+use crate::errors::ApplicationError;
+use crate::user::preferences::preferences_of;
+
+pub struct Deps {
+    pub command: Arc<dyn UserPreferencesCommandPort>,
+    pub query: Arc<dyn UserPreferencesQueryPort>,
+}
+
+#[tracing::instrument(skip(deps))]
+pub async fn execute(
+    user_id: UserId,
+    tracks_cycle: bool,
+    deps: &Deps,
+) -> Result<UserPreferences, ApplicationError> {
+    let mut preferences = preferences_of(&user_id, &deps.query).await?;
+    preferences.track_cycle(tracks_cycle);
+
+    deps.command.save(&preferences).await?;
+
+    Ok(preferences)
+}
diff --git a/crates/application/tests/api_token.rs b/crates/application/tests/api_token.rs
new file mode 100644
index 0000000..ca02339
--- /dev/null
+++ b/crates/application/tests/api_token.rs
@@ -0,0 +1,2 @@
+#[path = "api_token/api_token_test.rs"]
+mod api_token_test;
diff --git a/crates/application/tests/api_token/api_token_test.rs b/crates/application/tests/api_token/api_token_test.rs
new file mode 100644
index 0000000..c40374c
--- /dev/null
+++ b/crates/application/tests/api_token/api_token_test.rs
@@ -0,0 +1,183 @@
+use std::sync::Arc;
+
+use domain::api_token::ApiToken;
+use domain::ports::UserCommandPort;
+use domain::provider::ProviderName;
+use domain::testing::{FakeApiTokenSecret, InMemoryStore, test_user};
+use domain::user::{User, UserId};
+
+use application::api_token::commands::MintApiTokenCommand;
+use application::api_token::use_cases::{
+    authenticate_api_token, list_api_tokens, mint_api_token, revoke_api_token,
+};
+
+struct Fixture {
+    store: Arc<InMemoryStore>,
+    secrets: Arc<FakeApiTokenSecret>,
+    user: User,
+}
+
+async fn a_user_with_no_tokens() -> Fixture {
+    let store = Arc::new(InMemoryStore::new());
+    let user = test_user("alice");
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    Fixture {
+        store,
+        secrets: Arc::new(FakeApiTokenSecret::new()),
+        user,
+    }
+}
+
+impl Fixture {
+    async fn mint(&self, name: &str) -> Result<String, application::errors::ApplicationError> {
+        let deps = mint_api_token::Deps {
+            command: self.store.clone(),
+            secrets: self.secrets.clone(),
+        };
+
+        let minted = mint_api_token::execute(
+            MintApiTokenCommand {
+                user_id: self.user.id().clone(),
+                name: ProviderName::new(name)?,
+            },
+            &deps,
+        )
+        .await?;
+
+        Ok(minted.secret().to_string())
+    }
+
+    async fn authenticate(&self, secret: &str) -> 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()
+    }
+
+    async fn list(&self) -> Vec<ApiToken> {
+        let deps = list_api_tokens::Deps {
+            query: self.store.clone(),
+        };
+
+        list_api_tokens::execute(self.user.id().clone(), &deps)
+            .await
+            .unwrap()
+    }
+
+    async fn revoke(
+        &self,
+        owner: UserId,
+        token: &ApiToken,
+    ) -> Result<(), application::errors::ApplicationError> {
+        let deps = revoke_api_token::Deps {
+            command: self.store.clone(),
+        };
+
+        revoke_api_token::execute(owner, token.id().clone(), &deps).await
+    }
+}
+
+#[tokio::test]
+async fn a_minted_token_is_returned_once_and_stored_only_as_a_digest() {
+    let fixture = a_user_with_no_tokens().await;
+
+    let secret = fixture.mint("iphone-shortcuts").await.unwrap();
+
+    let stored = fixture.list().await;
+    assert_eq!(stored.len(), 1);
+    assert_eq!(stored[0].name().value(), "iphone-shortcuts");
+    assert!(!secret.is_empty(), "the caller is handed the secret once");
+    assert_ne!(
+        stored[0].digest().value(),
+        secret,
+        "what is stored is a digest, not the secret itself"
+    );
+}
+
+#[tokio::test]
+async fn the_secret_authenticates_and_names_the_provider_its_writes_belong_to() {
+    let fixture = a_user_with_no_tokens().await;
+    let secret = fixture.mint("iphone-shortcuts").await.unwrap();
+
+    let token = fixture.authenticate(&secret).await.expect("it should work");
+
+    assert_eq!(token.user_id(), fixture.user.id());
+    assert_eq!(token.name().value(), "iphone-shortcuts");
+}
+
+#[tokio::test]
+async fn a_secret_nobody_minted_authenticates_nothing() {
+    let fixture = a_user_with_no_tokens().await;
+    fixture.mint("iphone-shortcuts").await.unwrap();
+
+    assert!(
+        fixture
+            .authenticate("kmood_not_a_real_secret")
+            .await
+            .is_none()
+    );
+}
+
+#[tokio::test]
+async fn a_revoked_token_stops_working_at_once() {
+    let fixture = a_user_with_no_tokens().await;
+    let secret = fixture.mint("iphone-shortcuts").await.unwrap();
+    let token = fixture.authenticate(&secret).await.unwrap();
+
+    fixture
+        .revoke(fixture.user.id().clone(), &token)
+        .await
+        .unwrap();
+
+    assert!(fixture.authenticate(&secret).await.is_none());
+    assert!(fixture.list().await.is_empty());
+}
+
+#[tokio::test]
+async fn using_a_token_records_that_it_was_used() {
+    let fixture = a_user_with_no_tokens().await;
+    let secret = fixture.mint("iphone-shortcuts").await.unwrap();
+
+    assert!(fixture.list().await[0].last_used_at().is_none());
+
+    fixture.authenticate(&secret).await.unwrap();
+
+    assert!(fixture.list().await[0].last_used_at().is_some());
+}
+
+#[tokio::test]
+async fn nobody_can_revoke_a_token_that_is_not_theirs() {
+    let fixture = a_user_with_no_tokens().await;
+    let secret = fixture.mint("iphone-shortcuts").await.unwrap();
+    let token = fixture.authenticate(&secret).await.unwrap();
+
+    let attempt = fixture.revoke(UserId::generate(), &token).await;
+
+    assert!(attempt.is_err());
+    assert!(fixture.authenticate(&secret).await.is_some());
+}
+
+#[tokio::test]
+async fn two_tokens_cannot_share_a_name_because_the_name_is_the_provider() {
+    let fixture = a_user_with_no_tokens().await;
+    fixture.mint("iphone-shortcuts").await.unwrap();
+
+    let again = fixture.mint("iphone-shortcuts").await;
+
+    assert!(again.is_err());
+    assert_eq!(fixture.list().await.len(), 1);
+}
+
+#[tokio::test]
+async fn every_minting_produces_a_different_secret() {
+    let fixture = a_user_with_no_tokens().await;
+
+    let first = fixture.mint("iphone-shortcuts").await.unwrap();
+    let second = fixture.mint("tasker").await.unwrap();
+
+    assert_ne!(first, second);
+}
diff --git a/crates/application/tests/backup.rs b/crates/application/tests/backup.rs
new file mode 100644
index 0000000..71354fa
--- /dev/null
+++ b/crates/application/tests/backup.rs
@@ -0,0 +1,2 @@
+#[path = "backup/round_trip_test.rs"]
+mod round_trip_test;
diff --git a/crates/application/tests/backup/round_trip_test.rs b/crates/application/tests/backup/round_trip_test.rs
new file mode 100644
index 0000000..fe6298a
--- /dev/null
+++ b/crates/application/tests/backup/round_trip_test.rs
@@ -0,0 +1,332 @@
+use std::sync::Arc;
+
+use domain::activity::{Activity, ActivityName, CategoryName};
+use domain::dimension::DimensionValue;
+use domain::entry::{Content, Date, DateSpan, Mood, MoodEntry};
+use domain::location::Coordinates;
+use domain::metric::{DailyMetric, MetricValue, Source, Steps};
+use domain::ports::{
+    ActivityCommandPort, ActivityQueryPort, CycleStartCommandPort, CycleStartQueryPort,
+    DailyMetricCommandPort, DailyMetricQueryPort, EntryDimensionPort, MoodEntryCommandPort,
+    MoodEntryQueryPort, ReminderCommandPort, ReminderQueryPort, UserCommandPort,
+    UserPreferencesQueryPort,
+};
+use domain::reminder::{DaySchedule, Reminder};
+use domain::song::Song;
+use domain::testing::{InMemoryDimensionStore, InMemoryStore, test_user};
+use domain::user::{Timezone, User};
+
+use application::export::use_cases::write_backup;
+use application::restore::commands::RestoreBackupCommand;
+use application::restore::use_cases::restore_backup::{self, RestoreOutcome};
+
+fn dimension_stores() -> Vec<Arc<dyn EntryDimensionPort>> {
+    use domain::dimension::DimensionKind;
+
+    [
+        DimensionKind::Content,
+        DimensionKind::Activities,
+        DimensionKind::Location,
+        DimensionKind::Song,
+        DimensionKind::Photos,
+        DimensionKind::VoiceMemos,
+    ]
+    .into_iter()
+    .map(|kind| Arc::new(InMemoryDimensionStore::new(kind)) as Arc<dyn EntryDimensionPort>)
+    .collect()
+}
+
+struct World {
+    store: Arc<InMemoryStore>,
+    dimensions: Vec<Arc<dyn EntryDimensionPort>>,
+    user: User,
+}
+
+async fn a_populated_account() -> World {
+    let store = Arc::new(InMemoryStore::new());
+    let dimensions = dimension_stores();
+
+    let mut user = test_user("alice");
+    user.update_timezone(Some(Timezone::new("Europe/Warsaw").unwrap()));
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let walking = Activity::new(
+        user.id().clone(),
+        ActivityName::new("long walk").unwrap(),
+        Some(CategoryName::new("health").unwrap()),
+    );
+    ActivityCommandPort::save(store.as_ref(), &walking)
+        .await
+        .unwrap();
+
+    let entry = MoodEntry::new(
+        user.id().clone(),
+        Mood::Rad,
+        chrono::DateTime::parse_from_rfc3339("2026-08-20T21:30:00+02:00").unwrap(),
+    );
+    MoodEntryCommandPort::save(store.as_ref(), &entry)
+        .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(),
+        ),
+    ];
+    for port in &dimensions {
+        port.save(entry.id(), &attached).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();
+
+    let reminder = Reminder::new(
+        user.id().clone(),
+        DaySchedule::every_day_at(chrono::NaiveTime::from_hms_opt(20, 0, 0).unwrap()),
+    );
+    ReminderCommandPort::save(store.as_ref(), &reminder)
+        .await
+        .unwrap();
+
+    let preference_deps = application::user::use_cases::set_preferences::Deps {
+        command: store.clone(),
+        query: store.clone(),
+    };
+    application::user::use_cases::set_preferences::execute(
+        user.id().clone(),
+        true,
+        &preference_deps,
+    )
+    .await
+    .unwrap();
+
+    World {
+        store,
+        dimensions,
+        user,
+    }
+}
+
+fn on(day: &str) -> Date {
+    Date::from_persistence(day.parse().unwrap())
+}
+
+async fn backup_of(world: &World) -> Vec<u8> {
+    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: world.store.clone(),
+        writer: Arc::new(exporter::ZipBackupWriter),
+    };
+
+    write_backup::execute(world.user.id().clone(), &deps)
+        .await
+        .unwrap()
+}
+
+async fn restore_into(world: &World, archive: Vec<u8>) -> RestoreOutcome {
+    let deps = restore_backup::Deps {
+        reader: Arc::new(importer::KmoodBackupAdapter),
+        entry_command: world.store.clone(),
+        dimensions: world.dimensions.clone(),
+        activity_command: world.store.clone(),
+        activity_query: world.store.clone(),
+        reminder_command: world.store.clone(),
+        metrics: world.store.clone(),
+        cycles: world.store.clone(),
+        preferences_command: world.store.clone(),
+        preferences_query: world.store.clone(),
+        media_storage: world.store.clone(),
+    };
+
+    restore_backup::execute(
+        RestoreBackupCommand {
+            user_id: world.user.id().clone(),
+            data: archive,
+        },
+        &deps,
+    )
+    .await
+    .unwrap()
+}
+
+async fn an_empty_account() -> World {
+    let store = Arc::new(InMemoryStore::new());
+    let mut user = test_user("bob");
+    user.update_timezone(Some(Timezone::new("Europe/Warsaw").unwrap()));
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    World {
+        store,
+        dimensions: dimension_stores(),
+        user,
+    }
+}
+
+#[tokio::test]
+async fn a_backup_restores_into_an_empty_account_without_losing_anything() {
+    let source = a_populated_account().await;
+    let archive = backup_of(&source).await;
+
+    let restored = an_empty_account().await;
+    let outcome = restore_into(&restored, archive).await;
+
+    assert!(
+        outcome.unreadable.is_empty(),
+        "the restore could not read: {:?}",
+        outcome.unreadable
+    );
+    assert_eq!(outcome.entries, 1);
+    assert_eq!(outcome.metrics, 1);
+    assert_eq!(outcome.cycle_starts, 1);
+    assert_eq!(outcome.activities, 1);
+    assert_eq!(outcome.reminders, 1);
+}
+
+#[tokio::test]
+async fn every_dimension_survives_the_round_trip() {
+    let source = a_populated_account().await;
+    let archive = backup_of(&source).await;
+
+    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 composed = application::entry::composition::EntryComposer::new(restored.dimensions.clone())
+        .compose(entries)
+        .await
+        .unwrap();
+
+    assert_eq!(composed.len(), 1);
+    let entry = &composed[0];
+
+    assert_eq!(entry.entry.mood(), Mood::Rad);
+    assert_eq!(
+        entry.content().map(|content| content.value().to_string()),
+        Some("Long walk by the river".to_string())
+    );
+    assert!(entry.location().is_some(), "the location was lost");
+    assert_eq!(
+        entry.song().map(|song| song.artist().value().to_string()),
+        Some("Massive Attack".to_string())
+    );
+    assert_eq!(entry.activities().len(), 1, "the activity tag was lost");
+}
+
+#[tokio::test]
+async fn a_restored_activity_tag_points_at_the_restored_activity() {
+    let source = a_populated_account().await;
+    let archive = backup_of(&source).await;
+
+    let restored = an_empty_account().await;
+    restore_into(&restored, archive).await;
+
+    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 composed = application::entry::composition::EntryComposer::new(restored.dimensions.clone())
+        .compose(entries)
+        .await
+        .unwrap();
+
+    assert_eq!(catalog.len(), 1);
+    assert_eq!(
+        composed[0].activities(),
+        [catalog[0].id().clone()],
+        "the tag must reference the activity as it now exists, not as it was"
+    );
+    assert_eq!(catalog[0].name().value(), "long walk");
+}
+
+#[tokio::test]
+async fn metrics_cycle_starts_and_preferences_all_come_back() {
+    let source = a_populated_account().await;
+    let archive = backup_of(&source).await;
+
+    let restored = an_empty_account().await;
+    restore_into(&restored, archive).await;
+
+    let span = DateSpan::new(on("2026-01-01"), on("2026-12-31")).unwrap();
+    let metrics =
+        DailyMetricQueryPort::find_by_span(restored.store.as_ref(), restored.user.id(), &span)
+            .await
+            .unwrap();
+    let starts = CycleStartQueryPort::find_by_user(restored.store.as_ref(), restored.user.id())
+        .await
+        .unwrap();
+    let preferences =
+        UserPreferencesQueryPort::find_by_user(restored.store.as_ref(), restored.user.id())
+            .await
+            .unwrap()
+            .unwrap();
+    let reminders = ReminderQueryPort::find_by_user(restored.store.as_ref(), restored.user.id())
+        .await
+        .unwrap();
+
+    assert_eq!(metrics.len(), 1);
+    assert_eq!(metrics[0].value().count(), 8_412);
+    assert_eq!(starts.len(), 1);
+    assert_eq!(starts[0].to_string(), "2026-08-01");
+    assert!(preferences.tracks_cycle(), "the preference was lost");
+    assert_eq!(reminders.len(), 1);
+    assert!(reminders[0].is_enabled());
+}
+
+#[tokio::test]
+async fn an_archive_that_is_not_a_backup_is_refused() {
+    let restored = an_empty_account().await;
+
+    let deps = restore_backup::Deps {
+        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: restored.store.clone(),
+    };
+
+    let refused = restore_backup::execute(
+        RestoreBackupCommand {
+            user_id: restored.user.id().clone(),
+            data: b"this is not a zip file at all".to_vec(),
+        },
+        &deps,
+    )
+    .await
+    .unwrap_err();
+
+    assert!(refused.to_string().contains("zip"), "got {refused}");
+}
diff --git a/crates/application/tests/correlation.rs b/crates/application/tests/correlation.rs
new file mode 100644
index 0000000..7c94c1c
--- /dev/null
+++ b/crates/application/tests/correlation.rs
@@ -0,0 +1,2 @@
+#[path = "correlation/get_correlations_test.rs"]
+mod get_correlations_test;
diff --git a/crates/application/tests/correlation/get_correlations_test.rs b/crates/application/tests/correlation/get_correlations_test.rs
new file mode 100644
index 0000000..612c1c2
--- /dev/null
+++ b/crates/application/tests/correlation/get_correlations_test.rs
@@ -0,0 +1,739 @@
+use std::sync::Arc;
+
+use chrono::{DateTime, Duration, FixedOffset};
+
+use domain::correlation::{CorrelationInput, CorrelationStrategy};
+use domain::entry::{Date, DateSpan, Mood, MoodEntry};
+use domain::metric::{DailyMetric, MetricKind, MetricValue, Source, Steps};
+use domain::ports::{
+    ActivityCommandPort, DailyMetricCommandPort, MoodEntryCommandPort, UserCommandPort,
+};
+use domain::testing::{InMemoryStore, test_activity, test_user};
+use domain::user::{Timezone, User};
+
+use application::correlation::queries::CorrelationQuery;
+use application::correlation::use_cases::get_correlations::{self, CorrelationRow};
+
+const MINIMUM: usize = 30;
+
+fn a_user_in_warsaw() -> User {
+    let mut user = test_user("alice");
+    user.update_timezone(Some(Timezone::new("Europe/Warsaw").unwrap()));
+    user
+}
+
+fn noon_on(day: usize) -> DateTime<FixedOffset> {
+    DateTime::parse_from_rfc3339("2026-01-01T12:00:00+01:00").unwrap() + Duration::days(day as i64)
+}
+
+fn date_of(day: usize) -> Date {
+    Date::from_persistence(noon_on(day).date_naive())
+}
+
+async fn logged(store: &Arc<InMemoryStore>, user: &User, mood: Mood, day: usize) {
+    let entry = MoodEntry::new(user.id().clone(), mood, noon_on(day));
+    MoodEntryCommandPort::save(store.as_ref(), &entry)
+        .await
+        .unwrap();
+}
+
+async fn walked(store: &Arc<InMemoryStore>, user: &User, steps: u32, day: usize) {
+    let metric = DailyMetric::new(
+        user.id().clone(),
+        date_of(day),
+        MetricValue::Steps(Steps::new(steps).unwrap()),
+        Source::Manual,
+    );
+    DailyMetricCommandPort::save(store.as_ref(), &[metric])
+        .await
+        .unwrap();
+}
+
+fn a_rising_mood_for(day: usize) -> Mood {
+    match day / 8 {
+        0 => Mood::Awful,
+        1 => Mood::Bad,
+        2 => Mood::Meh,
+        3 => Mood::Good,
+        _ => Mood::Rad,
+    }
+}
+
+fn a_mood_for(day: usize) -> Mood {
+    match day % 5 {
+        0 => Mood::Awful,
+        1 => Mood::Bad,
+        2 => Mood::Meh,
+        3 => Mood::Good,
+        _ => Mood::Rad,
+    }
+}
+
+async fn correlations(store: &Arc<InMemoryStore>, user: &User) -> Vec<CorrelationRow> {
+    let deps = get_correlations::Deps {
+        entries: store.clone(),
+        metrics: store.clone(),
+        activities: store.clone(),
+        cycles: store.clone(),
+        weather_store: Arc::new(domain::testing::InMemoryDimensionStore::new(
+            domain::dimension::DimensionKind::Weather,
+        )),
+        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()
+}
+
+fn row_for(rows: &[CorrelationRow], input: CorrelationInput) -> &CorrelationRow {
+    rows.iter()
+        .find(|row| row.input == input)
+        .expect("every input has a row")
+}
+
+fn spearman_of(row: &CorrelationRow) -> Option<f64> {
+    row.scores
+        .iter()
+        .find(|score| score.strategy == CorrelationStrategy::Spearman)
+        .map(|score| score.coefficient.value())
+}
+
+#[tokio::test]
+async fn steps_that_track_mood_exactly_score_one() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..40 {
+        logged(&store, &user, a_rising_mood_for(day), day).await;
+        walked(&store, &user, 1_000 + day as u32 * 100, day).await;
+    }
+
+    let rows = correlations(&store, &user).await;
+    let steps = row_for(&rows, CorrelationInput::Metric(MetricKind::Steps));
+
+    assert_eq!(steps.sample_size, 40);
+    let score = spearman_of(steps).expect("40 days is above the floor");
+    assert!(score > 0.9, "expected a strong positive score, got {score}");
+}
+
+#[tokio::test]
+async fn too_few_days_yield_a_row_but_no_coefficient() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..12 {
+        logged(&store, &user, a_mood_for(day), day).await;
+        walked(&store, &user, 1_000 + day as u32 * 100, day).await;
+    }
+
+    let rows = correlations(&store, &user).await;
+    let steps = row_for(&rows, CorrelationInput::Metric(MetricKind::Steps));
+
+    assert_eq!(steps.sample_size, 12);
+    assert!(steps.scores.is_empty());
+}
+
+#[tokio::test]
+async fn a_day_with_several_entries_contributes_one_point() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..31 {
+        logged(&store, &user, a_mood_for(day), day).await;
+        walked(&store, &user, 1_000 + day as u32 * 100, day).await;
+    }
+    for _ in 0..4 {
+        logged(&store, &user, Mood::Rad, 0).await;
+    }
+
+    let rows = correlations(&store, &user).await;
+    let steps = row_for(&rows, CorrelationInput::Metric(MetricKind::Steps));
+
+    assert_eq!(steps.sample_size, 31);
+}
+
+#[tokio::test]
+async fn days_without_the_metric_are_left_out_of_its_sample() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..40 {
+        logged(&store, &user, a_mood_for(day), day).await;
+    }
+    for day in 0..33 {
+        walked(&store, &user, 1_000 + day as u32 * 100, day).await;
+    }
+
+    let rows = correlations(&store, &user).await;
+    let steps = row_for(&rows, CorrelationInput::Metric(MetricKind::Steps));
+
+    assert_eq!(steps.sample_size, 33);
+}
+
+#[tokio::test]
+async fn the_moon_is_scored_against_every_day_that_has_a_mood() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..40 {
+        logged(&store, &user, a_mood_for(day), day).await;
+    }
+
+    let rows = correlations(&store, &user).await;
+    let moon = row_for(&rows, CorrelationInput::MoonPhase);
+
+    assert_eq!(moon.sample_size, 40);
+    assert!(spearman_of(moon).is_some());
+}
+
+#[tokio::test]
+async fn a_kind_that_was_never_recorded_still_has_a_row_with_no_days() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..40 {
+        logged(&store, &user, a_mood_for(day), day).await;
+    }
+
+    let rows = correlations(&store, &user).await;
+    let hrv = row_for(&rows, CorrelationInput::Metric(MetricKind::Hrv));
+
+    assert_eq!(hrv.sample_size, 0);
+    assert!(hrv.scores.is_empty());
+    let inputs_that_need_no_data: usize = 2;
+    assert_eq!(
+        rows.len(),
+        MetricKind::ALL.len() + inputs_that_need_no_data,
+        "every metric kind, plus the moon and the temperature"
+    );
+}
+
+#[tokio::test]
+async fn an_entry_just_after_local_midnight_counts_for_that_day() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 1..40 {
+        logged(&store, &user, a_mood_for(day), day).await;
+    }
+
+    let just_after_midnight = DateTime::parse_from_rfc3339("2026-01-01T00:30:00+01:00").unwrap();
+    let entry = MoodEntry::new(user.id().clone(), Mood::Good, just_after_midnight);
+    MoodEntryCommandPort::save(store.as_ref(), &entry)
+        .await
+        .unwrap();
+
+    let rows = correlations(&store, &user).await;
+    let moon = row_for(&rows, CorrelationInput::MoonPhase);
+
+    assert_eq!(
+        moon.sample_size, 40,
+        "the first day's early entry was dropped"
+    );
+}
+
+#[tokio::test]
+async fn a_day_outside_the_span_is_not_counted() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..40 {
+        logged(&store, &user, a_mood_for(day), day).await;
+    }
+
+    let the_day_before = DateTime::parse_from_rfc3339("2025-12-31T12:00:00+01:00").unwrap();
+    let entry = MoodEntry::new(user.id().clone(), Mood::Rad, the_day_before);
+    MoodEntryCommandPort::save(store.as_ref(), &entry)
+        .await
+        .unwrap();
+
+    let rows = correlations(&store, &user).await;
+    let moon = row_for(&rows, CorrelationInput::MoonPhase);
+
+    assert_eq!(moon.sample_size, 40, "a day outside the span was counted");
+}
+
+async fn correlations_with_floor(
+    store: &Arc<InMemoryStore>,
+    user: &User,
+    floor: usize,
+) -> Vec<CorrelationRow> {
+    let deps = get_correlations::Deps {
+        entries: store.clone(),
+        metrics: store.clone(),
+        activities: store.clone(),
+        cycles: store.clone(),
+        weather_store: Arc::new(domain::testing::InMemoryDimensionStore::new(
+            domain::dimension::DimensionKind::Weather,
+        )),
+        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: floor,
+        false_discovery_rate: 0.10,
+    };
+
+    get_correlations::execute(query, &deps).await.unwrap()
+}
+
+fn strategies_of(row: &CorrelationRow) -> Vec<&str> {
+    row.scores
+        .iter()
+        .map(|score| score.strategy.name())
+        .collect()
+}
+
+#[tokio::test]
+async fn every_applicable_strategy_scores_a_metric() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..40 {
+        logged(&store, &user, a_rising_mood_for(day), day).await;
+        walked(&store, &user, 1_000 + day as u32 * 100, day).await;
+    }
+
+    let rows = correlations(&store, &user).await;
+    let steps = row_for(&rows, CorrelationInput::Metric(MetricKind::Steps));
+
+    assert_eq!(strategies_of(steps), ["pearson", "spearman", "kendall"]);
+    assert_eq!(steps.agreement.applicable(), 3);
+    assert_eq!(steps.agreement.agreeing(), 3);
+}
+
+#[tokio::test]
+async fn one_outlying_day_can_set_pearson_against_the_rank_methods() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let moods = [
+        Mood::Awful,
+        Mood::Awful,
+        Mood::Bad,
+        Mood::Bad,
+        Mood::Meh,
+        Mood::Meh,
+        Mood::Good,
+        Mood::Good,
+        Mood::Rad,
+        Mood::Awful,
+    ];
+    let steps = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10_000];
+
+    for day in 0..10 {
+        logged(&store, &user, moods[day], day).await;
+        walked(&store, &user, steps[day], day).await;
+    }
+
+    let rows = correlations_with_floor(&store, &user, 10).await;
+    let row = row_for(&rows, CorrelationInput::Metric(MetricKind::Steps));
+
+    let pearson = row
+        .scores
+        .iter()
+        .find(|score| score.strategy == CorrelationStrategy::Pearson)
+        .unwrap();
+
+    assert!(
+        pearson.coefficient.value() < 0.0,
+        "the outlier pulls the line down"
+    );
+    assert_eq!(row.agreement.applicable(), 3);
+    assert_eq!(
+        row.agreement.agreeing(),
+        2,
+        "the two rank methods still agree"
+    );
+}
+
+#[tokio::test]
+async fn an_activity_is_scored_by_mean_difference_alone() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let exercise = test_activity(user.id().clone(), "exercise");
+    ActivityCommandPort::save(store.as_ref(), &exercise)
+        .await
+        .unwrap();
+
+    for day in 0..40 {
+        let mood = if day % 2 == 0 { Mood::Rad } else { Mood::Bad };
+        let entry = MoodEntry::new(user.id().clone(), mood, noon_on(day));
+        MoodEntryCommandPort::save(store.as_ref(), &entry)
+            .await
+            .unwrap();
+
+        if day % 2 == 0 {
+            store.assign_activities(entry.id(), vec![exercise.id().clone()]);
+        }
+    }
+
+    let rows = correlations(&store, &user).await;
+    let row = row_for(&rows, CorrelationInput::Activity(exercise.id().clone()));
+
+    assert_eq!(strategies_of(row), ["meanDifference"]);
+    assert_eq!(row.agreement.applicable(), 1);
+    assert_eq!(row.agreement.agreeing(), 1);
+    assert!(row.scores[0].coefficient.value() > 0.0);
+}
+
+#[tokio::test]
+async fn an_activity_logged_every_single_day_cannot_be_compared() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let coffee = test_activity(user.id().clone(), "coffee");
+    ActivityCommandPort::save(store.as_ref(), &coffee)
+        .await
+        .unwrap();
+
+    for day in 0..40 {
+        let entry = MoodEntry::new(user.id().clone(), a_mood_for(day), noon_on(day));
+        MoodEntryCommandPort::save(store.as_ref(), &entry)
+            .await
+            .unwrap();
+        store.assign_activities(entry.id(), vec![coffee.id().clone()]);
+    }
+
+    let rows = correlations(&store, &user).await;
+    let row = row_for(&rows, CorrelationInput::Activity(coffee.id().clone()));
+
+    assert!(
+        row.scores.is_empty(),
+        "there are no days without it to compare"
+    );
+    assert_eq!(row.agreement.applicable(), 1);
+    assert_eq!(row.agreement.agreeing(), 0);
+}
+
+#[tokio::test]
+async fn an_archived_activity_is_not_offered() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let mut retired = test_activity(user.id().clone(), "fencing");
+    retired.archive().unwrap();
+    ActivityCommandPort::save(store.as_ref(), &retired)
+        .await
+        .unwrap();
+
+    for day in 0..40 {
+        logged(&store, &user, a_mood_for(day), day).await;
+    }
+
+    let rows = correlations(&store, &user).await;
+
+    assert!(
+        !rows
+            .iter()
+            .any(|row| row.input == CorrelationInput::Activity(retired.id().clone())),
+        "an archived activity cannot be tagged onto new entries and is not an input"
+    );
+}
+
+#[tokio::test]
+async fn an_activity_never_logged_in_the_span_is_not_a_row_at_all() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let untouched = test_activity(user.id().clone(), "fencing");
+    ActivityCommandPort::save(store.as_ref(), &untouched)
+        .await
+        .unwrap();
+
+    for day in 0..40 {
+        logged(&store, &user, a_mood_for(day), day).await;
+    }
+
+    let rows = correlations(&store, &user).await;
+
+    assert!(
+        !rows
+            .iter()
+            .any(|row| row.input == CorrelationInput::Activity(untouched.id().clone())),
+        "an activity with no logged day says nothing and should not be reported as measured"
+    );
+}
+
+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)
+        .await
+        .unwrap()
+}
+
+async fn correlations_with_rate(
+    store: &Arc<InMemoryStore>,
+    user: &User,
+    floor: usize,
+    false_discovery_rate: f64,
+) -> Vec<CorrelationRow> {
+    let deps = get_correlations::Deps {
+        entries: store.clone(),
+        metrics: store.clone(),
+        activities: store.clone(),
+        cycles: store.clone(),
+        weather_store: Arc::new(domain::testing::InMemoryDimensionStore::new(
+            domain::dimension::DimensionKind::Weather,
+        )),
+        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: floor,
+        false_discovery_rate,
+    };
+
+    get_correlations::execute(query, &deps).await.unwrap()
+}
+
+fn held_up(row: &CorrelationRow, strategy: CorrelationStrategy) -> bool {
+    row.scores
+        .iter()
+        .find(|score| score.strategy == strategy)
+        .map(|score| score.held_up)
+        .unwrap_or(false)
+}
+
+async fn a_year_of_steps_tracking_mood(store: &Arc<InMemoryStore>, user: &User) {
+    for day in 0..40 {
+        logged(store, user, a_rising_mood_for(day), day).await;
+        walked(store, user, 1_000 + day as u32 * 100, day).await;
+    }
+}
+
+#[tokio::test]
+async fn a_relationship_that_survives_the_number_of_things_tested_is_marked() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    a_year_of_steps_tracking_mood(&store, &user).await;
+
+    let rows = correlations_with_rate(&store, &user, 30, 0.10).await;
+    let steps = row_for(&rows, CorrelationInput::Metric(MetricKind::Steps));
+
+    assert!(held_up(steps, CorrelationStrategy::Spearman));
+    assert!(held_up(steps, CorrelationStrategy::Kendall));
+}
+
+#[tokio::test]
+async fn the_moon_does_not_survive_the_correction_on_ordinary_data() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    a_year_of_steps_tracking_mood(&store, &user).await;
+
+    let rows = correlations_with_rate(&store, &user, 30, 0.10).await;
+    let moon = row_for(&rows, CorrelationInput::MoonPhase);
+
+    assert!(!held_up(moon, CorrelationStrategy::Spearman));
+}
+
+#[tokio::test]
+async fn keeping_more_activities_does_not_change_whether_a_metric_is_marked() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    a_year_of_steps_tracking_mood(&store, &user).await;
+
+    let before = correlations_with_rate(&store, &user, 30, 0.10).await;
+    let steps_before = held_up(
+        row_for(&before, CorrelationInput::Metric(MetricKind::Steps)),
+        CorrelationStrategy::Spearman,
+    );
+
+    for number in 0..20 {
+        let activity = test_activity(user.id().clone(), &format!("activity {number}"));
+        ActivityCommandPort::save(store.as_ref(), &activity)
+            .await
+            .unwrap();
+
+        let entries = deps_free_entries(&store, &user).await;
+        for (index, entry) in entries.iter().enumerate() {
+            if index % (number + 2) == 0 {
+                store.assign_activities(entry.id(), vec![activity.id().clone()]);
+            }
+        }
+    }
+
+    let after = correlations_with_rate(&store, &user, 30, 0.10).await;
+    let steps_after = held_up(
+        row_for(&after, CorrelationInput::Metric(MetricKind::Steps)),
+        CorrelationStrategy::Spearman,
+    );
+
+    assert!(
+        after.len() > before.len(),
+        "the activities should have produced rows of their own"
+    );
+    assert_eq!(
+        steps_before, steps_after,
+        "a metric's mark must not depend on how many activities the user keeps"
+    );
+}
+
+#[tokio::test]
+async fn one_strategy_can_hold_up_while_another_does_not() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..30 {
+        let mood = if day == 29 {
+            Mood::Awful
+        } else {
+            a_rising_mood_for(day)
+        };
+        logged(&store, &user, mood, day).await;
+
+        let steps = if day == 29 {
+            200_000
+        } else {
+            1_000 + day as u32 * 100
+        };
+        walked(&store, &user, steps, day).await;
+    }
+
+    let rows = correlations_with_rate(&store, &user, 30, 0.10).await;
+    let steps = row_for(&rows, CorrelationInput::Metric(MetricKind::Steps));
+
+    assert!(
+        held_up(steps, CorrelationStrategy::Spearman),
+        "the order survives one outlying day"
+    );
+    assert!(
+        !held_up(steps, CorrelationStrategy::Pearson),
+        "the straight line does not"
+    );
+}
+
+#[tokio::test]
+async fn a_stricter_rate_marks_less() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..30 {
+        let mood = match day % 6 {
+            0 | 1 => Mood::Bad,
+            2 | 3 => Mood::Meh,
+            _ => Mood::Good,
+        };
+        logged(&store, &user, mood, day).await;
+        walked(&store, &user, 1_000 + day as u32 * 40, day).await;
+    }
+
+    let loose = correlations_with_rate(&store, &user, 30, 0.90).await;
+    let strict = correlations_with_rate(&store, &user, 30, 0.000_001).await;
+
+    let marked_loosely = held_up(
+        row_for(&loose, CorrelationInput::Metric(MetricKind::Steps)),
+        CorrelationStrategy::Spearman,
+    );
+    let marked_strictly = held_up(
+        row_for(&strict, CorrelationInput::Metric(MetricKind::Steps)),
+        CorrelationStrategy::Spearman,
+    );
+
+    assert!(marked_loosely);
+    assert!(!marked_strictly);
+}
+
+async fn turn_cycle_tracking_on(store: &Arc<InMemoryStore>, user: &User) {
+    let deps = application::user::use_cases::set_preferences::Deps {
+        command: store.clone(),
+        query: store.clone(),
+    };
+
+    application::user::use_cases::set_preferences::execute(user.id().clone(), true, &deps)
+        .await
+        .unwrap();
+}
+
+#[tokio::test]
+async fn the_cycle_is_not_correlated_unless_it_is_tracked() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    for day in 0..40 {
+        logged(&store, &user, a_mood_for(day), day).await;
+    }
+
+    let rows = correlations(&store, &user).await;
+
+    assert!(
+        !rows
+            .iter()
+            .any(|row| row.input == CorrelationInput::CycleProgress),
+        "an untracked cycle is not an input at all"
+    );
+}
+
+#[tokio::test]
+async fn a_tracked_cycle_is_scored_like_anything_else_continuous() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw();
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    turn_cycle_tracking_on(&store, &user).await;
+
+    for day in 0..40 {
+        logged(&store, &user, a_rising_mood_for(day), day).await;
+    }
+
+    let cycle_deps = application::cycle::use_cases::record_cycle_start::Deps {
+        command: store.clone(),
+        preferences: store.clone(),
+    };
+    for start in [0, 28] {
+        application::cycle::use_cases::record_cycle_start::execute(
+            user.id().clone(),
+            date_of(start),
+            &cycle_deps,
+        )
+        .await
+        .unwrap();
+    }
+
+    let rows = correlations(&store, &user).await;
+    let cycle = row_for(&rows, CorrelationInput::CycleProgress);
+
+    assert_eq!(cycle.sample_size, 40);
+    assert_eq!(
+        cycle
+            .scores
+            .iter()
+            .map(|s| s.strategy.name())
+            .collect::<Vec<_>>(),
+        ["pearson", "spearman", "kendall"]
+    );
+}
diff --git a/crates/application/tests/cycle.rs b/crates/application/tests/cycle.rs
new file mode 100644
index 0000000..8b33bfa
--- /dev/null
+++ b/crates/application/tests/cycle.rs
@@ -0,0 +1,2 @@
+#[path = "cycle/cycle_test.rs"]
+mod cycle_test;
diff --git a/crates/application/tests/cycle/cycle_test.rs b/crates/application/tests/cycle/cycle_test.rs
new file mode 100644
index 0000000..d98eddf
--- /dev/null
+++ b/crates/application/tests/cycle/cycle_test.rs
@@ -0,0 +1,172 @@
+use std::sync::Arc;
+
+use domain::entry::Date;
+use domain::ports::UserCommandPort;
+use domain::testing::{InMemoryStore, test_user};
+use domain::user::{Timezone, User};
+
+use application::cycle::use_cases::read_cycle::CycleView;
+use application::cycle::use_cases::{forget_cycle_start, read_cycle, record_cycle_start};
+use application::user::use_cases::set_preferences;
+
+async fn a_user_in_warsaw(store: &Arc<InMemoryStore>) -> User {
+    let mut user = test_user("alice");
+    user.update_timezone(Some(Timezone::new("Europe/Warsaw").unwrap()));
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    user
+}
+
+fn on(day: &str) -> Date {
+    Date::from_persistence(day.parse().unwrap())
+}
+
+async fn turn_tracking(store: &Arc<InMemoryStore>, user: &User, on: bool) {
+    let deps = set_preferences::Deps {
+        command: store.clone(),
+        query: store.clone(),
+    };
+
+    set_preferences::execute(user.id().clone(), on, &deps)
+        .await
+        .unwrap();
+}
+
+async fn record(
+    store: &Arc<InMemoryStore>,
+    user: &User,
+    day: &str,
+) -> Result<(), application::errors::ApplicationError> {
+    let deps = record_cycle_start::Deps {
+        command: store.clone(),
+        preferences: store.clone(),
+    };
+
+    record_cycle_start::execute(user.id().clone(), on(day), &deps).await
+}
+
+async fn forget(store: &Arc<InMemoryStore>, user: &User, day: &str) {
+    let deps = forget_cycle_start::Deps {
+        command: store.clone(),
+    };
+
+    forget_cycle_start::execute(user.id().clone(), on(day), &deps)
+        .await
+        .unwrap();
+}
+
+async fn read(store: &Arc<InMemoryStore>, user: &User) -> CycleView {
+    let deps = read_cycle::Deps {
+        query: store.clone(),
+        preferences: store.clone(),
+        users: store.clone(),
+    };
+
+    read_cycle::execute(user.id().clone(), &deps).await.unwrap()
+}
+
+#[tokio::test]
+async fn tracking_is_off_until_it_is_turned_on() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    let view = read(&store, &user).await;
+
+    assert!(!view.tracking);
+    assert!(view.starts.is_empty());
+    assert!(view.today.is_none());
+}
+
+#[tokio::test]
+async fn nothing_can_be_recorded_while_tracking_is_off() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    let refused = record(&store, &user, "2026-01-01").await.unwrap_err();
+
+    assert!(refused.to_string().contains("off"), "got {refused}");
+    assert!(read(&store, &user).await.starts.is_empty());
+}
+
+#[tokio::test]
+async fn a_recorded_start_comes_back_in_order() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+    turn_tracking(&store, &user, true).await;
+
+    record(&store, &user, "2026-01-29").await.unwrap();
+    record(&store, &user, "2026-01-01").await.unwrap();
+
+    let view = read(&store, &user).await;
+
+    assert_eq!(
+        view.starts
+            .iter()
+            .map(|d| d.to_string())
+            .collect::<Vec<_>>(),
+        ["2026-01-01", "2026-01-29"]
+    );
+}
+
+#[tokio::test]
+async fn recording_the_same_day_twice_records_it_once() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+    turn_tracking(&store, &user, true).await;
+
+    record(&store, &user, "2026-01-01").await.unwrap();
+    record(&store, &user, "2026-01-01").await.unwrap();
+
+    assert_eq!(read(&store, &user).await.starts.len(), 1);
+}
+
+#[tokio::test]
+async fn a_start_can_be_taken_back() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+    turn_tracking(&store, &user, true).await;
+    record(&store, &user, "2026-01-01").await.unwrap();
+
+    forget(&store, &user, "2026-01-01").await;
+
+    assert!(read(&store, &user).await.starts.is_empty());
+}
+
+#[tokio::test]
+async fn turning_tracking_off_hides_the_cycle_without_forgetting_it() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+    turn_tracking(&store, &user, true).await;
+    record(&store, &user, "2026-01-01").await.unwrap();
+
+    turn_tracking(&store, &user, false).await;
+    let hidden = read(&store, &user).await;
+
+    turn_tracking(&store, &user, true).await;
+    let shown = read(&store, &user).await;
+
+    assert!(!hidden.tracking);
+    assert!(
+        hidden.starts.is_empty(),
+        "nothing is offered while it is off"
+    );
+    assert_eq!(shown.starts.len(), 1, "and nothing was thrown away");
+}
+
+#[tokio::test]
+async fn one_accounts_cycle_is_not_anothers() {
+    let store = Arc::new(InMemoryStore::new());
+    let mine = a_user_in_warsaw(&store).await;
+
+    let mut theirs = test_user("bob");
+    theirs.update_timezone(Some(Timezone::new("Europe/Warsaw").unwrap()));
+    UserCommandPort::save(store.as_ref(), &theirs)
+        .await
+        .unwrap();
+
+    turn_tracking(&store, &mine, true).await;
+    turn_tracking(&store, &theirs, true).await;
+    record(&store, &mine, "2026-01-01").await.unwrap();
+
+    assert_eq!(read(&store, &mine).await.starts.len(), 1);
+    assert!(read(&store, &theirs).await.starts.is_empty());
+}
diff --git a/crates/application/tests/day.rs b/crates/application/tests/day.rs
new file mode 100644
index 0000000..c0cd14d
--- /dev/null
+++ b/crates/application/tests/day.rs
@@ -0,0 +1,2 @@
+#[path = "day/timezone_test.rs"]
+mod timezone_test;
diff --git a/crates/application/tests/day/timezone_test.rs b/crates/application/tests/day/timezone_test.rs
new file mode 100644
index 0000000..4c40014
--- /dev/null
+++ b/crates/application/tests/day/timezone_test.rs
@@ -0,0 +1,34 @@
+use std::sync::Arc;
+
+use domain::ports::{UserCommandPort, UserQueryPort};
+use domain::testing::{InMemoryStore, test_user};
+use domain::user::Timezone;
+
+use application::day::timezone_for;
+
+#[tokio::test]
+async fn a_users_timezone_is_resolved_when_they_have_one() {
+    let store = Arc::new(InMemoryStore::new());
+    let mut user = test_user("alice");
+    user.update_timezone(Some(Timezone::new("Europe/Warsaw").unwrap()));
+    store.save(&user).await.unwrap();
+
+    let users: Arc<dyn UserQueryPort> = store.clone();
+    let timezone = timezone_for(user.id(), &users).await.unwrap();
+
+    assert_eq!(timezone.value(), "Europe/Warsaw");
+}
+
+#[tokio::test]
+async fn a_user_with_no_timezone_gets_an_error_that_says_what_to_do() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = test_user("bob");
+    store.save(&user).await.unwrap();
+
+    let users: Arc<dyn UserQueryPort> = store.clone();
+    let error = timezone_for(user.id(), &users).await.unwrap_err();
+
+    let message = error.to_string();
+    assert!(message.contains("timezone"));
+    assert!(message.contains("settings"));
+}
diff --git a/crates/application/tests/deletion.rs b/crates/application/tests/deletion.rs
new file mode 100644
index 0000000..0b9eaf5
--- /dev/null
+++ b/crates/application/tests/deletion.rs
@@ -0,0 +1,5 @@
+#[path = "deletion/ordering_test.rs"]
+mod ordering_test;
+
+#[path = "deletion/best_effort_test.rs"]
+mod best_effort_test;
diff --git a/crates/application/tests/deletion/best_effort_test.rs b/crates/application/tests/deletion/best_effort_test.rs
new file mode 100644
index 0000000..6eda294
--- /dev/null
+++ b/crates/application/tests/deletion/best_effort_test.rs
@@ -0,0 +1,175 @@
+use std::sync::Arc;
+
+use domain::api_token::{ApiToken, TokenDigest};
+use domain::attachment::PhotoId;
+use domain::dimension::{DimensionKind, DimensionValue};
+use domain::entry::{Mood, MoodEntry};
+use domain::ports::{
+    ApiTokenSecretPort, DailyMetricQueryPort, EntryDimensionPort, MoodEntryCommandPort,
+};
+use domain::provider::ProviderName;
+use domain::testing::{
+    FakeApiTokenSecret, FakeMediaStorage, InMemoryDimensionStore, InMemoryStore, OneTokenStore,
+    RefusingApiTokenStore, RefusingRejectionTrace,
+};
+use domain::user::UserId;
+
+use application::api_token::use_cases::authenticate_api_token;
+use application::entry::commands::UpdateEntryCommand;
+use application::entry::use_cases::update_entry;
+use application::import::commands::{ImportDailyMetricsCommand, ImportedDay, ImportedMetric};
+use application::import::use_cases::import_daily_metrics;
+
+#[tokio::test]
+async fn a_blob_that_refuses_to_go_does_not_stop_the_entry_being_edited() {
+    let store = Arc::new(InMemoryStore::new());
+    let photos = Arc::new(InMemoryDimensionStore::new(DimensionKind::Photos));
+    let media = Arc::new(FakeMediaStorage::refusing_to_delete());
+
+    let owner = UserId::generate();
+    let entry = MoodEntry::new(
+        owner.clone(),
+        Mood::Good,
+        chrono::DateTime::parse_from_rfc3339("2026-08-20T12:00:00+02:00").unwrap(),
+    );
+    MoodEntryCommandPort::save(store.as_ref(), &entry)
+        .await
+        .unwrap();
+
+    let removed = PhotoId::generate();
+    media.put_photo(&removed, b"a photograph");
+    photos
+        .save(entry.id(), &[DimensionValue::Photos(vec![removed.clone()])])
+        .await
+        .unwrap();
+
+    let deps = update_entry::Deps {
+        command: store.clone(),
+        dimensions: vec![photos.clone() as Arc<dyn EntryDimensionPort>],
+        query: store.clone(),
+        media_storage: media.clone(),
+        events: store.clone(),
+    };
+
+    let edited = update_entry::execute(
+        UpdateEntryCommand {
+            entry_id: entry.id().clone(),
+            mood: Mood::Rad,
+            logged_at: Some(
+                chrono::DateTime::parse_from_rfc3339("2026-08-20T12:00:00+02:00").unwrap(),
+            ),
+            dimensions: Vec::new(),
+        },
+        owner,
+        &deps,
+    )
+    .await;
+
+    assert!(
+        edited.is_ok(),
+        "a blob store that will not delete must not block an edit: {edited:?}"
+    );
+    assert_eq!(edited.unwrap().mood(), Mood::Rad);
+    assert_eq!(
+        media.deletions_attempted().len(),
+        1,
+        "the deletion was still attempted"
+    );
+}
+
+#[tokio::test]
+async fn an_unwritable_rejection_trace_does_not_fail_the_import() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = UserId::generate();
+
+    let deps = import_daily_metrics::Deps {
+        metrics: store.clone(),
+        rejections: Arc::new(RefusingRejectionTrace),
+    };
+
+    let outcome = import_daily_metrics::execute(
+        ImportDailyMetricsCommand {
+            user_id: user_id.clone(),
+            provider: ProviderName::new("healthkit").unwrap(),
+            days: vec![ImportedDay {
+                date: "2026-08-20".into(),
+                metrics: vec![
+                    ImportedMetric {
+                        kind: "steps".into(),
+                        value: Some(8_412),
+                    },
+                    ImportedMetric {
+                        kind: "hrv".into(),
+                        value: Some(9_999),
+                    },
+                ],
+            }],
+            maximum_days: 90,
+        },
+        &deps,
+    )
+    .await
+    .expect("a trace that cannot be written must not lose the good readings");
+
+    assert_eq!(outcome.accepted, 1);
+    assert_eq!(outcome.rejected.len(), 1, "and the caller is still told");
+
+    let span = domain::entry::DateSpan::new(
+        domain::entry::Date::from_persistence("2026-08-20".parse().unwrap()),
+        domain::entry::Date::from_persistence("2026-08-20".parse().unwrap()),
+    )
+    .unwrap();
+    let stored = DailyMetricQueryPort::find_by_span(store.as_ref(), &user_id, &span)
+        .await
+        .unwrap();
+    assert_eq!(stored.len(), 1, "the valid reading was still stored");
+}
+
+#[tokio::test]
+async fn a_token_store_that_cannot_record_a_use_still_authenticates() {
+    let secrets = Arc::new(FakeApiTokenSecret::new());
+    let secret = secrets.mint();
+
+    let token = ApiToken::new(
+        UserId::generate(),
+        ProviderName::new("iphone-shortcuts").unwrap(),
+        secrets.digest(&secret),
+    );
+
+    let deps = authenticate_api_token::Deps {
+        query: Arc::new(OneTokenStore(token.clone())),
+        command: Arc::new(RefusingApiTokenStore),
+        secrets,
+    };
+
+    let authenticated = authenticate_api_token::execute(&secret, &deps).await;
+
+    assert!(
+        authenticated.is_ok(),
+        "a token must keep working when its last-used stamp cannot be written: {authenticated:?}"
+    );
+    assert_eq!(authenticated.unwrap().id(), token.id());
+}
+
+#[tokio::test]
+async fn a_digest_that_matches_nothing_is_still_refused() {
+    let secrets = Arc::new(FakeApiTokenSecret::new());
+    let real = secrets.mint();
+
+    let token = ApiToken::new(
+        UserId::generate(),
+        ProviderName::new("iphone-shortcuts").unwrap(),
+        TokenDigest::from_persistence("some other digest".into()),
+    );
+
+    let deps = authenticate_api_token::Deps {
+        query: Arc::new(OneTokenStore(token)),
+        command: Arc::new(RefusingApiTokenStore),
+        secrets,
+    };
+
+    assert!(
+        authenticate_api_token::execute(&real, &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
new file mode 100644
index 0000000..635f065
--- /dev/null
+++ b/crates/application/tests/deletion/ordering_test.rs
@@ -0,0 +1,232 @@
+use std::sync::Arc;
+
+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,
+};
+use domain::testing::{FakeMediaStorage, InMemoryDimensionStore, InMemoryStore, test_user};
+use domain::user::{Timezone, User};
+
+use application::entry::use_cases::delete_entries_by_date_range;
+use application::user::use_cases::{clear_data, delete_user};
+
+struct Doomed {
+    store: Arc<InMemoryStore>,
+    photos: Arc<InMemoryDimensionStore>,
+    voice_memos: Arc<InMemoryDimensionStore>,
+    user: User,
+    photo_id: PhotoId,
+    memo_id: VoiceMemoId,
+}
+
+async fn an_entry_with_media(media: &Arc<FakeMediaStorage>) -> Doomed {
+    let store = Arc::new(InMemoryStore::new());
+    let photos = Arc::new(InMemoryDimensionStore::new(DimensionKind::Photos));
+    let voice_memos = Arc::new(InMemoryDimensionStore::new(DimensionKind::VoiceMemos));
+
+    store.cascades_to(&photos);
+    store.cascades_to(&voice_memos);
+
+    let mut user = test_user("alice");
+    user.update_timezone(Some(Timezone::new("Europe/Warsaw").unwrap()));
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let entry = MoodEntry::new(
+        user.id().clone(),
+        Mood::Good,
+        chrono::DateTime::parse_from_rfc3339("2026-08-20T12:00:00+02:00").unwrap(),
+    );
+    MoodEntryCommandPort::save(store.as_ref(), &entry)
+        .await
+        .unwrap();
+
+    let photo_id = PhotoId::generate();
+    let memo_id = VoiceMemoId::generate();
+    media.put_photo(&photo_id, b"a photograph");
+    media.put_voice_memo(&memo_id, b"a recording");
+
+    photos
+        .save(
+            entry.id(),
+            &[DimensionValue::Photos(vec![photo_id.clone()])],
+        )
+        .await
+        .unwrap();
+    voice_memos
+        .save(
+            entry.id(),
+            &[DimensionValue::VoiceMemos(vec![memo_id.clone()])],
+        )
+        .await
+        .unwrap();
+
+    Doomed {
+        store,
+        photos,
+        voice_memos,
+        user,
+        photo_id,
+        memo_id,
+    }
+}
+
+impl Doomed {
+    fn dimensions(&self) -> Vec<Arc<dyn EntryDimensionPort>> {
+        vec![
+            self.photos.clone() as Arc<dyn EntryDimensionPort>,
+            self.voice_memos.clone() as Arc<dyn EntryDimensionPort>,
+        ]
+    }
+
+    fn everything_ever() -> DateRange {
+        DateRange::new(
+            chrono::DateTime::parse_from_rfc3339("2000-01-01T00:00:00+00:00").unwrap(),
+            chrono::DateTime::parse_from_rfc3339("2099-01-01T00:00:00+00:00").unwrap(),
+        )
+        .unwrap()
+    }
+}
+
+#[tokio::test]
+async fn deleting_a_date_range_takes_the_blobs_with_it() {
+    let media = Arc::new(FakeMediaStorage::holding_nothing());
+    let doomed = an_entry_with_media(&media).await;
+
+    let deps = delete_entries_by_date_range::Deps {
+        cascade: doomed.store.clone(),
+        query: doomed.store.clone(),
+        dimensions: doomed.dimensions(),
+        media_storage: media.clone(),
+    };
+
+    let deleted = delete_entries_by_date_range::execute(
+        doomed.user.id().clone(),
+        &Doomed::everything_ever(),
+        &deps,
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(deleted, 1);
+    assert!(
+        !media.holds_photo(&doomed.photo_id),
+        "the photo blob was orphaned: media must be resolved before the cascade clears the dimensions"
+    );
+    assert!(
+        !media.holds_voice_memo(&doomed.memo_id),
+        "the voice memo blob was orphaned"
+    );
+    assert_eq!(media.blobs_held(), 0);
+}
+
+#[tokio::test]
+async fn the_cascade_really_does_clear_the_dimension_values() {
+    let media = Arc::new(FakeMediaStorage::holding_nothing());
+    let doomed = an_entry_with_media(&media).await;
+    assert_eq!(doomed.store.entry_count(), 1);
+
+    CascadeDeletePort::delete_entries_in_range(
+        doomed.store.as_ref(),
+        doomed.user.id(),
+        &Doomed::everything_ever(),
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        doomed.photos.holds_count(),
+        0,
+        "a fake that keeps dimension values is more forgiving than the database"
+    );
+    assert_eq!(doomed.voice_memos.holds_count(), 0);
+}
+
+#[tokio::test]
+async fn clearing_a_users_data_takes_the_blobs_with_it() {
+    let media = Arc::new(FakeMediaStorage::holding_nothing());
+    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(),
+    };
+
+    clear_data::execute(doomed.user.id().clone(), &deps)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        media.blobs_held(),
+        0,
+        "clear_data has the same ordering requirement as deleting a range"
+    );
+}
+
+#[tokio::test]
+async fn deleting_an_account_takes_the_blobs_with_it() {
+    let media = Arc::new(FakeMediaStorage::holding_nothing());
+    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(),
+        user_query: doomed.store.clone(),
+        events: doomed.store.clone(),
+    };
+
+    delete_user::execute(doomed.user.id().clone(), &deps)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        media.blobs_held(),
+        0,
+        "deleting an account has the same ordering requirement"
+    );
+    let _ = ActivityQueryPort::find_by_user(doomed.store.as_ref(), doomed.user.id()).await;
+    let _ = ReminderQueryPort::find_by_user(doomed.store.as_ref(), doomed.user.id()).await;
+}
+
+#[tokio::test]
+async fn a_blob_store_that_refuses_to_delete_does_not_save_the_entries() {
+    let media = Arc::new(FakeMediaStorage::refusing_to_delete());
+    let doomed = an_entry_with_media(&media).await;
+
+    let deps = delete_entries_by_date_range::Deps {
+        cascade: doomed.store.clone(),
+        query: doomed.store.clone(),
+        dimensions: doomed.dimensions(),
+        media_storage: media.clone(),
+    };
+
+    let deleted = delete_entries_by_date_range::execute(
+        doomed.user.id().clone(),
+        &Doomed::everything_ever(),
+        &deps,
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        deleted, 1,
+        "a blob that will not go must not keep the entry alive"
+    );
+    assert_eq!(doomed.store.entry_count(), 0);
+    assert_eq!(
+        media.deletions_attempted().len(),
+        2,
+        "both blobs were attempted even though the first refused"
+    );
+    assert_eq!(
+        media.blobs_held(),
+        2,
+        "and the blobs are still there, orphaned but reported"
+    );
+}
diff --git a/crates/application/tests/entry.rs b/crates/application/tests/entry.rs
index 4998e4f..693e3bc 100644
--- a/crates/application/tests/entry.rs
+++ b/crates/application/tests/entry.rs
@@ -21,3 +21,9 @@ mod mood_stats_test;
 
 #[path = "entry/replace_activity_test.rs"]
 mod replace_activity_test;
+
+#[path = "entry/dimension_test.rs"]
+mod dimension_test;
+
+#[path = "entry/calendar_test.rs"]
+mod calendar_test;
diff --git a/crates/application/tests/entry/calendar_test.rs b/crates/application/tests/entry/calendar_test.rs
new file mode 100644
index 0000000..519ac7f
--- /dev/null
+++ b/crates/application/tests/entry/calendar_test.rs
@@ -0,0 +1,230 @@
+use std::sync::Arc;
+
+use chrono::{DateTime, FixedOffset};
+
+use domain::entry::{DateRange, Mood, MoodEntry};
+use domain::ports::{MoodEntryCommandPort, UserCommandPort};
+use domain::testing::{InMemoryStore, test_user};
+use domain::user::{Timezone, User};
+
+use application::entry::use_cases::get_calendar::{self, CalendarDay};
+
+fn user_in(name: &str, timezone: &str) -> User {
+    let mut user = test_user(name);
+    user.update_timezone(Some(Timezone::new(timezone).unwrap()));
+    user
+}
+
+fn at(instant: &str) -> DateTime<FixedOffset> {
+    DateTime::parse_from_rfc3339(instant).unwrap()
+}
+
+async fn calendar_of(store: &Arc<InMemoryStore>, user: &User) -> Vec<CalendarDay> {
+    let deps = get_calendar::Deps {
+        query: store.clone(),
+        dimensions: Vec::new(),
+        cycles: store.clone(),
+        preferences: store.clone(),
+        users: store.clone(),
+    };
+
+    let range = DateRange::new(
+        at("2026-08-01T00:00:00+00:00"),
+        at("2026-08-31T23:59:59+00:00"),
+    )
+    .unwrap();
+
+    get_calendar::execute(user.id().clone(), range, &deps)
+        .await
+        .unwrap()
+}
+
+async fn logged(store: &Arc<InMemoryStore>, user: &User, mood: Mood, instant: &str) {
+    let entry = MoodEntry::new(user.id().clone(), mood, at(instant));
+    MoodEntryCommandPort::save(store.as_ref(), &entry)
+        .await
+        .unwrap();
+}
+
+#[tokio::test]
+async fn a_day_of_one_awful_and_one_rad_does_not_report_rad() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = user_in("alice", "Europe/Warsaw");
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    logged(&store, &user, Mood::Awful, "2026-08-20T09:00:00+02:00").await;
+    logged(&store, &user, Mood::Rad, "2026-08-20T21:00:00+02:00").await;
+
+    let days = calendar_of(&store, &user).await;
+
+    assert_eq!(days.len(), 1);
+    let mood = days[0].day_mood.expect("the day has entries");
+    assert_eq!(mood.rounded(), Mood::Meh);
+    assert!((mood.value() - 3.0).abs() < f64::EPSILON);
+}
+
+#[tokio::test]
+async fn only_days_that_were_logged_appear() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = user_in("alice", "Europe/Warsaw");
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    logged(&store, &user, Mood::Good, "2026-08-20T09:00:00+02:00").await;
+    logged(&store, &user, Mood::Bad, "2026-08-24T09:00:00+02:00").await;
+
+    let days = calendar_of(&store, &user).await;
+    let dates: Vec<String> = days.iter().map(|day| day.date.to_string()).collect();
+
+    assert_eq!(dates, ["2026-08-20", "2026-08-24"]);
+}
+
+#[tokio::test]
+async fn a_late_evening_entry_belongs_to_the_day_the_user_was_living() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = user_in("alice", "Europe/Warsaw");
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    logged(&store, &user, Mood::Good, "2026-08-20T23:30:00+00:00").await;
+
+    let days = calendar_of(&store, &user).await;
+    let dates: Vec<String> = days.iter().map(|day| day.date.to_string()).collect();
+
+    assert_eq!(dates, ["2026-08-21"]);
+}
+
+#[tokio::test]
+async fn every_entry_on_a_day_moves_its_mood() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = user_in("alice", "Europe/Warsaw");
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    logged(&store, &user, Mood::Meh, "2026-08-20T08:00:00+02:00").await;
+    logged(&store, &user, Mood::Meh, "2026-08-20T12:00:00+02:00").await;
+    logged(&store, &user, Mood::Meh, "2026-08-20T16:00:00+02:00").await;
+    logged(&store, &user, Mood::Meh, "2026-08-20T20:00:00+02:00").await;
+    logged(&store, &user, Mood::Awful, "2026-08-20T23:00:00+02:00").await;
+
+    let days = calendar_of(&store, &user).await;
+    let mood = days[0].day_mood.expect("the day has entries");
+
+    assert!(mood.value() < 3.0, "the awful entry was discarded");
+}
+
+async fn tracking_cycle_from(store: &Arc<InMemoryStore>, user: &User, starts: &[&str]) {
+    let preference_deps = application::user::use_cases::set_preferences::Deps {
+        command: store.clone(),
+        query: store.clone(),
+    };
+    application::user::use_cases::set_preferences::execute(
+        user.id().clone(),
+        true,
+        &preference_deps,
+    )
+    .await
+    .unwrap();
+
+    let cycle_deps = application::cycle::use_cases::record_cycle_start::Deps {
+        command: store.clone(),
+        preferences: store.clone(),
+    };
+    for start in starts {
+        application::cycle::use_cases::record_cycle_start::execute(
+            user.id().clone(),
+            domain::entry::Date::from_persistence(start.parse().unwrap()),
+            &cycle_deps,
+        )
+        .await
+        .unwrap();
+    }
+}
+
+#[tokio::test]
+async fn a_day_carries_no_cycle_day_when_the_cycle_is_not_tracked() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = user_in("alice", "Europe/Warsaw");
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    tracking_cycle_from(&store, &user, &["2026-08-11"]).await;
+
+    let turn_off = application::user::use_cases::set_preferences::Deps {
+        command: store.clone(),
+        query: store.clone(),
+    };
+    application::user::use_cases::set_preferences::execute(user.id().clone(), false, &turn_off)
+        .await
+        .unwrap();
+
+    logged(&store, &user, Mood::Good, "2026-08-20T09:00:00+02:00").await;
+
+    let days = calendar_of(&store, &user).await;
+
+    assert!(
+        days[0].cycle_day.is_none(),
+        "a recorded start must stay invisible while tracking is off"
+    );
+}
+
+#[tokio::test]
+async fn a_tracked_day_carries_the_cycle_day_derived_for_it() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = user_in("alice", "Europe/Warsaw");
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    tracking_cycle_from(&store, &user, &["2026-08-11"]).await;
+
+    logged(&store, &user, Mood::Good, "2026-08-20T09:00:00+02:00").await;
+
+    let days = calendar_of(&store, &user).await;
+
+    assert_eq!(days[0].cycle_day.map(|day| day.value()), Some(10));
+}
+
+#[tokio::test]
+async fn a_day_before_the_first_recorded_start_has_no_cycle_day() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = user_in("alice", "Europe/Warsaw");
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    tracking_cycle_from(&store, &user, &["2026-08-25"]).await;
+
+    logged(&store, &user, Mood::Good, "2026-08-20T09:00:00+02:00").await;
+
+    let days = calendar_of(&store, &user).await;
+
+    assert!(days[0].cycle_day.is_none());
+}
+
+#[tokio::test]
+async fn correcting_a_start_changes_the_cycle_day_of_every_affected_date() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = user_in("alice", "Europe/Warsaw");
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    tracking_cycle_from(&store, &user, &["2026-08-11"]).await;
+
+    logged(&store, &user, Mood::Good, "2026-08-20T09:00:00+02:00").await;
+    logged(&store, &user, Mood::Meh, "2026-08-22T09:00:00+02:00").await;
+
+    let before: Vec<u16> = calendar_of(&store, &user)
+        .await
+        .iter()
+        .filter_map(|day| day.cycle_day.map(|cycle| cycle.value()))
+        .collect();
+
+    let forget = application::cycle::use_cases::forget_cycle_start::Deps {
+        command: store.clone(),
+    };
+    application::cycle::use_cases::forget_cycle_start::execute(
+        user.id().clone(),
+        domain::entry::Date::from_persistence("2026-08-11".parse().unwrap()),
+        &forget,
+    )
+    .await
+    .unwrap();
+    tracking_cycle_from(&store, &user, &["2026-08-13"]).await;
+
+    let after: Vec<u16> = calendar_of(&store, &user)
+        .await
+        .iter()
+        .filter_map(|day| day.cycle_day.map(|cycle| cycle.value()))
+        .collect();
+
+    assert_eq!(before, [10, 12]);
+    assert_eq!(after, [8, 10], "one correction moved both days");
+}
diff --git a/crates/application/tests/entry/create_entry_test.rs b/crates/application/tests/entry/create_entry_test.rs
index ae08466..8b457bd 100644
--- a/crates/application/tests/entry/create_entry_test.rs
+++ b/crates/application/tests/entry/create_entry_test.rs
@@ -1,15 +1,23 @@
 use std::sync::Arc;
 
+use domain::dimension::{DimensionKind, DimensionValue};
 use domain::entry::Mood;
-use domain::testing::{test_entry, test_logged_at, test_user};
+use domain::ports::EntryDimensionPort;
+use domain::testing::{InMemoryDimensionStore, InMemoryStore, test_logged_at, test_user};
 
 use application::entry::commands::CreateEntryCommand;
 use application::entry::use_cases::create_entry;
 
-fn deps() -> (Arc<domain::testing::InMemoryStore>, create_entry::Deps) {
-    let store = Arc::new(domain::testing::InMemoryStore::new());
+fn deps() -> (Arc<InMemoryStore>, create_entry::Deps) {
+    let store = Arc::new(InMemoryStore::new());
+    let content: Arc<dyn EntryDimensionPort> =
+        Arc::new(InMemoryDimensionStore::new(DimensionKind::Content));
+    let activities: Arc<dyn EntryDimensionPort> =
+        Arc::new(InMemoryDimensionStore::new(DimensionKind::Activities));
+
     let deps = create_entry::Deps {
         entries: store.clone(),
+        dimensions: vec![content, activities],
         events: store.clone(),
     };
     (store, deps)
@@ -24,10 +32,7 @@ async fn creates_entry_with_required_fields() {
         user_id: user.id().clone(),
         mood: Mood::Good,
         logged_at: test_logged_at(),
-        activities: vec![],
-        content: None,
-        photos: vec![],
-        voice_memos: vec![],
+        dimensions: vec![],
     };
 
     let entry = create_entry::execute(cmd, &deps).await.unwrap();
@@ -38,7 +43,7 @@ async fn creates_entry_with_required_fields() {
 }
 
 #[tokio::test]
-async fn creates_entry_with_all_optional_fields() {
+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");
@@ -47,16 +52,14 @@ async fn creates_entry_with_all_optional_fields() {
         user_id: user.id().clone(),
         mood: Mood::Rad,
         logged_at: test_logged_at(),
-        activities: vec![activity.id().clone()],
-        content: Some(domain::testing::test_content("great day")),
-        photos: vec![],
-        voice_memos: vec![],
+        dimensions: vec![
+            DimensionValue::Content(domain::testing::test_content("great day")),
+            DimensionValue::activities(vec![activity.id().clone()]),
+        ],
     };
 
     let entry = create_entry::execute(cmd, &deps).await.unwrap();
 
     assert_eq!(entry.mood(), Mood::Rad);
-    assert_eq!(entry.activities().len(), 1);
-    assert!(entry.content().is_some());
     assert_eq!(store.entry_count(), 1);
 }
diff --git a/crates/application/tests/entry/delete_entry_test.rs b/crates/application/tests/entry/delete_entry_test.rs
index d3f4eb5..4dbfe70 100644
--- a/crates/application/tests/entry/delete_entry_test.rs
+++ b/crates/application/tests/entry/delete_entry_test.rs
@@ -15,6 +15,7 @@ async fn deletes_existing_entry() {
     store.save(&entry).await.unwrap();
 
     let deps = delete_entry::Deps {
+        dimensions: vec![],
         command: store.clone(),
         query: store.clone(),
         events: store.clone(),
@@ -33,6 +34,7 @@ async fn deletes_existing_entry() {
 async fn deleting_nonexistent_entry_fails() {
     let store = Arc::new(InMemoryStore::new());
     let deps = delete_entry::Deps {
+        dimensions: vec![],
         command: store.clone(),
         query: store.clone(),
         events: store.clone(),
@@ -56,6 +58,7 @@ async fn rejects_delete_by_different_user() {
     store.save(&entry).await.unwrap();
 
     let deps = delete_entry::Deps {
+        dimensions: vec![],
         command: store.clone(),
         query: store.clone(),
         events: store.clone(),
diff --git a/crates/application/tests/entry/dimension_test.rs b/crates/application/tests/entry/dimension_test.rs
new file mode 100644
index 0000000..3743777
--- /dev/null
+++ b/crates/application/tests/entry/dimension_test.rs
@@ -0,0 +1,139 @@
+use std::sync::Arc;
+
+use domain::activity::ActivityId;
+use domain::attachment::{PhotoId, VoiceMemoId};
+use domain::dimension::{DimensionKind, DimensionValue};
+use domain::entry::{Mood, MoodEntry};
+use domain::ports::EntryDimensionPort;
+use domain::testing::{InMemoryDimensionStore, test_content, test_logged_at, test_user};
+
+use application::entry::commands::CreateEntryCommand;
+use application::entry::composition::EntryComposer;
+use application::entry::use_cases::create_entry;
+
+struct Dimensions {
+    content: Arc<InMemoryDimensionStore>,
+    activities: Arc<InMemoryDimensionStore>,
+    photos: Arc<InMemoryDimensionStore>,
+    voice_memos: Arc<InMemoryDimensionStore>,
+}
+
+impl Dimensions {
+    fn new() -> Self {
+        Self {
+            content: Arc::new(InMemoryDimensionStore::new(DimensionKind::Content)),
+            activities: Arc::new(InMemoryDimensionStore::new(DimensionKind::Activities)),
+            photos: Arc::new(InMemoryDimensionStore::new(DimensionKind::Photos)),
+            voice_memos: Arc::new(InMemoryDimensionStore::new(DimensionKind::VoiceMemos)),
+        }
+    }
+
+    fn ports(&self) -> Vec<Arc<dyn EntryDimensionPort>> {
+        vec![
+            self.content.clone(),
+            self.activities.clone(),
+            self.photos.clone(),
+            self.voice_memos.clone(),
+        ]
+    }
+
+    fn composer(&self) -> EntryComposer {
+        EntryComposer::new(self.ports())
+    }
+}
+
+#[tokio::test]
+async fn content_saved_for_an_entry_is_returned_when_that_entry_is_composed() {
+    let dimensions = Dimensions::new();
+    let user = test_user("alice");
+    let entry = MoodEntry::new(user.id().clone(), Mood::Good, test_logged_at());
+
+    dimensions.content.put(
+        entry.id(),
+        DimensionValue::Content(test_content("went for a walk")),
+    );
+
+    let composed = dimensions.composer().compose(vec![entry]).await.unwrap();
+
+    assert_eq!(
+        composed[0].content().map(|c| c.value()),
+        Some("went for a walk")
+    );
+}
+
+#[tokio::test]
+async fn an_entry_with_no_content_composes_with_no_dimensions() {
+    let dimensions = Dimensions::new();
+    let user = test_user("carol");
+    let entry = MoodEntry::new(user.id().clone(), Mood::Meh, test_logged_at());
+
+    let composed = dimensions.composer().compose(vec![entry]).await.unwrap();
+
+    assert!(composed[0].dimensions.is_empty());
+}
+
+#[tokio::test]
+async fn each_entry_in_a_page_composes_with_only_its_own_content() {
+    let dimensions = Dimensions::new();
+    let user = test_user("dave");
+
+    let first = MoodEntry::new(user.id().clone(), Mood::Good, test_logged_at());
+    let second = MoodEntry::new(user.id().clone(), Mood::Bad, test_logged_at());
+    let third = MoodEntry::new(user.id().clone(), Mood::Rad, test_logged_at());
+
+    dimensions
+        .content
+        .put(first.id(), DimensionValue::Content(test_content("mine")));
+    dimensions
+        .content
+        .put(third.id(), DimensionValue::Content(test_content("theirs")));
+
+    let composed = dimensions
+        .composer()
+        .compose(vec![first, second, third])
+        .await
+        .unwrap();
+
+    assert_eq!(composed[0].content().map(|c| c.value()), Some("mine"));
+    assert!(composed[1].dimensions.is_empty());
+    assert_eq!(composed[2].content().map(|c| c.value()), Some("theirs"));
+}
+
+#[tokio::test]
+async fn an_entry_composes_every_kind_of_dimension_it_has() {
+    let dimensions = Dimensions::new();
+    let store = Arc::new(domain::testing::InMemoryStore::new());
+    let user = test_user("erin");
+
+    let activity_id = ActivityId::generate();
+    let photo_id = PhotoId::generate();
+    let voice_memo_id = VoiceMemoId::generate();
+
+    let deps = create_entry::Deps {
+        entries: store.clone(),
+        dimensions: dimensions.ports(),
+        events: store.clone(),
+    };
+
+    let cmd = CreateEntryCommand {
+        user_id: user.id().clone(),
+        mood: Mood::Rad,
+        logged_at: test_logged_at(),
+        dimensions: vec![
+            DimensionValue::Content(test_content("a full day")),
+            DimensionValue::Activities(vec![activity_id.clone()]),
+            DimensionValue::Photos(vec![photo_id.clone()]),
+            DimensionValue::VoiceMemos(vec![voice_memo_id.clone()]),
+        ],
+    };
+
+    let entry = create_entry::execute(cmd, &deps).await.unwrap();
+
+    let composed = dimensions.composer().compose(vec![entry]).await.unwrap();
+    let composed = &composed[0];
+
+    assert_eq!(composed.content().map(|c| c.value()), Some("a full day"));
+    assert_eq!(composed.activities(), [activity_id]);
+    assert_eq!(composed.photos(), [photo_id]);
+    assert_eq!(composed.voice_memos(), [voice_memo_id]);
+}
diff --git a/crates/application/tests/entry/filter_test.rs b/crates/application/tests/entry/filter_test.rs
index 9deacd3..12f8025 100644
--- a/crates/application/tests/entry/filter_test.rs
+++ b/crates/application/tests/entry/filter_test.rs
@@ -44,9 +44,9 @@ async fn filters_by_activity() {
     let user = test_user("alice");
     let activity = test_activity(user.id().clone(), "exercise");
 
-    let mut tagged = test_entry(user.id().clone(), Mood::Good);
-    tagged.set_activities(vec![activity.id().clone()]);
+    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))
diff --git a/crates/application/tests/entry/mood_stats_test.rs b/crates/application/tests/entry/mood_stats_test.rs
index c16460e..845aa47 100644
--- a/crates/application/tests/entry/mood_stats_test.rs
+++ b/crates/application/tests/entry/mood_stats_test.rs
@@ -1,8 +1,9 @@
 use std::sync::Arc;
 
 use domain::entry::Mood;
-use domain::ports::MoodEntryCommandPort;
+use domain::ports::{MoodEntryCommandPort, UserCommandPort};
 use domain::testing::{InMemoryStore, test_entry_days_ago, test_user};
+use domain::user::Timezone;
 
 use application::entry::queries::MoodStatsQuery;
 use application::entry::use_cases::get_mood_stats;
@@ -10,23 +11,32 @@ use application::entry::use_cases::get_mood_stats;
 #[tokio::test]
 async fn computes_stats_across_entries() {
     let store = Arc::new(InMemoryStore::new());
-    let user = test_user("alice");
+    let user = user_in("alice", "Europe/Warsaw");
 
-    store
-        .save(&test_entry_days_ago(user.id().clone(), Mood::Good, 0))
-        .await
-        .unwrap();
-    store
-        .save(&test_entry_days_ago(user.id().clone(), Mood::Rad, 1))
-        .await
-        .unwrap();
-    store
-        .save(&test_entry_days_ago(user.id().clone(), Mood::Meh, 2))
-        .await
-        .unwrap();
+    MoodEntryCommandPort::save(
+        &*store,
+        &test_entry_days_ago(user.id().clone(), Mood::Good, 0),
+    )
+    .await
+    .unwrap();
+    MoodEntryCommandPort::save(
+        &*store,
+        &test_entry_days_ago(user.id().clone(), Mood::Rad, 1),
+    )
+    .await
+    .unwrap();
+    MoodEntryCommandPort::save(
+        &*store,
+        &test_entry_days_ago(user.id().clone(), Mood::Meh, 2),
+    )
+    .await
+    .unwrap();
+
+    UserCommandPort::save(&*store, &user).await.unwrap();
 
     let deps = get_mood_stats::Deps {
         query: store.clone(),
+        users: store.clone(),
     };
 
     let query = MoodStatsQuery {
@@ -43,14 +53,18 @@ async fn computes_stats_across_entries() {
 }
 
 #[tokio::test]
-async fn empty_entries_give_zero_stats() {
+async fn a_user_with_no_entries_has_zero_stats() {
     let store = Arc::new(InMemoryStore::new());
+    let user = user_in("newcomer", "Europe/Warsaw");
+    UserCommandPort::save(&*store, &user).await.unwrap();
+
     let deps = get_mood_stats::Deps {
         query: store.clone(),
+        users: store.clone(),
     };
 
     let query = MoodStatsQuery {
-        user_id: test_user("nobody").id().clone(),
+        user_id: user.id().clone(),
         range: None,
     };
 
@@ -60,3 +74,9 @@ async fn empty_entries_give_zero_stats() {
     assert!(stats.average.is_none());
     assert_eq!(stats.current_streak, 0);
 }
+
+fn user_in(name: &str, timezone: &str) -> domain::user::User {
+    let mut user = test_user(name);
+    user.update_timezone(Some(Timezone::new(timezone).unwrap()));
+    user
+}
diff --git a/crates/application/tests/entry/replace_activity_test.rs b/crates/application/tests/entry/replace_activity_test.rs
index d3a61db..ea6184b 100644
--- a/crates/application/tests/entry/replace_activity_test.rs
+++ b/crates/application/tests/entry/replace_activity_test.rs
@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
 use domain::activity::ActivityId;
-use domain::ports::ActivityCommandPort;
-use domain::testing::{InMemoryStore, test_activity, test_user};
-use domain::user::UserId;
+use domain::entry::Mood;
+use domain::ports::{ActivityCommandPort, MoodEntryCommandPort, MoodEntryQueryPort};
+use domain::testing::{InMemoryStore, test_activity, test_entry, test_user};
 
 use application::entry::use_cases::replace_activity;
 
@@ -13,18 +13,27 @@ async fn replaces_activity_on_entries() {
     let user = test_user("alice");
     let old = test_activity(user.id().clone(), "gaming");
     let new = test_activity(user.id().clone(), "video games");
-    store.save(&old).await.unwrap();
-    store.save(&new).await.unwrap();
+    ActivityCommandPort::save(&*store, &old).await.unwrap();
+    ActivityCommandPort::save(&*store, &new).await.unwrap();
+
+    let entry = test_entry(user.id().clone(), Mood::Good);
+    MoodEntryCommandPort::save(&*store, &entry).await.unwrap();
+    store.assign_activities(entry.id(), vec![old.id().clone()]);
 
     let deps = replace_activity::Deps {
         entry_command: store.clone(),
         activity_query: store.clone(),
     };
 
-    let result =
-        replace_activity::execute(user.id().clone(), old.id().clone(), new.id().clone(), &deps)
-            .await;
-    assert!(result.is_ok());
+    replace_activity::execute(user.id().clone(), old.id().clone(), new.id().clone(), &deps)
+        .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();
+
+    assert_eq!(now_tagged_new.len(), 1);
+    assert!(still_tagged_old.is_empty());
 }
 
 #[tokio::test]
@@ -53,7 +62,9 @@ async fn rejects_target_owned_by_different_user() {
     let alice = test_user("alice");
     let bob = test_user("bob");
     let bobs_activity = test_activity(bob.id().clone(), "gaming");
-    store.save(&bobs_activity).await.unwrap();
+    ActivityCommandPort::save(&*store, &bobs_activity)
+        .await
+        .unwrap();
 
     let deps = replace_activity::Deps {
         entry_command: store.clone(),
diff --git a/crates/application/tests/entry/update_entry_test.rs b/crates/application/tests/entry/update_entry_test.rs
index cf591d2..76ebf2b 100644
--- a/crates/application/tests/entry/update_entry_test.rs
+++ b/crates/application/tests/entry/update_entry_test.rs
@@ -1,8 +1,14 @@
 use std::sync::Arc;
 
+use chrono::{FixedOffset, TimeZone};
+
+use domain::dimension::DimensionKind;
 use domain::entry::Mood;
+use domain::ports::EntryDimensionPort;
 use domain::ports::MoodEntryCommandPort;
-use domain::testing::{InMemoryStore, test_entry, test_logged_at, test_user};
+use domain::testing::{
+    InMemoryDimensionStore, InMemoryStore, test_entry, test_logged_at, test_user,
+};
 use domain::user::UserId;
 
 use application::entry::commands::UpdateEntryCommand;
@@ -21,6 +27,10 @@ async fn setup() -> (
 
     let deps = update_entry::Deps {
         command: store.clone(),
+        dimensions: vec![
+            Arc::new(InMemoryDimensionStore::new(DimensionKind::Content))
+                as Arc<dyn EntryDimensionPort>,
+        ],
         query: store.clone(),
         media_storage: store.clone(),
         events: store.clone(),
@@ -36,11 +46,8 @@ async fn updates_mood() {
     let cmd = UpdateEntryCommand {
         entry_id: entry.id().clone(),
         mood: Mood::Rad,
-        logged_at: test_logged_at(),
-        activities: vec![],
-        content: None,
-        photos: vec![],
-        voice_memos: vec![],
+        logged_at: Some(test_logged_at()),
+        dimensions: vec![],
     };
 
     let updated = update_entry::execute(cmd, user_id, &deps).await.unwrap();
@@ -54,6 +61,10 @@ async fn updating_nonexistent_entry_fails() {
     let store = Arc::new(InMemoryStore::new());
     let deps = update_entry::Deps {
         command: store.clone(),
+        dimensions: vec![
+            Arc::new(InMemoryDimensionStore::new(DimensionKind::Content))
+                as Arc<dyn EntryDimensionPort>,
+        ],
         query: store.clone(),
         media_storage: store.clone(),
         events: store.clone(),
@@ -62,11 +73,8 @@ async fn updating_nonexistent_entry_fails() {
     let cmd = UpdateEntryCommand {
         entry_id: domain::entry::MoodEntryId::generate(),
         mood: Mood::Good,
-        logged_at: test_logged_at(),
-        activities: vec![],
-        content: None,
-        photos: vec![],
-        voice_memos: vec![],
+        logged_at: Some(test_logged_at()),
+        dimensions: vec![],
     };
 
     let result = update_entry::execute(cmd, UserId::generate(), &deps).await;
@@ -80,14 +88,48 @@ async fn rejects_update_by_different_user() {
     let cmd = UpdateEntryCommand {
         entry_id: entry.id().clone(),
         mood: Mood::Rad,
-        logged_at: test_logged_at(),
-        activities: vec![],
-        content: None,
-        photos: vec![],
-        voice_memos: vec![],
+        logged_at: Some(test_logged_at()),
+        dimensions: vec![],
     };
 
     let other_user = UserId::generate();
     let result = update_entry::execute(cmd, other_user, &deps).await;
     assert!(result.is_err());
 }
+
+#[tokio::test]
+async fn an_update_carrying_no_date_leaves_the_entry_where_it_was() {
+    let (_store, deps, entry, user_id) = setup().await;
+
+    let cmd = UpdateEntryCommand {
+        entry_id: entry.id().clone(),
+        mood: Mood::Rad,
+        logged_at: None,
+        dimensions: vec![],
+    };
+
+    let updated = update_entry::execute(cmd, user_id, &deps).await.unwrap();
+
+    assert_eq!(updated.logged_at(), &test_logged_at());
+}
+
+#[tokio::test]
+async fn an_update_carrying_a_date_moves_the_entry_to_it() {
+    let (_store, deps, entry, user_id) = setup().await;
+
+    let moved_to = FixedOffset::east_opt(3600)
+        .unwrap()
+        .with_ymd_and_hms(2024, 1, 2, 9, 30, 0)
+        .unwrap();
+
+    let cmd = UpdateEntryCommand {
+        entry_id: entry.id().clone(),
+        mood: Mood::Rad,
+        logged_at: Some(moved_to),
+        dimensions: vec![],
+    };
+
+    let updated = update_entry::execute(cmd, user_id, &deps).await.unwrap();
+
+    assert_eq!(updated.logged_at(), &moved_to);
+}
diff --git a/crates/application/tests/import.rs b/crates/application/tests/import.rs
new file mode 100644
index 0000000..995c7c8
--- /dev/null
+++ b/crates/application/tests/import.rs
@@ -0,0 +1,5 @@
+#[path = "import/daily_metric_import_test.rs"]
+mod daily_metric_import_test;
+
+#[path = "import/wall_clock_test.rs"]
+mod wall_clock_test;
diff --git a/crates/application/tests/import/daily_metric_import_test.rs b/crates/application/tests/import/daily_metric_import_test.rs
new file mode 100644
index 0000000..bd99abc
--- /dev/null
+++ b/crates/application/tests/import/daily_metric_import_test.rs
@@ -0,0 +1,319 @@
+use std::sync::Arc;
+
+use domain::entry::{Date, DateSpan};
+use domain::metric::{MetricValue, Source, Steps};
+use domain::ports::{
+    DailyMetricCommandPort, DailyMetricQueryPort, RejectionQueryPort, UserCommandPort,
+};
+use domain::provider::ProviderName;
+use domain::rejection::RejectionOrigin;
+use domain::testing::{InMemoryStore, test_user};
+use domain::user::{Timezone, User};
+
+use application::import::commands::{ImportDailyMetricsCommand, ImportedDay, ImportedMetric};
+use application::import::use_cases::import_daily_metrics::{self, ImportOutcome};
+
+const DAY_LIMIT: usize = 90;
+
+async fn a_user_in_warsaw(store: &Arc<InMemoryStore>) -> User {
+    let mut user = test_user("alice");
+    user.update_timezone(Some(Timezone::new("Europe/Warsaw").unwrap()));
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    user
+}
+
+fn healthkit() -> ProviderName {
+    ProviderName::new("healthkit").unwrap()
+}
+
+fn metric(kind: &str, value: Option<i64>) -> ImportedMetric {
+    ImportedMetric {
+        kind: kind.to_string(),
+        value,
+    }
+}
+
+fn day(date: &str, metrics: Vec<ImportedMetric>) -> ImportedDay {
+    ImportedDay {
+        date: date.to_string(),
+        metrics,
+    }
+}
+
+async fn import(
+    store: &Arc<InMemoryStore>,
+    user: &User,
+    days: Vec<ImportedDay>,
+) -> Result<ImportOutcome, application::errors::ApplicationError> {
+    let deps = import_daily_metrics::Deps {
+        metrics: store.clone(),
+        rejections: store.clone(),
+    };
+
+    import_daily_metrics::execute(
+        ImportDailyMetricsCommand {
+            user_id: user.id().clone(),
+            provider: healthkit(),
+            days,
+            maximum_days: DAY_LIMIT,
+        },
+        &deps,
+    )
+    .await
+}
+
+async fn stored(store: &Arc<InMemoryStore>, user: &User, from: &str, to: &str) -> Vec<String> {
+    let span = DateSpan::new(
+        Date::from_persistence(from.parse().unwrap()),
+        Date::from_persistence(to.parse().unwrap()),
+    )
+    .unwrap();
+
+    let metrics = DailyMetricQueryPort::find_by_span(store.as_ref(), user.id(), &span)
+        .await
+        .unwrap();
+
+    let mut described: Vec<String> = metrics
+        .iter()
+        .map(|metric| {
+            format!(
+                "{} {} {}",
+                metric.date(),
+                metric.kind().name(),
+                metric.value().count()
+            )
+        })
+        .collect();
+    described.sort();
+    described
+}
+
+#[tokio::test]
+async fn a_whole_day_of_readings_is_stored_under_the_providers_name() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    let outcome = import(
+        &store,
+        &user,
+        vec![day(
+            "2026-08-20",
+            vec![
+                metric("steps", Some(8_412)),
+                metric("sleepMinutes", Some(447)),
+            ],
+        )],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(outcome.accepted, 2);
+    assert!(outcome.rejected.is_empty());
+    assert_eq!(
+        stored(&store, &user, "2026-08-20", "2026-08-20").await,
+        ["2026-08-20 sleepMinutes 447", "2026-08-20 steps 8412"]
+    );
+}
+
+#[tokio::test]
+async fn one_bad_reading_does_not_cost_the_good_ones() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    let outcome = import(
+        &store,
+        &user,
+        vec![day(
+            "2026-08-20",
+            vec![
+                metric("steps", Some(8_412)),
+                metric("hrv", Some(9_999)),
+                metric("sleepMinutes", Some(447)),
+            ],
+        )],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(outcome.accepted, 2);
+    assert_eq!(outcome.rejected.len(), 1);
+    assert_eq!(outcome.rejected[0].kind, "hrv");
+    assert!(outcome.rejected[0].reason.contains("between"));
+    assert_eq!(
+        stored(&store, &user, "2026-08-20", "2026-08-20").await,
+        ["2026-08-20 sleepMinutes 447", "2026-08-20 steps 8412"]
+    );
+}
+
+#[tokio::test]
+async fn a_rejection_is_written_where_the_user_can_find_it() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    import(
+        &store,
+        &user,
+        vec![day("2026-08-20", vec![metric("hrv", Some(9_999))])],
+    )
+    .await
+    .unwrap();
+
+    let trace = RejectionQueryPort::find_recent_by_user(store.as_ref(), user.id())
+        .await
+        .unwrap();
+
+    assert_eq!(trace.len(), 1);
+    assert_eq!(trace[0].origin(), RejectionOrigin::Import);
+    assert_eq!(trace[0].detail().kind(), "hrv");
+    assert_eq!(trace[0].detail().value(), Some(9_999));
+    assert_eq!(trace[0].detail().provider(), Some(&healthkit()));
+}
+
+#[tokio::test]
+async fn a_kind_this_build_does_not_know_is_recorded_rather_than_dropped() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    let outcome = import(
+        &store,
+        &user,
+        vec![day(
+            "2026-08-20",
+            vec![metric("bloodOxygen", Some(98)), metric("steps", Some(500))],
+        )],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(outcome.accepted, 1);
+    assert_eq!(outcome.rejected.len(), 1);
+    assert!(outcome.rejected[0].reason.contains("unknown"));
+
+    let trace = RejectionQueryPort::find_recent_by_user(store.as_ref(), user.id())
+        .await
+        .unwrap();
+    assert_eq!(trace[0].detail().kind(), "bloodOxygen");
+}
+
+#[tokio::test]
+async fn an_unreadable_date_costs_only_that_day() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    let outcome = import(
+        &store,
+        &user,
+        vec![
+            day("yesterday", vec![metric("steps", Some(100))]),
+            day("2026-08-20", vec![metric("steps", Some(8_412))]),
+        ],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(outcome.accepted, 1);
+    assert_eq!(outcome.rejected.len(), 1);
+    assert!(outcome.rejected[0].reason.contains("date"));
+    assert_eq!(
+        stored(&store, &user, "2026-08-01", "2026-08-31").await,
+        ["2026-08-20 steps 8412"]
+    );
+}
+
+#[tokio::test]
+async fn an_importer_may_not_clear_a_reading_and_is_told_why() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    let outcome = import(
+        &store,
+        &user,
+        vec![day("2026-08-20", vec![metric("steps", None)])],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(outcome.accepted, 0);
+    assert_eq!(outcome.rejected.len(), 1);
+    assert!(outcome.rejected[0].reason.contains("clear"));
+}
+
+#[tokio::test]
+async fn what_the_user_stated_by_hand_is_reported_as_superseding_the_import() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    let stated = domain::metric::DailyMetric::new(
+        user.id().clone(),
+        Date::from_persistence("2026-08-20".parse().unwrap()),
+        MetricValue::Steps(Steps::new(8_412).unwrap()),
+        Source::Manual,
+    );
+    DailyMetricCommandPort::save(store.as_ref(), &[stated])
+        .await
+        .unwrap();
+
+    let outcome = import(
+        &store,
+        &user,
+        vec![day("2026-08-20", vec![metric("steps", Some(1))])],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(outcome.accepted, 0);
+    assert_eq!(outcome.superseded, 1);
+    assert!(
+        outcome.rejected.is_empty(),
+        "being superseded is not a rejection"
+    );
+    assert_eq!(
+        stored(&store, &user, "2026-08-20", "2026-08-20").await,
+        ["2026-08-20 steps 8412"]
+    );
+}
+
+#[tokio::test]
+async fn a_backfill_longer_than_the_limit_is_refused_outright() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    let days: Vec<ImportedDay> = (1..=DAY_LIMIT + 1)
+        .map(|number| {
+            day(
+                &format!("2026-01-{:02}", (number % 28) + 1),
+                vec![metric("steps", Some(100))],
+            )
+        })
+        .collect();
+
+    let refused = import(&store, &user, days).await.unwrap_err();
+
+    assert!(refused.to_string().contains("90"), "got {refused}");
+    assert!(
+        stored(&store, &user, "2026-01-01", "2026-12-31")
+            .await
+            .is_empty()
+    );
+}
+
+#[tokio::test]
+async fn posting_the_same_day_again_replaces_rather_than_duplicates() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in_warsaw(&store).await;
+
+    for count in [8_000, 8_412] {
+        import(
+            &store,
+            &user,
+            vec![day("2026-08-20", vec![metric("steps", Some(count))])],
+        )
+        .await
+        .unwrap();
+    }
+
+    assert_eq!(
+        stored(&store, &user, "2026-08-20", "2026-08-20").await,
+        ["2026-08-20 steps 8412"]
+    );
+}
diff --git a/crates/application/tests/import/wall_clock_test.rs b/crates/application/tests/import/wall_clock_test.rs
new file mode 100644
index 0000000..a7c43d5
--- /dev/null
+++ b/crates/application/tests/import/wall_clock_test.rs
@@ -0,0 +1,196 @@
+use std::sync::Arc;
+
+use domain::ports::{ImportSourcePort, ImportedRow, MoodEntryQueryPort, UserCommandPort};
+use domain::testing::{InMemoryStore, test_user};
+use domain::user::{Timezone, User};
+
+use application::import::commands::ImportCommand;
+use application::import::use_cases::import_entries;
+
+struct StubDaylio(Vec<(String, String, u8)>);
+
+#[async_trait::async_trait]
+impl ImportSourcePort for StubDaylio {
+    async fn read_entries(
+        &self,
+        _data: &[u8],
+    ) -> Result<Vec<ImportedRow>, domain::errors::DomainError> {
+        Ok(self
+            .0
+            .iter()
+            .map(|(date, time, mood)| ImportedRow {
+                mood: *mood,
+                date: date.clone(),
+                time: time.clone(),
+                activities: Vec::new(),
+                note: None,
+            })
+            .collect())
+    }
+}
+
+async fn a_user_in(store: &Arc<InMemoryStore>, zone: Option<&str>) -> User {
+    let mut user = test_user("alice");
+    user.update_timezone(zone.map(|zone| Timezone::new(zone).unwrap()));
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    user
+}
+
+async fn import(
+    store: &Arc<InMemoryStore>,
+    user: &User,
+    rows: Vec<(String, String, u8)>,
+) -> Result<
+    application::import::use_cases::import_entries::ImportResult,
+    application::errors::ApplicationError,
+> {
+    let deps = import_entries::Deps {
+        source: Arc::new(StubDaylio(rows)),
+        entry_command: store.clone(),
+        entry_query: store.clone(),
+        activity_command: store.clone(),
+        activity_query: store.clone(),
+        dimensions: Vec::new(),
+        users: store.clone(),
+        preset: config::PresetConfig::default(),
+    };
+
+    import_entries::execute(
+        ImportCommand {
+            user_id: user.id().clone(),
+            data: Vec::new(),
+        },
+        &deps,
+    )
+    .await
+}
+
+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();
+    held.sort();
+
+    held
+}
+
+#[tokio::test]
+async fn an_eight_pm_entry_is_eight_pm_where_the_user_lives() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in(&store, Some("Europe/Warsaw")).await;
+
+    import(
+        &store,
+        &user,
+        vec![("2026-08-25".into(), "8:00 PM".into(), 3)],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        instants_of(&store, &user).await,
+        ["2026-08-25T20:00:00+02:00"],
+        "a wall clock time with no zone is the user's own wall clock"
+    );
+}
+
+#[tokio::test]
+async fn the_offset_follows_daylight_saving_rather_than_being_fixed() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in(&store, Some("Europe/Warsaw")).await;
+
+    import(
+        &store,
+        &user,
+        vec![
+            ("2026-01-15".into(), "8:00 PM".into(), 3),
+            ("2026-07-15".into(), "8:00 PM".into(), 4),
+        ],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        instants_of(&store, &user).await,
+        ["2026-01-15T20:00:00+01:00", "2026-07-15T20:00:00+02:00"],
+        "winter is one hour ahead of UTC in Warsaw, summer is two"
+    );
+}
+
+#[tokio::test]
+async fn a_twenty_four_hour_clock_is_read_the_same_way() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in(&store, Some("Europe/Warsaw")).await;
+
+    import(
+        &store,
+        &user,
+        vec![("2026-08-25".into(), "20:00".into(), 3)],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        instants_of(&store, &user).await,
+        ["2026-08-25T20:00:00+02:00"]
+    );
+}
+
+#[tokio::test]
+async fn an_account_with_no_timezone_cannot_place_a_wall_clock_time() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in(&store, None).await;
+
+    let refused = import(
+        &store,
+        &user,
+        vec![("2026-08-25".into(), "8:00 PM".into(), 3)],
+    )
+    .await
+    .unwrap_err();
+
+    assert!(
+        refused.to_string().contains("timezone"),
+        "importing silently into the wrong hour is worse than asking: {refused}"
+    );
+    assert!(instants_of(&store, &user).await.is_empty());
+}
+
+#[tokio::test]
+async fn an_hour_that_daylight_saving_skips_is_still_imported() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in(&store, Some("Europe/Warsaw")).await;
+
+    let outcome = import(
+        &store,
+        &user,
+        vec![("2026-03-29".into(), "2:30 AM".into(), 3)],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        outcome.imported, 1,
+        "the clocks skip 2:30 that night, and the entry must still land somewhere sensible"
+    );
+    assert_eq!(instants_of(&store, &user).await.len(), 1);
+}
+
+#[tokio::test]
+async fn importing_the_same_export_twice_does_not_duplicate_anything() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = a_user_in(&store, Some("Europe/Warsaw")).await;
+    let rows = vec![("2026-08-25".into(), "8:00 PM".into(), 3)];
+
+    import(&store, &user, rows.clone()).await.unwrap();
+    let again = import(&store, &user, rows).await.unwrap();
+
+    assert_eq!(again.imported, 0);
+    assert_eq!(again.skipped, 1);
+    assert_eq!(instants_of(&store, &user).await.len(), 1);
+}
diff --git a/crates/application/tests/job.rs b/crates/application/tests/job.rs
new file mode 100644
index 0000000..2bda767
--- /dev/null
+++ b/crates/application/tests/job.rs
@@ -0,0 +1,2 @@
+#[path = "job/queue_test.rs"]
+mod queue_test;
diff --git a/crates/application/tests/job/queue_test.rs b/crates/application/tests/job/queue_test.rs
new file mode 100644
index 0000000..5cb7853
--- /dev/null
+++ b/crates/application/tests/job/queue_test.rs
@@ -0,0 +1,394 @@
+use std::sync::Arc;
+
+use domain::entry::{Mood, MoodEntry, MoodEntryId};
+use domain::job::{JobKind, JobStatus};
+use domain::ports::{JobQueueCommandPort, JobQueueQueryPort};
+use domain::song::RecordingId;
+use domain::testing::{FakeRecordingLookup, InMemoryStore};
+use domain::user::UserId;
+
+use application::job::use_cases::{run_due_jobs, sweep_recording_backlog, sweep_weather_backlog};
+
+const MOST_ATTEMPTS: u32 = 3;
+
+struct Bench {
+    store: Arc<InMemoryStore>,
+    lookups: Arc<FakeRecordingLookup>,
+}
+
+fn a_bench() -> Bench {
+    Bench {
+        store: Arc::new(InMemoryStore::new()),
+        lookups: Arc::new(FakeRecordingLookup::finding(None)),
+    }
+}
+
+impl Bench {
+    async fn an_unidentified_song(&self, title: &str) -> MoodEntryId {
+        let entry = MoodEntry::new(UserId::generate(), Mood::Good, test_instant());
+        domain::ports::MoodEntryCommandPort::save(self.store.as_ref(), &entry)
+            .await
+            .unwrap();
+
+        self.store
+            .put_unidentified_song(entry.id(), title, "Massive Attack");
+
+        entry.id().clone()
+    }
+
+    async fn sweep(&self) -> usize {
+        let deps = sweep_recording_backlog::Deps {
+            backlog: self.store.clone(),
+            queue: self.store.clone(),
+        };
+
+        sweep_recording_backlog::execute(200, &deps).await.unwrap()
+    }
+
+    async fn work(&self) -> run_due_jobs::Worked {
+        let deps = run_due_jobs::Deps {
+            queue: self.store.clone(),
+            backfill: self.store.clone(),
+            recordings: self.lookups.clone(),
+            places: self.store.clone(),
+            weather: None,
+            weather_store: Arc::new(domain::testing::InMemoryDimensionStore::new(
+                domain::dimension::DimensionKind::Weather,
+            )),
+        };
+
+        run_due_jobs::execute(10, MOST_ATTEMPTS, &deps)
+            .await
+            .unwrap()
+    }
+
+    async fn queued(&self) -> Vec<domain::job::Job> {
+        self.store.every_job()
+    }
+
+    async fn exhausted(&self) -> Vec<domain::job::Job> {
+        JobQueueQueryPort::find_exhausted(self.store.as_ref(), 50)
+            .await
+            .unwrap()
+    }
+}
+
+fn test_instant() -> chrono::DateTime<chrono::FixedOffset> {
+    chrono::DateTime::parse_from_rfc3339("2026-08-20T21:30:00+02:00").unwrap()
+}
+
+#[tokio::test]
+async fn a_song_with_no_recording_identity_is_swept_onto_the_queue() {
+    let bench = a_bench();
+    bench.an_unidentified_song("Teardrop").await;
+
+    let enqueued = bench.sweep().await;
+
+    assert_eq!(enqueued, 1);
+    let queued = bench.queued().await;
+    assert_eq!(queued.len(), 1);
+    assert_eq!(queued[0].kind(), JobKind::BackfillRecordingIdentity);
+    assert_eq!(queued[0].status(), JobStatus::Pending);
+}
+
+#[tokio::test]
+async fn sweeping_twice_does_not_queue_the_same_work_twice() {
+    let bench = a_bench();
+    bench.an_unidentified_song("Teardrop").await;
+
+    bench.sweep().await;
+    let again = bench.sweep().await;
+
+    assert_eq!(again, 0, "the work was already queued");
+    assert_eq!(bench.queued().await.len(), 1);
+}
+
+#[tokio::test]
+async fn the_sweep_is_bounded_by_what_it_is_asked_for() {
+    let bench = a_bench();
+    for number in 0..10 {
+        bench.an_unidentified_song(&format!("song {number}")).await;
+    }
+
+    let deps = sweep_recording_backlog::Deps {
+        backlog: bench.store.clone(),
+        queue: bench.store.clone(),
+    };
+    let enqueued = sweep_recording_backlog::execute(4, &deps).await.unwrap();
+
+    assert_eq!(enqueued, 4);
+}
+
+#[tokio::test]
+async fn a_job_that_succeeds_leaves_the_queue_and_records_the_identity() {
+    let bench = a_bench();
+    let found = RecordingId::new("8f3471b5-7e6a-4dbe-9c6b-1e56a5ed2f6d").unwrap();
+    let bench = Bench {
+        lookups: Arc::new(FakeRecordingLookup::finding(Some(found.clone()))),
+        ..bench
+    };
+    let entry_id = bench.an_unidentified_song("Teardrop").await;
+    bench.sweep().await;
+
+    let worked = bench.work().await;
+
+    assert_eq!(worked.finished, 1);
+    assert_eq!(worked.failed, 0);
+    assert!(bench.queued().await.is_empty(), "a finished job is gone");
+    assert_eq!(bench.store.recording_of(&entry_id), Some(found));
+}
+
+#[tokio::test]
+async fn a_lookup_that_finds_nothing_still_finishes_the_job() {
+    let bench = a_bench();
+    bench.an_unidentified_song("Teardrop").await;
+    bench.sweep().await;
+
+    let worked = bench.work().await;
+
+    assert_eq!(worked.finished, 1, "nothing to find is not a failure");
+    assert!(bench.queued().await.is_empty());
+}
+
+#[tokio::test]
+async fn a_failing_job_goes_back_to_the_queue_with_the_reason_recorded() {
+    let bench = Bench {
+        lookups: Arc::new(FakeRecordingLookup::failing("musicbrainz is unreachable")),
+        ..a_bench()
+    };
+    bench.an_unidentified_song("Teardrop").await;
+    bench.sweep().await;
+
+    let worked = bench.work().await;
+
+    assert_eq!(worked.failed, 1);
+    let queued = bench.queued().await;
+    assert_eq!(queued[0].status(), JobStatus::Pending);
+    assert_eq!(queued[0].attempts(), 1);
+    assert!(
+        queued[0].last_error().unwrap().contains("unreachable"),
+        "got {:?}",
+        queued[0].last_error()
+    );
+}
+
+#[tokio::test]
+async fn a_job_that_keeps_failing_stops_being_retried_but_stays_visible() {
+    let bench = Bench {
+        lookups: Arc::new(FakeRecordingLookup::failing("musicbrainz is unreachable")),
+        ..a_bench()
+    };
+    bench.an_unidentified_song("Teardrop").await;
+    bench.sweep().await;
+
+    for _ in 0..MOST_ATTEMPTS {
+        bench.work().await;
+    }
+
+    let after_giving_up = bench.work().await;
+
+    assert_eq!(
+        after_giving_up.finished + after_giving_up.failed,
+        0,
+        "an exhausted job is not claimed again"
+    );
+
+    let exhausted = bench.exhausted().await;
+    assert_eq!(exhausted.len(), 1);
+    assert_eq!(exhausted[0].attempts(), MOST_ATTEMPTS);
+    assert!(exhausted[0].last_error().is_some());
+}
+
+#[tokio::test]
+async fn work_lost_to_a_crash_is_found_again_by_the_sweep() {
+    let bench = a_bench();
+    bench.an_unidentified_song("Teardrop").await;
+    bench.sweep().await;
+
+    bench.store.lose_every_job();
+    assert!(bench.queued().await.is_empty(), "the queue was wiped");
+
+    let enqueued = bench.sweep().await;
+
+    assert_eq!(
+        enqueued, 1,
+        "the sweep rediscovered it from the entry itself"
+    );
+}
+
+#[tokio::test]
+async fn a_job_left_running_by_a_dead_worker_is_reclaimed() {
+    let bench = a_bench();
+    bench.an_unidentified_song("Teardrop").await;
+    bench.sweep().await;
+
+    JobQueueCommandPort::claim(bench.store.as_ref(), JobKind::BackfillRecordingIdentity, 10)
+        .await
+        .unwrap();
+    assert_eq!(bench.queued().await[0].status(), JobStatus::Running);
+
+    let reclaimed = JobQueueCommandPort::reclaim_stalled(bench.store.as_ref(), 0)
+        .await
+        .unwrap();
+
+    assert_eq!(reclaimed, 1);
+    assert_eq!(bench.queued().await[0].status(), JobStatus::Pending);
+}
+
+use domain::dimension::DimensionKind;
+use domain::location::Coordinates;
+use domain::provider::ProviderName;
+use domain::testing::{FakeWeatherLookup, InMemoryDimensionStore};
+use domain::weather::{Celsius, Condition, Weather};
+
+struct WeatherBench {
+    store: Arc<InMemoryStore>,
+    lookup: Arc<FakeWeatherLookup>,
+    weather_store: Arc<InMemoryDimensionStore>,
+    switched_on: bool,
+}
+
+fn a_downpour() -> Weather {
+    Weather::new(
+        Condition::Rain,
+        Celsius::new(11.5).unwrap(),
+        ProviderName::new("open-meteo").unwrap(),
+    )
+}
+
+fn a_weather_bench(lookup: FakeWeatherLookup, switched_on: bool) -> WeatherBench {
+    WeatherBench {
+        store: Arc::new(InMemoryStore::new()),
+        lookup: Arc::new(lookup),
+        weather_store: Arc::new(InMemoryDimensionStore::new(DimensionKind::Weather)),
+        switched_on,
+    }
+}
+
+impl WeatherBench {
+    async fn a_place_with_no_weather(&self) -> MoodEntryId {
+        let entry = MoodEntry::new(UserId::generate(), Mood::Good, test_instant());
+        domain::ports::MoodEntryCommandPort::save(self.store.as_ref(), &entry)
+            .await
+            .unwrap();
+
+        self.store.put_place_without_weather(
+            entry.id(),
+            Coordinates::new(52.2297, 21.0122).unwrap(),
+            test_instant(),
+        );
+
+        entry.id().clone()
+    }
+
+    async fn sweep(&self) -> usize {
+        let deps = sweep_weather_backlog::Deps {
+            backlog: self.store.clone(),
+            queue: self.store.clone(),
+        };
+
+        sweep_weather_backlog::execute(200, &deps).await.unwrap()
+    }
+
+    async fn work(&self) -> run_due_jobs::Worked {
+        let deps = run_due_jobs::Deps {
+            queue: self.store.clone(),
+            backfill: self.store.clone(),
+            recordings: Arc::new(FakeRecordingLookup::finding_nothing()),
+            places: self.store.clone(),
+            weather: self
+                .switched_on
+                .then(|| self.lookup.clone() as Arc<dyn domain::ports::WeatherLookupPort>),
+            weather_store: self.weather_store.clone(),
+        };
+
+        run_due_jobs::execute(10, MOST_ATTEMPTS, &deps)
+            .await
+            .unwrap()
+    }
+
+    async fn stored_weather(&self, entry_id: &MoodEntryId) -> Option<Weather> {
+        let held = domain::ports::EntryDimensionPort::load(
+            self.weather_store.as_ref(),
+            std::slice::from_ref(entry_id),
+        )
+        .await
+        .unwrap();
+
+        match held.get(entry_id) {
+            Some(domain::dimension::DimensionValue::Weather(weather)) => Some(weather.clone()),
+            _ => None,
+        }
+    }
+}
+
+#[tokio::test]
+async fn a_place_with_no_weather_is_swept_onto_the_queue_and_observed() {
+    let bench = a_weather_bench(FakeWeatherLookup::observing(Some(a_downpour())), true);
+    let entry_id = bench.a_place_with_no_weather().await;
+
+    assert_eq!(bench.sweep().await, 1);
+    let worked = bench.work().await;
+
+    assert_eq!(worked.finished, 1);
+    let observed = bench.stored_weather(&entry_id).await.expect("weather");
+    assert_eq!(observed.condition(), Condition::Rain);
+    assert_eq!(observed.observed_by().value(), "open-meteo");
+}
+
+#[tokio::test]
+async fn nothing_leaves_the_box_when_weather_lookups_are_switched_off() {
+    let bench = a_weather_bench(FakeWeatherLookup::observing(Some(a_downpour())), false);
+    let entry_id = bench.a_place_with_no_weather().await;
+    bench.sweep().await;
+
+    let worked = bench.work().await;
+
+    assert_eq!(worked.failed, 1, "the job cannot be done, and says so");
+    assert_eq!(
+        bench.lookup.times_asked(),
+        0,
+        "the provider was never asked"
+    );
+    assert!(bench.stored_weather(&entry_id).await.is_none());
+    assert!(
+        bench.queued().await[0]
+            .last_error()
+            .unwrap()
+            .contains("switched off"),
+        "got {:?}",
+        bench.queued().await[0].last_error()
+    );
+}
+
+#[tokio::test]
+async fn a_provider_that_has_no_reading_for_a_place_does_not_fail_the_job() {
+    let bench = a_weather_bench(FakeWeatherLookup::observing(None), true);
+    let entry_id = bench.a_place_with_no_weather().await;
+    bench.sweep().await;
+
+    let worked = bench.work().await;
+
+    assert_eq!(worked.finished, 1);
+    assert!(bench.stored_weather(&entry_id).await.is_none());
+}
+
+#[tokio::test]
+async fn an_unreachable_provider_leaves_the_job_to_be_retried() {
+    let bench = a_weather_bench(FakeWeatherLookup::failing("open-meteo timed out"), true);
+    bench.a_place_with_no_weather().await;
+    bench.sweep().await;
+
+    let worked = bench.work().await;
+
+    assert_eq!(worked.failed, 1);
+    let queued = bench.queued().await;
+    assert_eq!(queued[0].attempts(), 1);
+    assert!(queued[0].last_error().unwrap().contains("timed out"));
+}
+
+impl WeatherBench {
+    async fn queued(&self) -> Vec<domain::job::Job> {
+        self.store.every_job()
+    }
+}
diff --git a/crates/application/tests/metric.rs b/crates/application/tests/metric.rs
new file mode 100644
index 0000000..707b491
--- /dev/null
+++ b/crates/application/tests/metric.rs
@@ -0,0 +1,2 @@
+#[path = "metric/daily_metric_test.rs"]
+mod daily_metric_test;
diff --git a/crates/application/tests/metric/daily_metric_test.rs b/crates/application/tests/metric/daily_metric_test.rs
new file mode 100644
index 0000000..fadfe5e
--- /dev/null
+++ b/crates/application/tests/metric/daily_metric_test.rs
@@ -0,0 +1,725 @@
+use std::sync::Arc;
+
+use domain::entry::{Date, DateSpan};
+use domain::metric::{
+    AlcoholicDrinks, AwakeMinutes, DailyMetric, ExerciseMinutes, Hrv, MetricKind, MetricValue,
+    RestingHeartRate, ScreenTimeMinutes, SleepMinutes, Source, Steps,
+};
+use domain::ports::{
+    CascadeDeletePort, DailyMetricCommandPort, DailyMetricQueryPort, UserCommandPort, UserQueryPort,
+};
+use domain::provider::ProviderName;
+use domain::testing::{InMemoryStore, test_user};
+use domain::user::{Timezone, UserId};
+
+use application::metric::commands::{MetricChange, SetDailyMetricsCommand};
+use application::metric::use_cases::{list_daily_metrics, set_daily_metrics};
+
+async fn a_user_in_warsaw(store: &Arc<InMemoryStore>) -> UserId {
+    let mut user = test_user("alice");
+    user.update_timezone(Some(Timezone::new("Europe/Warsaw").unwrap()));
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+    user.id().clone()
+}
+
+fn set_deps(store: &Arc<InMemoryStore>) -> set_daily_metrics::Deps {
+    set_daily_metrics::Deps {
+        metrics: store.clone() as Arc<dyn DailyMetricCommandPort>,
+        users: store.clone() as Arc<dyn UserQueryPort>,
+    }
+}
+
+fn list_deps(store: &Arc<InMemoryStore>) -> list_daily_metrics::Deps {
+    list_daily_metrics::Deps {
+        metrics: store.clone() as Arc<dyn DailyMetricQueryPort>,
+    }
+}
+
+fn on(day: &str) -> Date {
+    Date::from_persistence(day.parse().unwrap())
+}
+
+fn steps(count: u32) -> MetricValue {
+    MetricValue::Steps(Steps::new(count).unwrap())
+}
+
+async fn on_that_day(store: &Arc<InMemoryStore>, user_id: &UserId) -> Vec<DailyMetric> {
+    let span = DateSpan::new(on("2026-08-20"), on("2026-08-20")).unwrap();
+    list_daily_metrics::execute(user_id.clone(), span, &list_deps(store))
+        .await
+        .unwrap()
+}
+
+async fn only_metric(store: &Arc<InMemoryStore>, user_id: &UserId, day: &str) -> DailyMetric {
+    let span = DateSpan::new(on(day), on(day)).unwrap();
+    let stored = list_daily_metrics::execute(user_id.clone(), span, &list_deps(store))
+        .await
+        .unwrap();
+
+    assert_eq!(stored.len(), 1);
+    stored.into_iter().next().unwrap()
+}
+
+#[tokio::test]
+async fn a_step_count_the_user_states_is_stored_for_that_date() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Stated(steps(8_412))],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let span = DateSpan::new(on("2026-08-20"), on("2026-08-20")).unwrap();
+    let stored = list_daily_metrics::execute(user_id, span, &list_deps(&store))
+        .await
+        .unwrap();
+
+    assert_eq!(stored.len(), 1);
+    assert_eq!(stored[0].value(), &steps(8_412));
+    assert_eq!(stored[0].source(), &Source::Manual);
+}
+
+#[tokio::test]
+async fn an_import_does_not_overwrite_the_count_the_user_stated() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Stated(steps(8_412))],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let imported = DailyMetric::new(
+        user_id.clone(),
+        on("2026-08-20"),
+        steps(1_000),
+        Source::Provider(ProviderName::new("healthkit").unwrap()),
+    );
+    DailyMetricCommandPort::save(store.as_ref(), &[imported])
+        .await
+        .unwrap();
+
+    let stored = only_metric(&store, &user_id, "2026-08-20").await;
+
+    assert_eq!(stored.value(), &steps(8_412));
+    assert_eq!(stored.source(), &Source::Manual);
+}
+
+#[tokio::test]
+async fn a_count_the_user_states_replaces_what_a_provider_reported() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    let imported = DailyMetric::new(
+        user_id.clone(),
+        on("2026-08-20"),
+        steps(1_000),
+        Source::Provider(ProviderName::new("healthkit").unwrap()),
+    );
+    DailyMetricCommandPort::save(store.as_ref(), &[imported])
+        .await
+        .unwrap();
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Stated(steps(8_412))],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let stored = only_metric(&store, &user_id, "2026-08-20").await;
+
+    assert_eq!(stored.value(), &steps(8_412));
+    assert_eq!(stored.source(), &Source::Manual);
+}
+
+#[tokio::test]
+async fn restating_a_date_corrects_it_rather_than_recording_it_twice() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    for count in [8_000, 8_412] {
+        set_daily_metrics::execute(
+            SetDailyMetricsCommand {
+                user_id: user_id.clone(),
+                date: on("2026-08-20"),
+                changes: vec![MetricChange::Stated(steps(count))],
+                source: Source::Manual,
+            },
+            &set_deps(&store),
+        )
+        .await
+        .unwrap();
+    }
+
+    let stored = only_metric(&store, &user_id, "2026-08-20").await;
+
+    assert_eq!(stored.value(), &steps(8_412));
+}
+
+#[tokio::test]
+async fn a_date_that_has_not_happened_yet_is_refused() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    let error = set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id,
+            date: on("2099-01-01"),
+            changes: vec![MetricChange::Stated(steps(8_412))],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap_err();
+
+    assert!(error.to_string().contains("has not happened yet"));
+}
+
+#[tokio::test]
+async fn an_account_with_no_timezone_cannot_record_a_day() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = test_user("bob");
+    UserCommandPort::save(store.as_ref(), &user).await.unwrap();
+
+    let error = set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user.id().clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Stated(steps(8_412))],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap_err();
+
+    assert!(error.to_string().contains("timezone"));
+}
+
+#[tokio::test]
+async fn only_the_days_in_the_span_come_back() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    for day in ["2026-08-19", "2026-08-20", "2026-08-21"] {
+        set_daily_metrics::execute(
+            SetDailyMetricsCommand {
+                user_id: user_id.clone(),
+                date: on(day),
+                changes: vec![MetricChange::Stated(steps(8_412))],
+                source: Source::Manual,
+            },
+            &set_deps(&store),
+        )
+        .await
+        .unwrap();
+    }
+
+    let span = DateSpan::new(on("2026-08-20"), on("2026-08-21")).unwrap();
+    let stored = list_daily_metrics::execute(user_id, span, &list_deps(&store))
+        .await
+        .unwrap();
+
+    let mut days: Vec<String> = stored
+        .iter()
+        .map(|metric| metric.date().to_string())
+        .collect();
+    days.sort();
+
+    assert_eq!(days, vec!["2026-08-20", "2026-08-21"]);
+}
+
+#[tokio::test]
+async fn another_users_days_are_not_returned() {
+    let store = Arc::new(InMemoryStore::new());
+    let mine = a_user_in_warsaw(&store).await;
+    let theirs = UserId::generate();
+
+    let hers = DailyMetric::new(theirs, on("2026-08-20"), steps(1_000), Source::Manual);
+    DailyMetricCommandPort::save(store.as_ref(), &[hers])
+        .await
+        .unwrap();
+
+    let span = DateSpan::new(on("2026-08-20"), on("2026-08-20")).unwrap();
+    let stored = list_daily_metrics::execute(mine, span, &list_deps(&store))
+        .await
+        .unwrap();
+
+    assert!(stored.is_empty());
+}
+
+#[tokio::test]
+async fn clearing_a_users_data_removes_their_days() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Stated(steps(8_412))],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    CascadeDeletePort::delete_all_user_data(store.as_ref(), &user_id)
+        .await
+        .unwrap();
+
+    let span = DateSpan::new(on("2026-08-20"), on("2026-08-20")).unwrap();
+    let stored = list_daily_metrics::execute(user_id, span, &list_deps(&store))
+        .await
+        .unwrap();
+
+    assert!(stored.is_empty());
+}
+
+fn one_of_every_kind() -> Vec<MetricChange> {
+    [
+        MetricValue::Steps(Steps::new(8_412).unwrap()),
+        MetricValue::SleepMinutes(SleepMinutes::new(447).unwrap()),
+        MetricValue::AwakeMinutes(AwakeMinutes::new(23).unwrap()),
+        MetricValue::RestingHeartRate(RestingHeartRate::new(52).unwrap()),
+        MetricValue::Hrv(Hrv::new(61).unwrap()),
+        MetricValue::ExerciseMinutes(ExerciseMinutes::new(35).unwrap()),
+        MetricValue::ScreenTimeMinutes(ScreenTimeMinutes::new(212).unwrap()),
+        MetricValue::AlcoholicDrinks(AlcoholicDrinks::new(2).unwrap()),
+    ]
+    .into_iter()
+    .map(MetricChange::Stated)
+    .collect()
+}
+
+#[tokio::test]
+async fn every_kind_can_be_stated_and_read_back_on_one_day() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: one_of_every_kind(),
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let span = DateSpan::new(on("2026-08-20"), on("2026-08-20")).unwrap();
+    let stored = list_daily_metrics::execute(user_id, span, &list_deps(&store))
+        .await
+        .unwrap();
+
+    let mut names: Vec<&str> = stored.iter().map(|metric| metric.kind().name()).collect();
+    names.sort_unstable();
+
+    assert_eq!(
+        names,
+        [
+            "alcoholicDrinks",
+            "awakeMinutes",
+            "exerciseMinutes",
+            "hrv",
+            "restingHeartRate",
+            "screenTimeMinutes",
+            "sleepMinutes",
+            "steps",
+        ]
+    );
+
+    let values: Vec<&MetricValue> = stored.iter().map(|metric| metric.value()).collect();
+    for change in one_of_every_kind() {
+        let MetricChange::Stated(expected) = change else {
+            unreachable!("every kind is stated, never cleared, in this test")
+        };
+        assert!(
+            values.contains(&&expected),
+            "{expected:?} did not come back"
+        );
+    }
+}
+
+#[tokio::test]
+async fn stating_one_kind_leaves_another_providers_reading_alone() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    let reported = DailyMetric::new(
+        user_id.clone(),
+        on("2026-08-20"),
+        MetricValue::Hrv(Hrv::new(61).unwrap()),
+        Source::Provider(ProviderName::new("healthkit").unwrap()),
+    );
+    DailyMetricCommandPort::save(store.as_ref(), &[reported])
+        .await
+        .unwrap();
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Stated(steps(8_412))],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let span = DateSpan::new(on("2026-08-20"), on("2026-08-20")).unwrap();
+    let stored = list_daily_metrics::execute(user_id, span, &list_deps(&store))
+        .await
+        .unwrap();
+
+    let hrv = stored
+        .iter()
+        .find(|metric| metric.kind() == MetricKind::Hrv)
+        .expect("the provider's reading was lost");
+
+    assert_eq!(hrv.value(), &MetricValue::Hrv(Hrv::new(61).unwrap()));
+    assert!(hrv.source().provider().is_some());
+    assert_eq!(stored.len(), 2);
+}
+
+#[tokio::test]
+async fn clearing_a_kind_removes_what_was_stated() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Stated(steps(8_412))],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Cleared(MetricKind::Steps)],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let span = DateSpan::new(on("2026-08-20"), on("2026-08-20")).unwrap();
+    let stored = list_daily_metrics::execute(user_id, span, &list_deps(&store))
+        .await
+        .unwrap();
+
+    assert!(stored.is_empty());
+}
+
+#[tokio::test]
+async fn clearing_a_kind_that_was_never_recorded_changes_nothing() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Cleared(MetricKind::Hrv)],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let span = DateSpan::new(on("2026-08-20"), on("2026-08-20")).unwrap();
+    let stored = list_daily_metrics::execute(user_id, span, &list_deps(&store))
+        .await
+        .unwrap();
+
+    assert!(stored.is_empty());
+}
+
+#[tokio::test]
+async fn a_providers_reading_can_be_cleared_and_a_later_import_may_return_it() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    let reading = || {
+        DailyMetric::new(
+            user_id.clone(),
+            on("2026-08-20"),
+            steps(1_000),
+            Source::Provider(ProviderName::new("healthkit").unwrap()),
+        )
+    };
+
+    DailyMetricCommandPort::save(store.as_ref(), &[reading()])
+        .await
+        .unwrap();
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Cleared(MetricKind::Steps)],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    assert!(
+        on_that_day(&store, &user_id).await.is_empty(),
+        "clearing left the provider's reading behind"
+    );
+
+    DailyMetricCommandPort::save(store.as_ref(), &[reading()])
+        .await
+        .unwrap();
+
+    let stored = on_that_day(&store, &user_id).await;
+
+    assert_eq!(stored.len(), 1);
+    assert!(stored[0].source().provider().is_some());
+}
+
+#[tokio::test]
+async fn one_request_can_state_one_kind_and_clear_another() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![
+                MetricChange::Stated(steps(8_412)),
+                MetricChange::Stated(MetricValue::Hrv(Hrv::new(61).unwrap())),
+            ],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![
+                MetricChange::Stated(steps(9_000)),
+                MetricChange::Cleared(MetricKind::Hrv),
+            ],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let stored = on_that_day(&store, &user_id).await;
+
+    assert_eq!(stored.len(), 1);
+    assert_eq!(stored[0].value(), &steps(9_000));
+}
+
+#[tokio::test]
+async fn naming_a_kind_twice_in_one_request_is_refused() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    let error = set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id,
+            date: on("2026-08-20"),
+            changes: vec![
+                MetricChange::Stated(steps(8_412)),
+                MetricChange::Cleared(MetricKind::Steps),
+            ],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap_err();
+
+    assert!(error.to_string().contains("more than once"));
+}
+
+#[tokio::test]
+async fn clearing_one_kind_leaves_the_others_on_that_day_alone() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: one_of_every_kind(),
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Cleared(MetricKind::Hrv)],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let stored = on_that_day(&store, &user_id).await;
+    let remaining: Vec<MetricKind> = stored.iter().map(|metric| metric.kind()).collect();
+
+    assert_eq!(stored.len(), 7);
+    assert!(!remaining.contains(&MetricKind::Hrv));
+    assert!(remaining.contains(&MetricKind::Steps));
+}
+
+#[tokio::test]
+async fn clearing_a_kind_on_one_day_leaves_the_same_kind_on_other_days() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    for day in ["2026-08-19", "2026-08-20", "2026-08-21"] {
+        set_daily_metrics::execute(
+            SetDailyMetricsCommand {
+                user_id: user_id.clone(),
+                date: on(day),
+                changes: vec![MetricChange::Stated(steps(8_412))],
+                source: Source::Manual,
+            },
+            &set_deps(&store),
+        )
+        .await
+        .unwrap();
+    }
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Cleared(MetricKind::Steps)],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let span = DateSpan::new(on("2026-08-19"), on("2026-08-21")).unwrap();
+    let stored = list_daily_metrics::execute(user_id, span, &list_deps(&store))
+        .await
+        .unwrap();
+
+    let mut days: Vec<String> = stored
+        .iter()
+        .map(|metric| metric.date().to_string())
+        .collect();
+    days.sort();
+
+    assert_eq!(days, ["2026-08-19", "2026-08-21"]);
+}
+
+fn healthkit() -> Source {
+    Source::Provider(ProviderName::new("healthkit").unwrap())
+}
+
+#[tokio::test]
+async fn an_importer_writes_under_its_own_name() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Stated(steps(8_412))],
+            source: healthkit(),
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let stored = only_metric(&store, &user_id, "2026-08-20").await;
+
+    assert_eq!(stored.source(), &healthkit());
+}
+
+#[tokio::test]
+async fn an_importer_cannot_clear_a_reading() {
+    let store = Arc::new(InMemoryStore::new());
+    let user_id = a_user_in_warsaw(&store).await;
+
+    set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Stated(steps(8_412))],
+            source: Source::Manual,
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap();
+
+    let refused = set_daily_metrics::execute(
+        SetDailyMetricsCommand {
+            user_id: user_id.clone(),
+            date: on("2026-08-20"),
+            changes: vec![MetricChange::Cleared(MetricKind::Steps)],
+            source: healthkit(),
+        },
+        &set_deps(&store),
+    )
+    .await
+    .unwrap_err();
+
+    assert!(refused.to_string().contains("clear"), "got {refused}");
+    assert_eq!(
+        only_metric(&store, &user_id, "2026-08-20").await.value(),
+        &steps(8_412),
+        "the reading must survive an importer trying to clear it"
+    );
+}
diff --git a/crates/application/tests/provider.rs b/crates/application/tests/provider.rs
new file mode 100644
index 0000000..b935378
--- /dev/null
+++ b/crates/application/tests/provider.rs
@@ -0,0 +1,5 @@
+#[path = "provider/connection_test.rs"]
+mod connection_test;
+
+#[path = "provider/now_playing_test.rs"]
+mod now_playing_test;
diff --git a/crates/application/tests/provider/connection_test.rs b/crates/application/tests/provider/connection_test.rs
new file mode 100644
index 0000000..c90482e
--- /dev/null
+++ b/crates/application/tests/provider/connection_test.rs
@@ -0,0 +1,121 @@
+use std::sync::Arc;
+
+use domain::ports::ProviderConnectionQueryPort;
+use domain::provider::ProviderName;
+use domain::testing::{FakeCredentialCipher, InMemoryStore, test_user};
+
+use application::provider::commands::ConnectProviderCommand;
+use application::provider::use_cases::{connect_provider, disconnect_provider, list_connections};
+
+const SUBSONIC_CREDENTIAL: &str =
+    r#"{"url":"https://music.example","username":"gabriel","password":"hunter2"}"#;
+
+fn deps() -> (Arc<InMemoryStore>, connect_provider::Deps) {
+    let store = Arc::new(InMemoryStore::new());
+    let deps = connect_provider::Deps {
+        command: store.clone(),
+        cipher: Arc::new(FakeCredentialCipher),
+    };
+    (store, deps)
+}
+
+#[tokio::test]
+async fn connecting_stores_the_credential_sealed_rather_than_verbatim() {
+    let (store, deps) = deps();
+    let user = test_user("alice");
+
+    let cmd = ConnectProviderCommand {
+        user_id: user.id().clone(),
+        provider: ProviderName::new("subsonic").unwrap(),
+        credential: SUBSONIC_CREDENTIAL.as_bytes().to_vec(),
+    };
+
+    connect_provider::execute(cmd, &deps).await.unwrap();
+
+    let stored = store.find_by_user(user.id()).await.unwrap();
+    let sealed = stored[0].credential().value();
+
+    assert!(
+        !sealed.windows(7).any(|window| window == b"hunter2"),
+        "the raw password reached storage"
+    );
+}
+
+#[tokio::test]
+async fn reconnecting_replaces_the_credential_rather_than_adding_a_second() {
+    let (store, deps) = deps();
+    let user = test_user("bob");
+    let provider = ProviderName::new("subsonic").unwrap();
+
+    for password in ["first", "second"] {
+        let cmd = ConnectProviderCommand {
+            user_id: user.id().clone(),
+            provider: provider.clone(),
+            credential: password.as_bytes().to_vec(),
+        };
+        connect_provider::execute(cmd, &deps).await.unwrap();
+    }
+
+    let stored = store.find_by_user(user.id()).await.unwrap();
+
+    assert_eq!(stored.len(), 1);
+}
+
+#[tokio::test]
+async fn listing_reports_connected_providers_without_their_credentials() {
+    let (store, deps) = deps();
+    let user = test_user("carol");
+
+    connect_provider::execute(
+        ConnectProviderCommand {
+            user_id: user.id().clone(),
+            provider: ProviderName::new("subsonic").unwrap(),
+            credential: SUBSONIC_CREDENTIAL.as_bytes().to_vec(),
+        },
+        &deps,
+    )
+    .await
+    .unwrap();
+
+    let listing = list_connections::execute(
+        user.id().clone(),
+        &list_connections::Deps {
+            query: store.clone(),
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(listing.len(), 1);
+    assert_eq!(listing[0].provider.value(), "subsonic");
+}
+
+#[tokio::test]
+async fn disconnecting_removes_the_connection() {
+    let (store, deps) = deps();
+    let user = test_user("dave");
+    let provider = ProviderName::new("subsonic").unwrap();
+
+    connect_provider::execute(
+        ConnectProviderCommand {
+            user_id: user.id().clone(),
+            provider: provider.clone(),
+            credential: SUBSONIC_CREDENTIAL.as_bytes().to_vec(),
+        },
+        &deps,
+    )
+    .await
+    .unwrap();
+
+    disconnect_provider::execute(
+        user.id().clone(),
+        provider,
+        &disconnect_provider::Deps {
+            command: store.clone(),
+        },
+    )
+    .await
+    .unwrap();
+
+    assert!(store.find_by_user(user.id()).await.unwrap().is_empty());
+}
diff --git a/crates/application/tests/provider/now_playing_test.rs b/crates/application/tests/provider/now_playing_test.rs
new file mode 100644
index 0000000..fee35a3
--- /dev/null
+++ b/crates/application/tests/provider/now_playing_test.rs
@@ -0,0 +1,199 @@
+use std::sync::Arc;
+
+use domain::provider::ProviderName;
+use domain::song::{RecordingId, Song};
+use domain::testing::{
+    FakeCredentialCipher, FakeNowPlaying, FakeRecordingLookup, InMemoryStore, test_user,
+};
+
+use application::provider::commands::ConnectProviderCommand;
+use application::provider::use_cases::{connect_provider, get_now_playing};
+
+const RECORDING: &str = "f5c7e7a2-0000-4000-8000-000000000001";
+
+async fn connected_store() -> (Arc<InMemoryStore>, domain::user::UserId) {
+    let store = Arc::new(InMemoryStore::new());
+    let user = test_user("alice");
+
+    connect_provider::execute(
+        ConnectProviderCommand {
+            user_id: user.id().clone(),
+            provider: ProviderName::new("subsonic").unwrap(),
+            credential: br#"{"url":"https://music.example"}"#.to_vec(),
+        },
+        &connect_provider::Deps {
+            command: store.clone(),
+            cipher: Arc::new(FakeCredentialCipher),
+        },
+    )
+    .await
+    .unwrap();
+
+    (store, user.id().clone())
+}
+
+fn song() -> Song {
+    Song::new("Paranoid Android", "Radiohead", None, None).unwrap()
+}
+
+#[tokio::test]
+async fn a_playing_song_is_returned_enriched_with_its_recording_id() {
+    let (store, user_id) = connected_store().await;
+
+    let deps = get_now_playing::Deps {
+        query: store.clone(),
+        cipher: Arc::new(FakeCredentialCipher),
+        now_playing: Arc::new(FakeNowPlaying::playing("subsonic", song())),
+        recordings: Arc::new(FakeRecordingLookup::finding(Some(
+            RecordingId::new(RECORDING).unwrap(),
+        ))),
+    };
+
+    let result = get_now_playing::execute(user_id, &deps).await.unwrap();
+    let found = result.unwrap();
+
+    assert_eq!(found.title().value(), "Paranoid Android");
+    assert_eq!(
+        found.recording_id().map(|id| id.value().to_string()),
+        Some(RECORDING.to_string())
+    );
+}
+
+#[tokio::test]
+async fn a_song_with_no_musicbrainz_match_is_still_returned() {
+    let (store, user_id) = connected_store().await;
+
+    let deps = get_now_playing::Deps {
+        query: store.clone(),
+        cipher: Arc::new(FakeCredentialCipher),
+        now_playing: Arc::new(FakeNowPlaying::playing("subsonic", song())),
+        recordings: Arc::new(FakeRecordingLookup::finding_nothing()),
+    };
+
+    let found = get_now_playing::execute(user_id, &deps)
+        .await
+        .unwrap()
+        .unwrap();
+
+    assert!(found.recording_id().is_none());
+}
+
+#[tokio::test]
+async fn nothing_playing_is_not_an_error() {
+    let (store, user_id) = connected_store().await;
+
+    let deps = get_now_playing::Deps {
+        query: store.clone(),
+        cipher: Arc::new(FakeCredentialCipher),
+        now_playing: Arc::new(FakeNowPlaying::silent("subsonic")),
+        recordings: Arc::new(FakeRecordingLookup::finding_nothing()),
+    };
+
+    assert!(
+        get_now_playing::execute(user_id, &deps)
+            .await
+            .unwrap()
+            .is_none()
+    );
+}
+
+#[tokio::test]
+async fn a_user_with_no_connection_gets_a_clear_error() {
+    let store = Arc::new(InMemoryStore::new());
+    let stranger = test_user("bob");
+
+    let deps = get_now_playing::Deps {
+        query: store.clone(),
+        cipher: Arc::new(FakeCredentialCipher),
+        now_playing: Arc::new(FakeNowPlaying::playing("subsonic", song())),
+        recordings: Arc::new(FakeRecordingLookup::finding_nothing()),
+    };
+
+    assert!(
+        get_now_playing::execute(stranger.id().clone(), &deps)
+            .await
+            .is_err()
+    );
+}
+
+#[tokio::test]
+async fn a_provider_that_cannot_be_reached_offers_nothing_rather_than_failing() {
+    let (store, user_id) = connected_store().await;
+
+    let deps = get_now_playing::Deps {
+        query: store.clone(),
+        cipher: Arc::new(FakeCredentialCipher),
+        now_playing: Arc::new(FakeNowPlaying::failing("subsonic", "connection refused")),
+        recordings: Arc::new(FakeRecordingLookup::finding_nothing()),
+    };
+
+    let asked = get_now_playing::execute(user_id, &deps).await;
+
+    assert!(
+        asked.is_ok(),
+        "the user must still be able to type a song by hand: {asked:?}"
+    );
+    assert!(asked.unwrap().is_none(), "nothing found, not an error");
+}
+
+#[tokio::test]
+async fn a_recording_lookup_that_fails_yields_a_song_with_no_identity() {
+    let (store, user_id) = connected_store().await;
+
+    let deps = get_now_playing::Deps {
+        query: store.clone(),
+        cipher: Arc::new(FakeCredentialCipher),
+        now_playing: Arc::new(FakeNowPlaying::playing("subsonic", song())),
+        recordings: Arc::new(FakeRecordingLookup::failing("musicbrainz is rate limiting")),
+    };
+
+    let playing = get_now_playing::execute(user_id, &deps)
+        .await
+        .expect("a failing enrichment must not fail the lookup")
+        .expect("the song is still playing");
+
+    assert_eq!(playing.title().value(), song().title().value());
+    assert!(
+        playing.recording_id().is_none(),
+        "an identity that could not be found is simply absent"
+    );
+}
+
+#[tokio::test]
+async fn a_recording_lookup_that_finds_nothing_yields_a_song_with_no_identity() {
+    let (store, user_id) = connected_store().await;
+
+    let deps = get_now_playing::Deps {
+        query: store.clone(),
+        cipher: Arc::new(FakeCredentialCipher),
+        now_playing: Arc::new(FakeNowPlaying::playing("subsonic", song())),
+        recordings: Arc::new(FakeRecordingLookup::finding_nothing()),
+    };
+
+    let playing = get_now_playing::execute(user_id, &deps)
+        .await
+        .unwrap()
+        .unwrap();
+
+    assert!(playing.recording_id().is_none());
+}
+
+#[tokio::test]
+async fn an_account_with_no_connection_is_told_so_rather_than_offered_silence() {
+    let store = Arc::new(InMemoryStore::new());
+    let user = test_user("nobody");
+
+    let deps = get_now_playing::Deps {
+        query: store.clone(),
+        cipher: Arc::new(FakeCredentialCipher),
+        now_playing: Arc::new(FakeNowPlaying::playing("subsonic", song())),
+        recordings: Arc::new(FakeRecordingLookup::finding_nothing()),
+    };
+
+    let asked = get_now_playing::execute(user.id().clone(), &deps).await;
+
+    assert!(
+        asked.is_err(),
+        "nothing to connect to is actionable, unlike a provider being down"
+    );
+}
diff --git a/crates/application/tests/reminder.rs b/crates/application/tests/reminder.rs
index 6c11e55..39cc0cf 100644
--- a/crates/application/tests/reminder.rs
+++ b/crates/application/tests/reminder.rs
@@ -1,2 +1,5 @@
 #[path = "reminder/crud_test.rs"]
 mod crud_test;
+
+#[path = "reminder/process_due_test.rs"]
+mod process_due_test;
diff --git a/crates/application/tests/reminder/process_due_test.rs b/crates/application/tests/reminder/process_due_test.rs
new file mode 100644
index 0000000..3d9d803
--- /dev/null
+++ b/crates/application/tests/reminder/process_due_test.rs
@@ -0,0 +1,87 @@
+use std::sync::{Arc, Mutex};
+
+use chrono::Utc;
+
+use domain::errors::DomainError;
+use domain::ports::{ReminderCommandPort, ReminderSenderPort, UserCommandPort};
+use domain::reminder::{DaySchedule, Reminder};
+use domain::testing::{InMemoryStore, test_user};
+use domain::user::{Timezone, UserId};
+
+use application::reminder::use_cases::process_due_reminders;
+
+/// Records every attempt and fails for one nominated user, the way a device
+/// whose push subscription has gone stale does.
+struct FlakySender {
+    failing: UserId,
+    attempts: Mutex<Vec<UserId>>,
+}
+
+impl FlakySender {
+    fn new(failing: UserId) -> Self {
+        Self {
+            failing,
+            attempts: Mutex::new(Vec::new()),
+        }
+    }
+
+    fn attempts(&self) -> Vec<UserId> {
+        self.attempts.lock().unwrap().clone()
+    }
+}
+
+#[async_trait::async_trait]
+impl ReminderSenderPort for FlakySender {
+    async fn send_reminder(&self, user_id: &UserId) -> Result<(), DomainError> {
+        self.attempts.lock().unwrap().push(user_id.clone());
+
+        if user_id == &self.failing {
+            return Err(DomainError::InvalidInput(
+                "no push notification could be delivered".into(),
+            ));
+        }
+
+        Ok(())
+    }
+}
+
+/// A reminder due right now, so `should_send` lets it through.
+fn due_now(user_id: UserId) -> Reminder {
+    Reminder::new(user_id, DaySchedule::every_day_at(Utc::now().time()))
+}
+
+#[tokio::test]
+async fn a_failing_send_does_not_abort_the_sweep() {
+    let store = Arc::new(InMemoryStore::new());
+
+    let mut broken = test_user("broken");
+    broken.update_timezone(Some(Timezone::new("UTC").unwrap()));
+    let mut healthy = test_user("healthy");
+    healthy.update_timezone(Some(Timezone::new("UTC").unwrap()));
+
+    UserCommandPort::save(&*store, &broken).await.unwrap();
+    UserCommandPort::save(&*store, &healthy).await.unwrap();
+    ReminderCommandPort::save(&*store, &due_now(broken.id().clone()))
+        .await
+        .unwrap();
+    ReminderCommandPort::save(&*store, &due_now(healthy.id().clone()))
+        .await
+        .unwrap();
+
+    let sender = Arc::new(FlakySender::new(broken.id().clone()));
+    let deps = process_due_reminders::Deps {
+        reminder_query: store.clone(),
+        user_query: store.clone(),
+        sender: sender.clone(),
+    };
+
+    let sent = process_due_reminders::execute(&deps).await.unwrap();
+
+    assert_eq!(sent, 1, "the healthy user should still have been counted");
+
+    let attempts = sender.attempts();
+    assert!(
+        attempts.contains(broken.id()) && attempts.contains(healthy.id()),
+        "both users should have been attempted regardless of order, got {attempts:?}"
+    );
+}
diff --git a/crates/application/tests/user/clear_data_test.rs b/crates/application/tests/user/clear_data_test.rs
index b1e8c8a..79fee43 100644
--- a/crates/application/tests/user/clear_data_test.rs
+++ b/crates/application/tests/user/clear_data_test.rs
@@ -19,6 +19,7 @@ async fn clears_all_user_data() {
     ReminderCommandPort::save(&*store, &reminder).await.unwrap();
 
     let deps = clear_data::Deps {
+        dimensions: vec![],
         entry_query: store.clone(),
         cascade: store.clone(),
         media_storage: store.clone(),
diff --git a/crates/application/tests/user/delete_user_test.rs b/crates/application/tests/user/delete_user_test.rs
index bee328e..f82277d 100644
--- a/crates/application/tests/user/delete_user_test.rs
+++ b/crates/application/tests/user/delete_user_test.rs
@@ -11,6 +11,7 @@ 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(),
diff --git a/crates/bootstrap/Cargo.toml b/crates/bootstrap/Cargo.toml
new file mode 100644
index 0000000..322cd8a
--- /dev/null
+++ b/crates/bootstrap/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "bootstrap"
+edition.workspace = true
+version.workspace = true
+
+[dependencies]
+domain.workspace = true
+application.workspace = true
+config.workspace = true
+http-axum.workspace = true
+sqlite.workspace = true
+auth.workspace = true
+storage.workspace = true
+event-publisher.workspace = true
+importer.workspace = true
+crypto.workspace = true
+music.workspace = true
+reqwest.workspace = true
+exporter.workspace = true
+weather.workspace = true
+web-push-adapter.workspace = true
+tokio.workspace = true
+tracing.workspace = true
+tracing-subscriber.workspace = true
diff --git a/crates/bootstrap/src/factory.rs b/crates/bootstrap/src/factory.rs
new file mode 100644
index 0000000..d9ac0f7
--- /dev/null
+++ b/crates/bootstrap/src/factory.rs
@@ -0,0 +1,251 @@
+use std::sync::Arc;
+
+use config::AppConfig;
+use domain::ports::ReminderSenderPort;
+use http_axum::state::AppState;
+
+pub struct Context {
+    pub state: AppState,
+    pub reminder_sender: Option<Arc<dyn ReminderSenderPort>>,
+    pub job_queue: Arc<dyn domain::ports::JobQueueCommandPort>,
+    pub job_view: Arc<dyn domain::ports::JobQueueQueryPort>,
+    pub recording_backlog: Arc<dyn domain::ports::RecordingBackfillQueryPort>,
+    pub recordings: Arc<dyn domain::ports::RecordingLookupPort>,
+    pub weather_backlog: Arc<dyn domain::ports::WeatherBacklogQueryPort>,
+    pub weather_store: Arc<dyn domain::ports::EntryDimensionPort>,
+    pub weather: Option<Arc<dyn domain::ports::WeatherLookupPort>>,
+    pub worker_config: config::WorkerConfig,
+}
+
+pub async fn build(config: AppConfig) -> Result<Context, Box<dyn std::error::Error>> {
+    let db_url = config
+        .storage
+        .database_url
+        .clone()
+        .unwrap_or_else(|| format!("sqlite://{}/k-mood.db", config.storage.data_dir));
+
+    let pool = sqlite::create_pool(&db_url).await?;
+    sqlite::run_migrations(&pool).await?;
+
+    let user_command = Arc::new(sqlite::repositories::SqliteUserCommandRepository::new(
+        pool.clone(),
+    ));
+    let user_query = Arc::new(sqlite::repositories::SqliteUserQueryRepository::new(
+        pool.clone(),
+    ));
+    let activity_command = Arc::new(sqlite::repositories::SqliteActivityCommandRepository::new(
+        pool.clone(),
+    ));
+    let activity_query = Arc::new(sqlite::repositories::SqliteActivityQueryRepository::new(
+        pool.clone(),
+    ));
+    let entry_command = Arc::new(sqlite::repositories::SqliteEntryCommandRepository::new(
+        pool.clone(),
+    ));
+    let entry_query = Arc::new(sqlite::repositories::SqliteEntryQueryRepository::new(
+        pool.clone(),
+    ));
+    let weather_store = Arc::new(sqlite::repositories::SqliteWeatherDimensionRepository::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())),
+        Arc::new(sqlite::repositories::SqliteRelationDimensionRepository::photos(pool.clone())),
+        Arc::new(
+            sqlite::repositories::SqliteRelationDimensionRepository::voice_memos(pool.clone()),
+        ),
+        Arc::new(sqlite::repositories::SqliteLocationDimensionRepository::new(pool.clone())),
+        Arc::new(sqlite::repositories::SqliteSongDimensionRepository::new(
+            pool.clone(),
+        )),
+        weather_store.clone(),
+    ];
+    let reminder_command = Arc::new(sqlite::repositories::SqliteReminderCommandRepository::new(
+        pool.clone(),
+    ));
+    let reminder_query = Arc::new(sqlite::repositories::SqliteReminderQueryRepository::new(
+        pool.clone(),
+    ));
+    let refresh_session_command =
+        Arc::new(sqlite::repositories::SqliteRefreshSessionCommandRepository::new(pool.clone()));
+    let refresh_session_query =
+        Arc::new(sqlite::repositories::SqliteRefreshSessionQueryRepository::new(pool.clone()));
+    let cascade = Arc::new(sqlite::repositories::SqliteCascadeDeleteRepository::new(
+        pool.clone(),
+    ));
+    let job_queue = Arc::new(sqlite::repositories::SqliteJobQueueRepository::new(
+        pool.clone(),
+    ));
+    let recording_backlog =
+        Arc::new(sqlite::repositories::SqliteRecordingBackfillRepository::new(pool.clone()));
+    let weather_backlog = Arc::new(sqlite::repositories::SqliteWeatherBacklogRepository::new(
+        pool.clone(),
+    ));
+    let cycle_repository = Arc::new(sqlite::repositories::SqliteCycleStartRepository::new(
+        pool.clone(),
+    ));
+    let preferences_repository = Arc::new(
+        sqlite::repositories::SqliteUserPreferencesRepository::new(pool.clone()),
+    );
+    let api_token_command = Arc::new(sqlite::repositories::SqliteApiTokenCommandRepository::new(
+        pool.clone(),
+    ));
+    let api_token_query = Arc::new(sqlite::repositories::SqliteApiTokenQueryRepository::new(
+        pool.clone(),
+    ));
+    let daily_metric_command =
+        Arc::new(sqlite::repositories::SqliteDailyMetricCommandRepository::new(pool.clone()));
+    let rejections = Arc::new(sqlite::repositories::SqliteRejectionRepository::new(
+        pool.clone(),
+        config.import.rejections_kept,
+    ));
+    let daily_metric_query = Arc::new(sqlite::repositories::SqliteDailyMetricQueryRepository::new(
+        pool.clone(),
+        rejections.clone(),
+    ));
+    let push_subscription_command =
+        Arc::new(sqlite::repositories::SqlitePushSubscriptionCommandRepository::new(pool.clone()));
+    let push_subscription_query =
+        Arc::new(sqlite::repositories::SqlitePushSubscriptionQueryRepository::new(pool.clone()));
+
+    let jwt_service = auth::JwtAuthService::new(&config.auth)?;
+    let password_hasher = auth::Argon2PasswordHasher;
+
+    let media_storage = storage::create_media_storage(&config.storage)?;
+
+    let reminder_sender: Option<Arc<dyn ReminderSenderPort>> = if config.push.enabled {
+        let sender = web_push_adapter::WebPushSender::new(
+            &config.push,
+            push_subscription_query.clone(),
+            push_subscription_command.clone(),
+        )?;
+        Some(Arc::new(sender))
+    } else {
+        None
+    };
+
+    let provider_connection_command = Arc::new(
+        sqlite::repositories::SqliteProviderConnectionCommandRepository::new(pool.clone()),
+    );
+    let provider_connection_query =
+        Arc::new(sqlite::repositories::SqliteProviderConnectionQueryRepository::new(pool.clone()));
+
+    let credential_cipher = match config.provider.encryption_key.as_deref() {
+        Some(key) if !key.is_empty() => {
+            let cipher = crypto::ChaChaCredentialCipher::new(key)?;
+            tracing::info!("provider connections enabled");
+            Some(Arc::new(cipher) as Arc<dyn domain::provider::CredentialCipher>)
+        }
+        _ => {
+            tracing::info!(
+                "no credential encryption key configured, provider connections are unavailable"
+            );
+            None
+        }
+    };
+
+    let music_http = reqwest::Client::builder()
+        .user_agent(music::musicbrainz::USER_AGENT)
+        .build()?;
+
+    let now_playing: Option<Arc<dyn domain::ports::NowPlayingPort>> = Some(Arc::new(
+        music::SubsonicNowPlayingAdapter::new(music_http.clone()),
+    ));
+    let recording_lookup: Arc<dyn domain::ports::RecordingLookupPort> =
+        Arc::new(music::MusicBrainzRecordingLookup::new(music_http));
+
+    let weather_lookup: Option<Arc<dyn domain::ports::WeatherLookupPort>> = if config
+        .worker
+        .look_up_weather
+    {
+        Some(Arc::new(weather::OpenMeteoWeatherLookup::new(
+            reqwest::Client::new(),
+        )))
+    } else {
+        tracing::info!("weather lookups are switched off, so no coordinates leave this machine");
+        None
+    };
+
+    let (event_publisher, event_receiver) = event_publisher::create_event_channel();
+    spawn_event_drain(event_receiver);
+
+    let state = AppState {
+        entry_command,
+        entry_query,
+        dimensions,
+        weather_store: weather_store.clone(),
+        provider_connection_command,
+        provider_connection_query,
+        credential_cipher,
+        now_playing,
+        recording_lookup: recording_lookup.clone(),
+        activity_command,
+        activity_query,
+        user_command,
+        user_query,
+        reminder_command,
+        reminder_query,
+        refresh_session_command,
+        refresh_session_query,
+        cascade,
+        daily_metric_command,
+        daily_metric_query,
+        cycle_command: cycle_repository.clone(),
+        cycle_query: cycle_repository,
+        preferences_command: preferences_repository.clone(),
+        preferences_query: preferences_repository,
+        rejection_command: rejections.clone(),
+        rejection_query: rejections,
+        api_token_command,
+        api_token_query,
+        api_token_secrets: Arc::new(auth::ApiTokenSecret),
+        auth_service: Arc::new(jwt_service),
+        password_hasher: Arc::new(password_hasher),
+        event_publisher: Arc::new(event_publisher),
+        media_storage: Arc::new(media_storage),
+        backup_writer: Arc::new(exporter::ZipBackupWriter),
+        backup_reader: Arc::new(importer::KmoodBackupAdapter),
+        extract_writer: Arc::new(exporter::MarkdownExtractWriter),
+        import_source: Arc::new(importer::DaylioImportAdapter),
+        push_subscription_command,
+        push_subscription_query,
+        reminder_sender: reminder_sender.clone(),
+        server_config: config.server,
+        entry_config: config.entry,
+        analysis_config: config.analysis,
+        import_config: config.import,
+        auth_config: config.auth,
+        push_config: config.push,
+        preset_config: config.preset,
+    };
+
+    Ok(Context {
+        state,
+        reminder_sender,
+        job_queue: job_queue.clone(),
+        job_view: job_queue,
+        recording_backlog,
+        recordings: recording_lookup,
+        weather_backlog,
+        weather_store: weather_store.clone(),
+        weather: weather_lookup,
+        worker_config: config.worker,
+    })
+}
+
+fn spawn_event_drain(mut receiver: event_publisher::EventReceiver) {
+    tokio::spawn(async move {
+        while let Some(envelope) = receiver.recv().await {
+            tracing::debug!(
+                event_id = %envelope.id(),
+                event = ?envelope.event(),
+                "domain event published"
+            );
+        }
+        tracing::info!("event drain stopped");
+    });
+}
diff --git a/crates/bootstrap/src/lib.rs b/crates/bootstrap/src/lib.rs
new file mode 100644
index 0000000..2d680b1
--- /dev/null
+++ b/crates/bootstrap/src/lib.rs
@@ -0,0 +1,7 @@
+mod factory;
+pub mod shutdown;
+mod tracing_setup;
+
+pub use config::load;
+pub use factory::{Context, build};
+pub use tracing_setup::setup_tracing;
diff --git a/crates/bootstrap/src/shutdown.rs b/crates/bootstrap/src/shutdown.rs
new file mode 100644
index 0000000..6567f21
--- /dev/null
+++ b/crates/bootstrap/src/shutdown.rs
@@ -0,0 +1,25 @@
+pub async fn on_signal() {
+    let ctrl_c = async {
+        if tokio::signal::ctrl_c().await.is_err() {
+            tracing::error!("could not listen for Ctrl+C");
+        }
+    };
+
+    #[cfg(unix)]
+    let terminate = async {
+        match tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) {
+            Ok(mut signal) => {
+                signal.recv().await;
+            }
+            Err(_) => tracing::error!("could not listen for SIGTERM"),
+        }
+    };
+
+    #[cfg(not(unix))]
+    let terminate = std::future::pending::<()>();
+
+    tokio::select! {
+        _ = ctrl_c => tracing::info!("received Ctrl+C"),
+        _ = terminate => tracing::info!("received SIGTERM"),
+    }
+}
diff --git a/crates/bootstrap/src/tracing_setup.rs b/crates/bootstrap/src/tracing_setup.rs
new file mode 100644
index 0000000..e529b23
--- /dev/null
+++ b/crates/bootstrap/src/tracing_setup.rs
@@ -0,0 +1,7 @@
+pub fn setup_tracing() {
+    use tracing_subscriber::EnvFilter;
+
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()))
+        .init();
+}
diff --git a/crates/config/Cargo.toml b/crates/config/Cargo.toml
index 8a25f44..3e15bec 100644
--- a/crates/config/Cargo.toml
+++ b/crates/config/Cargo.toml
@@ -6,3 +6,8 @@ version.workspace = true
 [dependencies]
 thiserror.workspace = true
 serde.workspace = true
+figment.workspace = true
+tracing.workspace = true
+
+[dev-dependencies]
+figment = { workspace = true, features = ["test"] }
diff --git a/crates/config/src/analysis_config.rs b/crates/config/src/analysis_config.rs
new file mode 100644
index 0000000..6d95a41
--- /dev/null
+++ b/crates/config/src/analysis_config.rs
@@ -0,0 +1,18 @@
+const DEFAULT_MINIMUM_SAMPLE_SIZE: usize = 30;
+const DEFAULT_FALSE_DISCOVERY_RATE: f64 = 0.10;
+
+#[derive(Debug, Clone, serde::Deserialize)]
+#[serde(default)]
+pub struct AnalysisConfig {
+    pub minimum_sample_size: usize,
+    pub false_discovery_rate: f64,
+}
+
+impl Default for AnalysisConfig {
+    fn default() -> Self {
+        Self {
+            minimum_sample_size: DEFAULT_MINIMUM_SAMPLE_SIZE,
+            false_discovery_rate: DEFAULT_FALSE_DISCOVERY_RATE,
+        }
+    }
+}
diff --git a/crates/config/src/app_config.rs b/crates/config/src/app_config.rs
index e0dc6d8..bc08305 100644
--- a/crates/config/src/app_config.rs
+++ b/crates/config/src/app_config.rs
@@ -1,4 +1,7 @@
-use super::{AuthConfig, EntryConfig, PresetConfig, PushConfig, ServerConfig, StorageConfig};
+use super::{
+    AnalysisConfig, AuthConfig, EntryConfig, ImportConfig, PresetConfig, ProviderConfig,
+    PushConfig, ServerConfig, StorageConfig, WorkerConfig,
+};
 
 #[derive(Debug, Default, Clone, serde::Deserialize)]
 #[serde(default)]
@@ -9,4 +12,8 @@ pub struct AppConfig {
     pub auth: AuthConfig,
     pub push: PushConfig,
     pub preset: PresetConfig,
+    pub provider: ProviderConfig,
+    pub analysis: AnalysisConfig,
+    pub import: ImportConfig,
+    pub worker: WorkerConfig,
 }
diff --git a/crates/config/src/errors.rs b/crates/config/src/errors.rs
new file mode 100644
index 0000000..b4ab1e6
--- /dev/null
+++ b/crates/config/src/errors.rs
@@ -0,0 +1,7 @@
+#[derive(Debug, thiserror::Error)]
+pub enum ConfigError {
+    #[error("configuration file {0} was named by the environment but does not exist")]
+    NamedFileMissing(String),
+    #[error("could not read configuration: {0}")]
+    Unreadable(#[from] Box<figment::Error>),
+}
diff --git a/crates/config/src/import_config.rs b/crates/config/src/import_config.rs
new file mode 100644
index 0000000..bf8fb31
--- /dev/null
+++ b/crates/config/src/import_config.rs
@@ -0,0 +1,18 @@
+const DEFAULT_MAXIMUM_DAYS_PER_IMPORT: usize = 90;
+const DEFAULT_REJECTIONS_KEPT: usize = 200;
+
+#[derive(Debug, Clone, serde::Deserialize)]
+#[serde(default)]
+pub struct ImportConfig {
+    pub maximum_days_per_import: usize,
+    pub rejections_kept: usize,
+}
+
+impl Default for ImportConfig {
+    fn default() -> Self {
+        Self {
+            maximum_days_per_import: DEFAULT_MAXIMUM_DAYS_PER_IMPORT,
+            rejections_kept: DEFAULT_REJECTIONS_KEPT,
+        }
+    }
+}
diff --git a/crates/config/src/lib.rs b/crates/config/src/lib.rs
index d55a6c0..03c3974 100644
--- a/crates/config/src/lib.rs
+++ b/crates/config/src/lib.rs
@@ -1,15 +1,27 @@
+mod analysis_config;
 mod app_config;
 mod auth_config;
 mod entry_config;
+mod errors;
+mod import_config;
+mod loader;
 mod preset;
+mod provider_config;
 mod push_config;
 mod server_config;
 mod storage_config;
+mod worker_config;
 
+pub use analysis_config::AnalysisConfig;
 pub use app_config::AppConfig;
 pub use auth_config::AuthConfig;
 pub use entry_config::EntryConfig;
+pub use errors::ConfigError;
+pub use import_config::ImportConfig;
+pub use loader::load;
 pub use preset::{PresetActivity, PresetConfig};
+pub use provider_config::ProviderConfig;
 pub use push_config::PushConfig;
 pub use server_config::{CorsConfig, ServerConfig};
 pub use storage_config::{MediaBackend, StorageConfig};
+pub use worker_config::WorkerConfig;
diff --git a/crates/config/src/loader.rs b/crates/config/src/loader.rs
new file mode 100644
index 0000000..931c505
--- /dev/null
+++ b/crates/config/src/loader.rs
@@ -0,0 +1,56 @@
+use std::path::Path;
+
+use figment::Figment;
+use figment::providers::{Env, Format, Toml};
+
+use crate::AppConfig;
+use crate::errors::ConfigError;
+
+const DEFAULT_CONFIG_FILE: &str = "config.toml";
+const CONFIG_FILE_VARIABLE: &str = "KMOOD_CONFIG_FILE";
+const VARIABLE_PREFIX: &str = "KMOOD_";
+const SECTION_SEPARATOR: &str = "__";
+
+pub fn load() -> Result<AppConfig, ConfigError> {
+    let named_file = std::env::var(CONFIG_FILE_VARIABLE).ok();
+    let path = named_file.as_deref().unwrap_or(DEFAULT_CONFIG_FILE);
+
+    if named_file.is_some() && !Path::new(path).exists() {
+        return Err(ConfigError::NamedFileMissing(path.to_owned()));
+    }
+
+    let config = Figment::new()
+        .merge(Toml::file(path))
+        .merge(Env::prefixed(VARIABLE_PREFIX).split(SECTION_SEPARATOR))
+        .extract()
+        .map_err(Box::new)?;
+
+    announce(path);
+
+    Ok(config)
+}
+
+fn announce(path: &str) {
+    if Path::new(path).exists() {
+        tracing::info!(path, "loaded configuration from file");
+    } else {
+        tracing::info!("no configuration file found, using defaults");
+    }
+
+    let overridden = overriding_variables();
+    if !overridden.is_empty() {
+        tracing::info!(
+            variables = ?overridden,
+            "configuration overridden from the environment"
+        );
+    }
+}
+
+fn overriding_variables() -> Vec<String> {
+    let mut names: Vec<String> = std::env::vars()
+        .map(|(name, _)| name)
+        .filter(|name| name.starts_with(VARIABLE_PREFIX) && name != CONFIG_FILE_VARIABLE)
+        .collect();
+    names.sort();
+    names
+}
diff --git a/crates/config/src/provider_config.rs b/crates/config/src/provider_config.rs
new file mode 100644
index 0000000..2e15cc8
--- /dev/null
+++ b/crates/config/src/provider_config.rs
@@ -0,0 +1,5 @@
+#[derive(Debug, Default, Clone, serde::Deserialize)]
+#[serde(default)]
+pub struct ProviderConfig {
+    pub encryption_key: Option<String>,
+}
diff --git a/crates/config/src/worker_config.rs b/crates/config/src/worker_config.rs
new file mode 100644
index 0000000..88c0d56
--- /dev/null
+++ b/crates/config/src/worker_config.rs
@@ -0,0 +1,39 @@
+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_JOBS_PER_POLL: usize = 20;
+const DEFAULT_ENQUEUED_PER_SWEEP: usize = 200;
+const DEFAULT_MOST_ATTEMPTS: u32 = 5;
+const DEFAULT_STALLED_AFTER_SECONDS: i64 = 300;
+const DEFAULT_LOOK_UP_WEATHER: bool = true;
+
+#[derive(Debug, Clone, serde::Deserialize)]
+#[serde(default)]
+pub struct WorkerConfig {
+    pub poll_seconds: u64,
+    pub sweep_seconds: u64,
+    pub session_cleanup_seconds: u64,
+    pub reminder_seconds: u64,
+    pub jobs_per_poll: usize,
+    pub enqueued_per_sweep: usize,
+    pub most_attempts: u32,
+    pub stalled_after_seconds: i64,
+    pub look_up_weather: bool,
+}
+
+impl Default for WorkerConfig {
+    fn default() -> Self {
+        Self {
+            poll_seconds: DEFAULT_POLL_SECONDS,
+            sweep_seconds: DEFAULT_SWEEP_SECONDS,
+            session_cleanup_seconds: DEFAULT_SESSION_CLEANUP_SECONDS,
+            reminder_seconds: DEFAULT_REMINDER_SECONDS,
+            jobs_per_poll: DEFAULT_JOBS_PER_POLL,
+            enqueued_per_sweep: DEFAULT_ENQUEUED_PER_SWEEP,
+            most_attempts: DEFAULT_MOST_ATTEMPTS,
+            stalled_after_seconds: DEFAULT_STALLED_AFTER_SECONDS,
+            look_up_weather: DEFAULT_LOOK_UP_WEATHER,
+        }
+    }
+}
diff --git a/crates/config/tests/loader.rs b/crates/config/tests/loader.rs
new file mode 100644
index 0000000..73ee159
--- /dev/null
+++ b/crates/config/tests/loader.rs
@@ -0,0 +1,7 @@
+#![allow(clippy::result_large_err)]
+
+#[path = "loader/layering_test.rs"]
+mod layering_test;
+
+#[path = "loader/rejection_test.rs"]
+mod rejection_test;
diff --git a/crates/config/tests/loader/layering_test.rs b/crates/config/tests/loader/layering_test.rs
new file mode 100644
index 0000000..5ade261
--- /dev/null
+++ b/crates/config/tests/loader/layering_test.rs
@@ -0,0 +1,138 @@
+use figment::Jail;
+
+use config::{MediaBackend, load};
+
+const CONFIG_FILE: &str = "config.toml";
+
+#[test]
+fn with_no_file_and_no_environment_every_default_stands() {
+    Jail::expect_with(|_jail| {
+        let loaded = load().unwrap();
+
+        assert_eq!(loaded.server.port, 3000);
+        assert_eq!(loaded.server.host, "0.0.0.0");
+        assert_eq!(loaded.storage.data_dir, "./data");
+        assert!(loaded.auth.jwt_secret.is_none());
+        Ok(())
+    });
+}
+
+#[test]
+fn a_file_overrides_the_defaults_it_names() {
+    Jail::expect_with(|jail| {
+        jail.create_file(CONFIG_FILE, "[server]\nport = 4321\n")?;
+
+        let loaded = load().unwrap();
+
+        assert_eq!(loaded.server.port, 4321);
+        assert_eq!(loaded.server.host, "0.0.0.0");
+        Ok(())
+    });
+}
+
+#[test]
+fn the_environment_overrides_the_file() {
+    Jail::expect_with(|jail| {
+        jail.create_file(CONFIG_FILE, "[server]\nport = 4321\nhost = \"127.0.0.1\"\n")?;
+        jail.set_env("KMOOD_SERVER__PORT", "8080");
+
+        let loaded = load().unwrap();
+
+        assert_eq!(loaded.server.port, 8080);
+        assert_eq!(loaded.server.host, "127.0.0.1");
+        Ok(())
+    });
+}
+
+#[test]
+fn a_double_underscore_descends_a_section() {
+    Jail::expect_with(|jail| {
+        jail.set_env("KMOOD_SERVER__CORS__ALLOW_ANY_ORIGIN", "false");
+
+        let loaded = load().unwrap();
+
+        assert!(!loaded.server.cors.allow_any_origin);
+        Ok(())
+    });
+}
+
+#[test]
+fn a_single_underscore_stays_inside_a_field_name() {
+    Jail::expect_with(|jail| {
+        jail.set_env("KMOOD_STORAGE__DATA_DIR", "/var/lib/kmood");
+        jail.set_env("KMOOD_AUTH__JWT_SECRET", "from-the-environment");
+
+        let loaded = load().unwrap();
+
+        assert_eq!(loaded.storage.data_dir, "/var/lib/kmood");
+        assert_eq!(
+            loaded.auth.jwt_secret.as_deref(),
+            Some("from-the-environment")
+        );
+        Ok(())
+    });
+}
+
+#[test]
+fn the_environment_can_switch_the_media_backend() {
+    Jail::expect_with(|jail| {
+        jail.set_env("KMOOD_STORAGE__MEDIA__BACKEND", "s3");
+        jail.set_env("KMOOD_STORAGE__MEDIA__BUCKET", "moods");
+        jail.set_env("KMOOD_STORAGE__MEDIA__REGION", "eu-central-1");
+
+        let loaded = load().unwrap();
+
+        match loaded.storage.media {
+            MediaBackend::S3 { bucket, region, .. } => {
+                assert_eq!(bucket, "moods");
+                assert_eq!(region, "eu-central-1");
+            }
+            other => panic!("expected the s3 backend, got {other:?}"),
+        }
+        Ok(())
+    });
+}
+
+#[test]
+fn an_unrelated_variable_leaves_the_configuration_alone() {
+    Jail::expect_with(|jail| {
+        jail.set_env("PORT", "9999");
+        jail.set_env("SERVER__PORT", "9999");
+
+        let loaded = load().unwrap();
+
+        assert_eq!(loaded.server.port, 3000);
+        Ok(())
+    });
+}
+
+#[test]
+fn a_list_arrives_as_an_array() {
+    Jail::expect_with(|jail| {
+        jail.set_env(
+            "KMOOD_SERVER__CORS__ALLOWED_ORIGINS",
+            r#"["https://a.example","https://b.example"]"#,
+        );
+
+        let loaded = load().unwrap();
+
+        assert_eq!(
+            loaded.server.cors.allowed_origins,
+            vec!["https://a.example", "https://b.example"]
+        );
+        Ok(())
+    });
+}
+
+#[test]
+fn the_file_to_read_can_be_named_by_the_environment() {
+    Jail::expect_with(|jail| {
+        jail.create_file("elsewhere.toml", "[server]\nport = 7777\n")?;
+        jail.set_env("KMOOD_CONFIG_FILE", "elsewhere.toml");
+
+        let loaded = load().unwrap();
+
+        assert_eq!(loaded.server.port, 7777);
+        Ok(())
+    });
+}
diff --git a/crates/config/tests/loader/rejection_test.rs b/crates/config/tests/loader/rejection_test.rs
new file mode 100644
index 0000000..5c60011
--- /dev/null
+++ b/crates/config/tests/loader/rejection_test.rs
@@ -0,0 +1,47 @@
+use figment::Jail;
+
+use config::load;
+
+const CONFIG_FILE: &str = "config.toml";
+
+#[test]
+fn a_malformed_file_is_refused_rather_than_ignored() {
+    Jail::expect_with(|jail| {
+        jail.create_file(CONFIG_FILE, "[server\nport = ")?;
+
+        assert!(load().is_err());
+        Ok(())
+    });
+}
+
+#[test]
+fn a_value_of_the_wrong_type_is_refused() {
+    Jail::expect_with(|jail| {
+        jail.set_env("KMOOD_SERVER__PORT", "not-a-port");
+
+        assert!(load().is_err());
+        Ok(())
+    });
+}
+
+#[test]
+fn a_refusal_names_the_key_at_fault() {
+    Jail::expect_with(|jail| {
+        jail.set_env("KMOOD_SERVER__PORT", "not-a-port");
+
+        let message = load().unwrap_err().to_string().to_lowercase();
+
+        assert!(message.contains("port"), "unhelpful message: {message}");
+        Ok(())
+    });
+}
+
+#[test]
+fn a_named_file_that_is_missing_is_refused_rather_than_ignored() {
+    Jail::expect_with(|jail| {
+        jail.set_env("KMOOD_CONFIG_FILE", "nowhere.toml");
+
+        assert!(load().is_err());
+        Ok(())
+    });
+}
diff --git a/crates/domain/Cargo.toml b/crates/domain/Cargo.toml
index ae7bd28..5729e97 100644
--- a/crates/domain/Cargo.toml
+++ b/crates/domain/Cargo.toml
@@ -8,6 +8,7 @@ thiserror.workspace = true
 async-trait.workspace = true
 uuid.workspace = true
 chrono.workspace = true
+chrono-tz.workspace = true
 serde.workspace = true
 email_address.workspace = true
 tracing.workspace = true
diff --git a/crates/domain/src/api_token/api_token.rs b/crates/domain/src/api_token/api_token.rs
new file mode 100644
index 0000000..ae3d468
--- /dev/null
+++ b/crates/domain/src/api_token/api_token.rs
@@ -0,0 +1,89 @@
+use chrono::{DateTime, Utc};
+
+use crate::provider::ProviderName;
+use crate::user::UserId;
+
+use super::{ApiTokenId, TokenDigest, TokenScope};
+
+pub struct ApiTokenData {
+    pub id: ApiTokenId,
+    pub user_id: UserId,
+    pub name: ProviderName,
+    pub digest: TokenDigest,
+    pub scope: TokenScope,
+    pub created_at: DateTime<Utc>,
+    pub last_used_at: Option<DateTime<Utc>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ApiToken {
+    id: ApiTokenId,
+    user_id: UserId,
+    name: ProviderName,
+    digest: TokenDigest,
+    scope: TokenScope,
+    created_at: DateTime<Utc>,
+    last_used_at: Option<DateTime<Utc>>,
+}
+
+impl ApiToken {
+    pub fn new(user_id: UserId, name: ProviderName, digest: TokenDigest) -> Self {
+        Self {
+            id: ApiTokenId::generate(),
+            user_id,
+            name,
+            digest,
+            scope: TokenScope::WriteMetrics,
+            created_at: Utc::now(),
+            last_used_at: None,
+        }
+    }
+
+    pub fn from_persistence(data: ApiTokenData) -> Self {
+        Self {
+            id: data.id,
+            user_id: data.user_id,
+            name: data.name,
+            digest: data.digest,
+            scope: data.scope,
+            created_at: data.created_at,
+            last_used_at: data.last_used_at,
+        }
+    }
+}
+
+impl ApiToken {
+    pub fn id(&self) -> &ApiTokenId {
+        &self.id
+    }
+
+    pub fn user_id(&self) -> &UserId {
+        &self.user_id
+    }
+
+    pub fn name(&self) -> &ProviderName {
+        &self.name
+    }
+
+    pub fn digest(&self) -> &TokenDigest {
+        &self.digest
+    }
+
+    pub fn scope(&self) -> TokenScope {
+        self.scope
+    }
+
+    pub fn created_at(&self) -> &DateTime<Utc> {
+        &self.created_at
+    }
+
+    pub fn last_used_at(&self) -> Option<&DateTime<Utc>> {
+        self.last_used_at.as_ref()
+    }
+}
+
+impl ApiToken {
+    pub fn mark_used(&mut self) {
+        self.last_used_at = Some(Utc::now());
+    }
+}
diff --git a/crates/domain/src/api_token/api_token_id.rs b/crates/domain/src/api_token/api_token_id.rs
new file mode 100644
index 0000000..5320750
--- /dev/null
+++ b/crates/domain/src/api_token/api_token_id.rs
@@ -0,0 +1,3 @@
+use crate::macros::uuid_id;
+
+uuid_id!(ApiTokenId);
diff --git a/crates/domain/src/api_token/minted_api_token.rs b/crates/domain/src/api_token/minted_api_token.rs
new file mode 100644
index 0000000..a27ce91
--- /dev/null
+++ b/crates/domain/src/api_token/minted_api_token.rs
@@ -0,0 +1,29 @@
+use super::ApiToken;
+
+pub struct MintedApiToken {
+    token: ApiToken,
+    secret: String,
+}
+
+impl MintedApiToken {
+    pub fn new(token: ApiToken, secret: String) -> Self {
+        Self { token, secret }
+    }
+
+    pub fn token(&self) -> &ApiToken {
+        &self.token
+    }
+
+    pub fn secret(&self) -> &str {
+        &self.secret
+    }
+}
+
+impl std::fmt::Debug for MintedApiToken {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MintedApiToken")
+            .field("token", &self.token)
+            .field("secret", &"<shown once, never logged>")
+            .finish()
+    }
+}
diff --git a/crates/domain/src/api_token/mod.rs b/crates/domain/src/api_token/mod.rs
new file mode 100644
index 0000000..be4d074
--- /dev/null
+++ b/crates/domain/src/api_token/mod.rs
@@ -0,0 +1,11 @@
+mod api_token;
+mod api_token_id;
+mod minted_api_token;
+mod token_digest;
+mod token_scope;
+
+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;
diff --git a/crates/domain/src/api_token/token_digest.rs b/crates/domain/src/api_token/token_digest.rs
new file mode 100644
index 0000000..0016744
--- /dev/null
+++ b/crates/domain/src/api_token/token_digest.rs
@@ -0,0 +1,18 @@
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct TokenDigest(String);
+
+impl TokenDigest {
+    pub fn from_persistence(digest: String) -> Self {
+        Self(digest)
+    }
+
+    pub fn value(&self) -> &str {
+        &self.0
+    }
+}
+
+impl std::fmt::Debug for TokenDigest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("TokenDigest(<redacted>)")
+    }
+}
diff --git a/crates/domain/src/api_token/token_scope.rs b/crates/domain/src/api_token/token_scope.rs
new file mode 100644
index 0000000..6969510
--- /dev/null
+++ b/crates/domain/src/api_token/token_scope.rs
@@ -0,0 +1,21 @@
+const WRITE_METRICS: &str = "writeMetrics";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum TokenScope {
+    WriteMetrics,
+}
+
+impl TokenScope {
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::WriteMetrics => WRITE_METRICS,
+        }
+    }
+
+    pub fn from_name(name: &str) -> Option<Self> {
+        match name {
+            WRITE_METRICS => Some(Self::WriteMetrics),
+            _ => None,
+        }
+    }
+}
diff --git a/crates/domain/src/correlation/adjustment.rs b/crates/domain/src/correlation/adjustment.rs
new file mode 100644
index 0000000..8e7b63b
--- /dev/null
+++ b/crates/domain/src/correlation/adjustment.rs
@@ -0,0 +1,76 @@
+use std::collections::BTreeMap;
+
+use super::{CorrelationStrategy, Family, PValue};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Tested {
+    pub family: Family,
+    pub strategy: CorrelationStrategy,
+    pub p_value: PValue,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct Adjustment {
+    false_discovery_rate: f64,
+}
+
+impl Adjustment {
+    pub fn controlling_false_discovery_at(false_discovery_rate: f64) -> Self {
+        Self {
+            false_discovery_rate,
+        }
+    }
+
+    pub fn holds_up_across(&self, tested: &[Tested]) -> Vec<bool> {
+        let mut groups: BTreeMap<(Family, CorrelationStrategy), Vec<usize>> = BTreeMap::new();
+        for (index, entry) in tested.iter().enumerate() {
+            groups
+                .entry((entry.family, entry.strategy))
+                .or_default()
+                .push(index);
+        }
+
+        let mut held = vec![false; tested.len()];
+
+        for places in groups.values() {
+            let p_values: Vec<PValue> = places.iter().map(|index| tested[*index].p_value).collect();
+
+            for (place, holds) in places.iter().zip(self.holds_up(&p_values)) {
+                held[*place] = holds;
+            }
+        }
+
+        held
+    }
+
+    pub fn holds_up(&self, p_values: &[PValue]) -> Vec<bool> {
+        let tested = p_values.len();
+
+        let mut by_size: Vec<usize> = (0..tested).collect();
+        by_size.sort_by(|left, right| p_values[*left].value().total_cmp(&p_values[*right].value()));
+
+        let largest_passing_rank = by_size
+            .iter()
+            .enumerate()
+            .filter(|(position, index)| {
+                p_values[**index].value() <= self.threshold_at(position + 1, tested)
+            })
+            .map(|(position, _)| position + 1)
+            .max();
+
+        let Some(rank) = largest_passing_rank else {
+            return vec![false; tested];
+        };
+
+        let mut held = vec![false; tested];
+        for index in &by_size[..rank] {
+            held[*index] = true;
+        }
+
+        held
+    }
+
+    fn threshold_at(&self, rank: usize, tested: usize) -> f64 {
+        rank as f64 / tested as f64 * self.false_discovery_rate
+    }
+}
diff --git a/crates/domain/src/correlation/agreement.rs b/crates/domain/src/correlation/agreement.rs
new file mode 100644
index 0000000..8bb2fce
--- /dev/null
+++ b/crates/domain/src/correlation/agreement.rs
@@ -0,0 +1,29 @@
+use super::Coefficient;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Agreement {
+    agreeing: usize,
+    applicable: usize,
+}
+
+impl Agreement {
+    pub fn of(scores: &[Coefficient], applicable: usize) -> Self {
+        let positive = scores.iter().filter(|score| score.value() > 0.0).count();
+        let negative = scores.iter().filter(|score| score.value() < 0.0).count();
+
+        Self {
+            agreeing: positive.max(negative),
+            applicable,
+        }
+    }
+}
+
+impl Agreement {
+    pub fn agreeing(&self) -> usize {
+        self.agreeing
+    }
+
+    pub fn applicable(&self) -> usize {
+        self.applicable
+    }
+}
diff --git a/crates/domain/src/correlation/coefficient.rs b/crates/domain/src/correlation/coefficient.rs
new file mode 100644
index 0000000..1f3aca3
--- /dev/null
+++ b/crates/domain/src/correlation/coefficient.rs
@@ -0,0 +1,29 @@
+use crate::errors::DomainError;
+
+const STRONGEST_NEGATIVE: f64 = -1.0;
+const STRONGEST_POSITIVE: f64 = 1.0;
+
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct Coefficient(f64);
+
+impl Coefficient {
+    pub fn new(value: f64) -> Result<Self, DomainError> {
+        if !value.is_finite() {
+            return Err(DomainError::InvalidInput(
+                "a correlation coefficient must be a finite number".into(),
+            ));
+        }
+
+        if !(STRONGEST_NEGATIVE..=STRONGEST_POSITIVE).contains(&value) {
+            return Err(DomainError::InvalidInput(format!(
+                "a correlation coefficient must be between {STRONGEST_NEGATIVE} and {STRONGEST_POSITIVE}, got {value}"
+            )));
+        }
+
+        Ok(Self(value))
+    }
+
+    pub fn value(&self) -> f64 {
+        self.0
+    }
+}
diff --git a/crates/domain/src/correlation/correlation_input.rs b/crates/domain/src/correlation/correlation_input.rs
new file mode 100644
index 0000000..95d1731
--- /dev/null
+++ b/crates/domain/src/correlation/correlation_input.rs
@@ -0,0 +1,48 @@
+use crate::activity::ActivityId;
+use crate::metric::MetricKind;
+
+use super::{Family, SeriesShape};
+
+const MOON_PHASE: &str = "moonPhase";
+const ACTIVITY: &str = "activity";
+const CYCLE_PROGRESS: &str = "cycleProgress";
+const TEMPERATURE: &str = "temperature";
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum CorrelationInput {
+    Metric(MetricKind),
+    MoonPhase,
+    CycleProgress,
+    Temperature,
+    Activity(ActivityId),
+}
+
+impl CorrelationInput {
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::Metric(kind) => kind.name(),
+            Self::MoonPhase => MOON_PHASE,
+            Self::CycleProgress => CYCLE_PROGRESS,
+            Self::Temperature => TEMPERATURE,
+            Self::Activity(_) => ACTIVITY,
+        }
+    }
+
+    pub fn family(&self) -> Family {
+        match self {
+            Self::Metric(_) | Self::MoonPhase | Self::CycleProgress | Self::Temperature => {
+                Family::Measurements
+            }
+            Self::Activity(_) => Family::Activities,
+        }
+    }
+
+    pub fn series(&self) -> SeriesShape {
+        match self {
+            Self::Metric(_) | Self::MoonPhase | Self::CycleProgress | Self::Temperature => {
+                SeriesShape::Continuous
+            }
+            Self::Activity(_) => SeriesShape::Presence,
+        }
+    }
+}
diff --git a/crates/domain/src/correlation/correlation_strategy.rs b/crates/domain/src/correlation/correlation_strategy.rs
new file mode 100644
index 0000000..e05c92c
--- /dev/null
+++ b/crates/domain/src/correlation/correlation_strategy.rs
@@ -0,0 +1,113 @@
+use super::PValue;
+use super::kendall::kendall_tau_b;
+use super::mean_difference::mean_difference;
+use super::pearson::pearson;
+use super::ranks::average_ranks;
+use super::welch::welch_standard_score;
+use super::{Coefficient, CorrelationInput, Observation, SeriesShape};
+
+const PEARSON: &str = "pearson";
+const SPEARMAN: &str = "spearman";
+const KENDALL: &str = "kendall";
+const MEAN_DIFFERENCE: &str = "meanDifference";
+const FEWEST_OBSERVATIONS: usize = 2;
+const FEWEST_FOR_A_P_VALUE: usize = 4;
+const SPEARMAN_VARIANCE_INFLATION: f64 = 1.06;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum CorrelationStrategy {
+    Pearson,
+    Spearman,
+    Kendall,
+    MeanDifference,
+}
+
+impl CorrelationStrategy {
+    pub const ALL: [CorrelationStrategy; 4] = [
+        Self::Pearson,
+        Self::Spearman,
+        Self::Kendall,
+        Self::MeanDifference,
+    ];
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::Pearson => PEARSON,
+            Self::Spearman => SPEARMAN,
+            Self::Kendall => KENDALL,
+            Self::MeanDifference => MEAN_DIFFERENCE,
+        }
+    }
+
+    pub fn scores(&self) -> SeriesShape {
+        match self {
+            Self::Pearson | Self::Spearman | Self::Kendall => SeriesShape::Continuous,
+            Self::MeanDifference => SeriesShape::Presence,
+        }
+    }
+
+    pub fn can_score(&self, input: &CorrelationInput) -> bool {
+        self.scores() == input.series()
+    }
+
+    pub fn significance(&self, observations: &[Observation]) -> Option<PValue> {
+        if observations.len() < FEWEST_FOR_A_P_VALUE {
+            return None;
+        }
+
+        self.standard_score(observations)
+            .map(PValue::from_standard_score)
+    }
+
+    fn standard_score(&self, observations: &[Observation]) -> Option<f64> {
+        let (values, moods) = series(observations);
+        let count = observations.len() as f64;
+
+        match self {
+            Self::Pearson => {
+                let scored = pearson(&values, &moods)?;
+                Some(fisher(scored, count, 1.0))
+            }
+            Self::Spearman => {
+                let scored = pearson(&average_ranks(&values), &average_ranks(&moods))?;
+                Some(fisher(scored, count, SPEARMAN_VARIANCE_INFLATION))
+            }
+            Self::Kendall => {
+                let scored = kendall_tau_b(&values, &moods)?;
+                Some(scored * (9.0 * count * (count - 1.0) / (2.0 * (2.0 * count + 5.0))).sqrt())
+            }
+            Self::MeanDifference => welch_standard_score(&values, &moods),
+        }
+    }
+
+    pub fn score(&self, observations: &[Observation]) -> Option<Coefficient> {
+        if observations.len() < FEWEST_OBSERVATIONS {
+            return None;
+        }
+
+        let (values, moods) = series(observations);
+
+        let scored = match self {
+            Self::Pearson => pearson(&values, &moods),
+            Self::Spearman => pearson(&average_ranks(&values), &average_ranks(&moods)),
+            Self::Kendall => kendall_tau_b(&values, &moods),
+            Self::MeanDifference => mean_difference(&values, &moods),
+        }?;
+
+        Coefficient::new(scored.clamp(-1.0, 1.0)).ok()
+    }
+}
+
+fn series(observations: &[Observation]) -> (Vec<f64>, Vec<f64>) {
+    let values = observations.iter().map(Observation::value).collect();
+    let moods = observations
+        .iter()
+        .map(|observation| observation.day_mood().value())
+        .collect();
+
+    (values, moods)
+}
+
+fn fisher(scored: f64, count: f64, variance_inflation: f64) -> f64 {
+    scored.atanh() * ((count - 3.0) / variance_inflation).sqrt()
+}
diff --git a/crates/domain/src/correlation/family.rs b/crates/domain/src/correlation/family.rs
new file mode 100644
index 0000000..c63477d
--- /dev/null
+++ b/crates/domain/src/correlation/family.rs
@@ -0,0 +1,5 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Family {
+    Measurements,
+    Activities,
+}
diff --git a/crates/domain/src/correlation/kendall.rs b/crates/domain/src/correlation/kendall.rs
new file mode 100644
index 0000000..0400f0b
--- /dev/null
+++ b/crates/domain/src/correlation/kendall.rs
@@ -0,0 +1,63 @@
+pub fn kendall_tau_b(left: &[f64], right: &[f64]) -> Option<f64> {
+    let mut concordant = 0i64;
+    let mut discordant = 0i64;
+
+    for first in 0..left.len() {
+        for second in (first + 1)..left.len() {
+            let agreement =
+                direction(left[first] - left[second]) * direction(right[first] - right[second]);
+
+            match agreement {
+                1 => concordant += 1,
+                -1 => discordant += 1,
+                _ => continue,
+            }
+        }
+    }
+
+    let pairs = pair_count(left.len());
+    let denominator = ((pairs - tied_pairs(left)) * (pairs - tied_pairs(right))).sqrt();
+
+    if denominator == 0.0 {
+        return None;
+    }
+
+    Some((concordant - discordant) as f64 / denominator)
+}
+
+fn direction(difference: f64) -> i64 {
+    if difference > 0.0 {
+        return 1;
+    }
+    if difference < 0.0 {
+        return -1;
+    }
+
+    0
+}
+
+fn pair_count(len: usize) -> f64 {
+    let len = len as f64;
+
+    len * (len - 1.0) / 2.0
+}
+
+fn tied_pairs(values: &[f64]) -> f64 {
+    let mut sorted = values.to_vec();
+    sorted.sort_by(|left, right| left.total_cmp(right));
+
+    let mut tied = 0.0;
+    let mut start = 0;
+
+    while start < sorted.len() {
+        let mut end = start;
+        while end + 1 < sorted.len() && sorted[end + 1] == sorted[start] {
+            end += 1;
+        }
+
+        tied += pair_count(end - start + 1);
+        start = end + 1;
+    }
+
+    tied
+}
diff --git a/crates/domain/src/correlation/mean_difference.rs b/crates/domain/src/correlation/mean_difference.rs
new file mode 100644
index 0000000..42f8bf1
--- /dev/null
+++ b/crates/domain/src/correlation/mean_difference.rs
@@ -0,0 +1,33 @@
+use crate::entry::Mood;
+
+const PRESENT: f64 = 1.0;
+
+pub fn mean_difference(values: &[f64], moods: &[f64]) -> Option<f64> {
+    let present: Vec<f64> = pick(values, moods, |value| value == PRESENT);
+    let absent: Vec<f64> = pick(values, moods, |value| value != PRESENT);
+
+    let difference = mean(&present)? - mean(&absent)?;
+
+    Some(difference / mood_span())
+}
+
+fn pick(values: &[f64], moods: &[f64], wanted: impl Fn(f64) -> bool) -> Vec<f64> {
+    values
+        .iter()
+        .zip(moods)
+        .filter(|(value, _)| wanted(**value))
+        .map(|(_, mood)| *mood)
+        .collect()
+}
+
+fn mean(moods: &[f64]) -> Option<f64> {
+    if moods.is_empty() {
+        return None;
+    }
+
+    Some(moods.iter().sum::<f64>() / moods.len() as f64)
+}
+
+fn mood_span() -> f64 {
+    f64::from(Mood::Rad.value() - Mood::Awful.value())
+}
diff --git a/crates/domain/src/correlation/mod.rs b/crates/domain/src/correlation/mod.rs
new file mode 100644
index 0000000..72aa4e2
--- /dev/null
+++ b/crates/domain/src/correlation/mod.rs
@@ -0,0 +1,25 @@
+mod adjustment;
+mod agreement;
+mod coefficient;
+mod correlation_input;
+mod correlation_strategy;
+mod family;
+mod kendall;
+mod mean_difference;
+mod normal;
+mod observation;
+mod p_value;
+mod pearson;
+mod ranks;
+mod series_shape;
+mod welch;
+
+pub use adjustment::{Adjustment, Tested};
+pub use agreement::Agreement;
+pub use coefficient::Coefficient;
+pub use correlation_input::CorrelationInput;
+pub use correlation_strategy::CorrelationStrategy;
+pub use family::Family;
+pub use observation::Observation;
+pub use p_value::PValue;
+pub use series_shape::SeriesShape;
diff --git a/crates/domain/src/correlation/normal.rs b/crates/domain/src/correlation/normal.rs
new file mode 100644
index 0000000..ee4ab4e
--- /dev/null
+++ b/crates/domain/src/correlation/normal.rs
@@ -0,0 +1,23 @@
+const ERF_A1: f64 = 0.254_829_592;
+const ERF_A2: f64 = -0.284_496_736;
+const ERF_A3: f64 = 1.421_413_741;
+const ERF_A4: f64 = -1.453_152_027;
+const ERF_A5: f64 = 1.061_405_429;
+const ERF_P: f64 = 0.327_591_1;
+
+pub fn two_sided_tail(standard_score: f64) -> f64 {
+    let beyond = 1.0 - error_function(standard_score.abs() / std::f64::consts::SQRT_2);
+
+    beyond.clamp(0.0, 1.0)
+}
+
+fn error_function(x: f64) -> f64 {
+    if x < 0.0 {
+        return -error_function(-x);
+    }
+
+    let t = 1.0 / (1.0 + ERF_P * x);
+    let series = t * (ERF_A1 + t * (ERF_A2 + t * (ERF_A3 + t * (ERF_A4 + t * ERF_A5))));
+
+    1.0 - series * (-x * x).exp()
+}
diff --git a/crates/domain/src/correlation/observation.rs b/crates/domain/src/correlation/observation.rs
new file mode 100644
index 0000000..6699632
--- /dev/null
+++ b/crates/domain/src/correlation/observation.rs
@@ -0,0 +1,21 @@
+use crate::entry::DayMood;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Observation {
+    value: f64,
+    day_mood: DayMood,
+}
+
+impl Observation {
+    pub fn new(value: f64, day_mood: DayMood) -> Self {
+        Self { value, day_mood }
+    }
+
+    pub fn value(&self) -> f64 {
+        self.value
+    }
+
+    pub fn day_mood(&self) -> DayMood {
+        self.day_mood
+    }
+}
diff --git a/crates/domain/src/correlation/p_value.rs b/crates/domain/src/correlation/p_value.rs
new file mode 100644
index 0000000..b9df2b6
--- /dev/null
+++ b/crates/domain/src/correlation/p_value.rs
@@ -0,0 +1,29 @@
+use crate::errors::DomainError;
+
+use super::normal::two_sided_tail;
+
+const CERTAIN: f64 = 1.0;
+const IMPOSSIBLE: f64 = 0.0;
+
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct PValue(f64);
+
+impl PValue {
+    pub fn new(value: f64) -> Result<Self, DomainError> {
+        if !value.is_finite() || !(IMPOSSIBLE..=CERTAIN).contains(&value) {
+            return Err(DomainError::InvalidInput(format!(
+                "a p-value must be between {IMPOSSIBLE} and {CERTAIN}, got {value}"
+            )));
+        }
+
+        Ok(Self(value))
+    }
+
+    pub fn from_standard_score(standard_score: f64) -> Self {
+        Self(two_sided_tail(standard_score))
+    }
+
+    pub fn value(&self) -> f64 {
+        self.0
+    }
+}
diff --git a/crates/domain/src/correlation/pearson.rs b/crates/domain/src/correlation/pearson.rs
new file mode 100644
index 0000000..a253241
--- /dev/null
+++ b/crates/domain/src/correlation/pearson.rs
@@ -0,0 +1,20 @@
+pub fn pearson(left: &[f64], right: &[f64]) -> Option<f64> {
+    let count = left.len() as f64;
+    let left_mean = left.iter().sum::<f64>() / count;
+    let right_mean = right.iter().sum::<f64>() / count;
+
+    let covariance: f64 = left
+        .iter()
+        .zip(right)
+        .map(|(l, r)| (l - left_mean) * (r - right_mean))
+        .sum();
+
+    let left_variance: f64 = left.iter().map(|l| (l - left_mean).powi(2)).sum();
+    let right_variance: f64 = right.iter().map(|r| (r - right_mean).powi(2)).sum();
+
+    if left_variance == 0.0 || right_variance == 0.0 {
+        return None;
+    }
+
+    Some(covariance / (left_variance * right_variance).sqrt())
+}
diff --git a/crates/domain/src/correlation/ranks.rs b/crates/domain/src/correlation/ranks.rs
new file mode 100644
index 0000000..6fcb6be
--- /dev/null
+++ b/crates/domain/src/correlation/ranks.rs
@@ -0,0 +1,30 @@
+pub fn average_ranks(values: &[f64]) -> Vec<f64> {
+    let mut order: Vec<usize> = (0..values.len()).collect();
+    order.sort_by(|left, right| values[*left].total_cmp(&values[*right]));
+
+    let mut ranks = vec![0.0; values.len()];
+    let mut start = 0;
+
+    while start < order.len() {
+        let mut end = start;
+        while end + 1 < order.len() && values[order[end + 1]] == values[order[start]] {
+            end += 1;
+        }
+
+        let shared = shared_rank(start, end);
+        for position in &order[start..=end] {
+            ranks[*position] = shared;
+        }
+
+        start = end + 1;
+    }
+
+    ranks
+}
+
+fn shared_rank(start: usize, end: usize) -> f64 {
+    let first = start as f64 + 1.0;
+    let last = end as f64 + 1.0;
+
+    (first + last) / 2.0
+}
diff --git a/crates/domain/src/correlation/series_shape.rs b/crates/domain/src/correlation/series_shape.rs
new file mode 100644
index 0000000..9e4e284
--- /dev/null
+++ b/crates/domain/src/correlation/series_shape.rs
@@ -0,0 +1,5 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum SeriesShape {
+    Continuous,
+    Presence,
+}
diff --git a/crates/domain/src/correlation/welch.rs b/crates/domain/src/correlation/welch.rs
new file mode 100644
index 0000000..f4dfcd4
--- /dev/null
+++ b/crates/domain/src/correlation/welch.rs
@@ -0,0 +1,51 @@
+const PRESENT: f64 = 1.0;
+const FEWEST_FOR_A_SPREAD: usize = 2;
+
+pub fn welch_standard_score(values: &[f64], moods: &[f64]) -> Option<f64> {
+    let present = group(values, moods, |value| value == PRESENT);
+    let absent = group(values, moods, |value| value != PRESENT);
+
+    if present.len() < FEWEST_FOR_A_SPREAD || absent.len() < FEWEST_FOR_A_SPREAD {
+        return None;
+    }
+
+    let spread = (variance(&present)? / present.len() as f64
+        + variance(&absent)? / absent.len() as f64)
+        .sqrt();
+
+    if spread == 0.0 {
+        return None;
+    }
+
+    Some((mean(&present)? - mean(&absent)?) / spread)
+}
+
+fn group(values: &[f64], moods: &[f64], wanted: impl Fn(f64) -> bool) -> Vec<f64> {
+    values
+        .iter()
+        .zip(moods)
+        .filter(|(value, _)| wanted(**value))
+        .map(|(_, mood)| *mood)
+        .collect()
+}
+
+fn mean(moods: &[f64]) -> Option<f64> {
+    if moods.is_empty() {
+        return None;
+    }
+
+    Some(moods.iter().sum::<f64>() / moods.len() as f64)
+}
+
+fn variance(moods: &[f64]) -> Option<f64> {
+    let average = mean(moods)?;
+    let degrees_of_freedom = moods.len() as f64 - 1.0;
+
+    Some(
+        moods
+            .iter()
+            .map(|mood| (mood - average).powi(2))
+            .sum::<f64>()
+            / degrees_of_freedom,
+    )
+}
diff --git a/crates/domain/src/cycle/cycle_calendar.rs b/crates/domain/src/cycle/cycle_calendar.rs
new file mode 100644
index 0000000..196ac23
--- /dev/null
+++ b/crates/domain/src/cycle/cycle_calendar.rs
@@ -0,0 +1,63 @@
+use crate::entry::Date;
+
+use super::{CycleDay, CyclePosition};
+
+const ASSUMED_CYCLE_LENGTH: i64 = 28;
+
+pub struct CycleCalendar {
+    starts: Vec<Date>,
+}
+
+impl CycleCalendar {
+    pub fn new(starts: Vec<Date>) -> Self {
+        let mut starts = starts;
+        starts.sort();
+        starts.dedup();
+
+        Self { starts }
+    }
+}
+
+impl CycleCalendar {
+    pub fn starts(&self) -> &[Date] {
+        &self.starts
+    }
+
+    pub fn position_on(&self, date: &Date) -> Option<CyclePosition> {
+        let start = self.start_of_the_cycle_containing(date)?;
+        let elapsed = date.days_since(start);
+
+        let day = CycleDay::new(u16::try_from(elapsed + 1).ok()?).ok()?;
+        let length = self.length_of_the_cycle_from(start) as f64;
+
+        Some(CyclePosition::new(day, elapsed as f64 / length))
+    }
+
+    pub fn usual_length(&self) -> i64 {
+        let mut observed: Vec<i64> = self
+            .starts
+            .windows(2)
+            .map(|pair| pair[1].days_since(&pair[0]))
+            .collect();
+
+        if observed.is_empty() {
+            return ASSUMED_CYCLE_LENGTH;
+        }
+
+        observed.sort_unstable();
+
+        observed[observed.len() / 2]
+    }
+
+    fn start_of_the_cycle_containing(&self, date: &Date) -> Option<&Date> {
+        self.starts.iter().rev().find(|start| *start <= date)
+    }
+
+    fn length_of_the_cycle_from(&self, start: &Date) -> i64 {
+        self.starts
+            .iter()
+            .find(|next| *next > start)
+            .map(|next| next.days_since(start))
+            .unwrap_or_else(|| self.usual_length())
+    }
+}
diff --git a/crates/domain/src/cycle/cycle_day.rs b/crates/domain/src/cycle/cycle_day.rs
new file mode 100644
index 0000000..d6f2219
--- /dev/null
+++ b/crates/domain/src/cycle/cycle_day.rs
@@ -0,0 +1,23 @@
+use crate::errors::DomainError;
+
+const FIRST_DAY: u16 = 1;
+const LONGEST_PLAUSIBLE_CYCLE: u16 = 90;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct CycleDay(u16);
+
+impl CycleDay {
+    pub fn new(day: u16) -> Result<Self, DomainError> {
+        if !(FIRST_DAY..=LONGEST_PLAUSIBLE_CYCLE).contains(&day) {
+            return Err(DomainError::InvalidInput(format!(
+                "a cycle day must be between {FIRST_DAY} and {LONGEST_PLAUSIBLE_CYCLE}, got {day}"
+            )));
+        }
+
+        Ok(Self(day))
+    }
+
+    pub fn value(&self) -> u16 {
+        self.0
+    }
+}
diff --git a/crates/domain/src/cycle/cycle_position.rs b/crates/domain/src/cycle/cycle_position.rs
new file mode 100644
index 0000000..0126227
--- /dev/null
+++ b/crates/domain/src/cycle/cycle_position.rs
@@ -0,0 +1,24 @@
+use super::CycleDay;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct CyclePosition {
+    day: CycleDay,
+    progress: f64,
+}
+
+impl CyclePosition {
+    pub fn new(day: CycleDay, progress: f64) -> Self {
+        Self {
+            day,
+            progress: progress.clamp(0.0, 1.0),
+        }
+    }
+
+    pub fn day(&self) -> CycleDay {
+        self.day
+    }
+
+    pub fn progress(&self) -> f64 {
+        self.progress
+    }
+}
diff --git a/crates/domain/src/cycle/cycle_start_restore.rs b/crates/domain/src/cycle/cycle_start_restore.rs
new file mode 100644
index 0000000..5327547
--- /dev/null
+++ b/crates/domain/src/cycle/cycle_start_restore.rs
@@ -0,0 +1,14 @@
+use crate::entry::Date;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CycleStartRestore(Date);
+
+impl CycleStartRestore {
+    pub fn on(date: Date) -> Self {
+        Self(date)
+    }
+
+    pub fn date(&self) -> Date {
+        self.0
+    }
+}
diff --git a/crates/domain/src/cycle/mod.rs b/crates/domain/src/cycle/mod.rs
new file mode 100644
index 0000000..a509c48
--- /dev/null
+++ b/crates/domain/src/cycle/mod.rs
@@ -0,0 +1,9 @@
+mod cycle_calendar;
+mod cycle_day;
+mod cycle_position;
+mod cycle_start_restore;
+
+pub use cycle_calendar::CycleCalendar;
+pub use cycle_day::CycleDay;
+pub use cycle_position::CyclePosition;
+pub use cycle_start_restore::CycleStartRestore;
diff --git a/crates/domain/src/dimension/composed_entry.rs b/crates/domain/src/dimension/composed_entry.rs
new file mode 100644
index 0000000..02afbba
--- /dev/null
+++ b/crates/domain/src/dimension/composed_entry.rs
@@ -0,0 +1,44 @@
+use crate::activity::ActivityId;
+use crate::attachment::{PhotoId, VoiceMemoId};
+use crate::entry::{Content, MoodEntry};
+use crate::location::Coordinates;
+use crate::song::Song;
+use crate::weather::Weather;
+
+use super::DimensionValue;
+use super::lookup;
+
+pub struct ComposedEntry {
+    pub entry: MoodEntry,
+    pub dimensions: Vec<DimensionValue>,
+}
+
+impl ComposedEntry {
+    pub fn content(&self) -> Option<&Content> {
+        lookup::content_in(&self.dimensions)
+    }
+
+    pub fn activities(&self) -> &[ActivityId] {
+        lookup::activities_in(&self.dimensions)
+    }
+
+    pub fn photos(&self) -> &[PhotoId] {
+        lookup::photos_in(&self.dimensions)
+    }
+
+    pub fn voice_memos(&self) -> &[VoiceMemoId] {
+        lookup::voice_memos_in(&self.dimensions)
+    }
+
+    pub fn location(&self) -> Option<&Coordinates> {
+        lookup::location_in(&self.dimensions)
+    }
+
+    pub fn song(&self) -> Option<&Song> {
+        lookup::song_in(&self.dimensions)
+    }
+
+    pub fn weather(&self) -> Option<&Weather> {
+        lookup::weather_in(&self.dimensions)
+    }
+}
diff --git a/crates/domain/src/dimension/dimension_kind.rs b/crates/domain/src/dimension/dimension_kind.rs
new file mode 100644
index 0000000..c99d919
--- /dev/null
+++ b/crates/domain/src/dimension/dimension_kind.rs
@@ -0,0 +1,10 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+pub enum DimensionKind {
+    Content,
+    Activities,
+    Photos,
+    VoiceMemos,
+    Location,
+    Song,
+    Weather,
+}
diff --git a/crates/domain/src/dimension/dimension_value.rs b/crates/domain/src/dimension/dimension_value.rs
new file mode 100644
index 0000000..f969271
--- /dev/null
+++ b/crates/domain/src/dimension/dimension_value.rs
@@ -0,0 +1,39 @@
+use crate::activity::ActivityId;
+use crate::attachment::{PhotoId, VoiceMemoId};
+use crate::entry::Content;
+use crate::location::Coordinates;
+use crate::song::Song;
+use crate::weather::Weather;
+
+use super::DimensionKind;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum DimensionValue {
+    Content(Content),
+    Activities(Vec<ActivityId>),
+    Photos(Vec<PhotoId>),
+    VoiceMemos(Vec<VoiceMemoId>),
+    Location(Coordinates),
+    Song(Song),
+    Weather(Weather),
+}
+
+impl DimensionValue {
+    pub fn activities(mut ids: Vec<ActivityId>) -> Self {
+        ids.sort();
+        ids.dedup();
+        Self::Activities(ids)
+    }
+
+    pub fn kind(&self) -> DimensionKind {
+        match self {
+            Self::Content(_) => DimensionKind::Content,
+            Self::Activities(_) => DimensionKind::Activities,
+            Self::Photos(_) => DimensionKind::Photos,
+            Self::VoiceMemos(_) => DimensionKind::VoiceMemos,
+            Self::Location(_) => DimensionKind::Location,
+            Self::Song(_) => DimensionKind::Song,
+            Self::Weather(_) => DimensionKind::Weather,
+        }
+    }
+}
diff --git a/crates/domain/src/dimension/lookup.rs b/crates/domain/src/dimension/lookup.rs
new file mode 100644
index 0000000..53eebe4
--- /dev/null
+++ b/crates/domain/src/dimension/lookup.rs
@@ -0,0 +1,61 @@
+use crate::activity::ActivityId;
+use crate::attachment::{PhotoId, VoiceMemoId};
+use crate::entry::Content;
+use crate::location::Coordinates;
+use crate::song::Song;
+use crate::weather::Weather;
+
+use super::{DimensionKind, DimensionValue};
+
+pub fn content_in(values: &[DimensionValue]) -> Option<&Content> {
+    match find(values, DimensionKind::Content) {
+        Some(DimensionValue::Content(content)) => Some(content),
+        _ => None,
+    }
+}
+
+pub fn activities_in(values: &[DimensionValue]) -> &[ActivityId] {
+    match find(values, DimensionKind::Activities) {
+        Some(DimensionValue::Activities(ids)) => ids,
+        _ => &[],
+    }
+}
+
+pub fn photos_in(values: &[DimensionValue]) -> &[PhotoId] {
+    match find(values, DimensionKind::Photos) {
+        Some(DimensionValue::Photos(ids)) => ids,
+        _ => &[],
+    }
+}
+
+pub fn voice_memos_in(values: &[DimensionValue]) -> &[VoiceMemoId] {
+    match find(values, DimensionKind::VoiceMemos) {
+        Some(DimensionValue::VoiceMemos(ids)) => ids,
+        _ => &[],
+    }
+}
+
+pub fn location_in(values: &[DimensionValue]) -> Option<&Coordinates> {
+    match find(values, DimensionKind::Location) {
+        Some(DimensionValue::Location(coordinates)) => Some(coordinates),
+        _ => None,
+    }
+}
+
+pub fn song_in(values: &[DimensionValue]) -> Option<&Song> {
+    match find(values, DimensionKind::Song) {
+        Some(DimensionValue::Song(song)) => Some(song),
+        _ => None,
+    }
+}
+
+pub fn weather_in(values: &[DimensionValue]) -> Option<&Weather> {
+    match find(values, DimensionKind::Weather) {
+        Some(DimensionValue::Weather(weather)) => Some(weather),
+        _ => None,
+    }
+}
+
+fn find(values: &[DimensionValue], kind: DimensionKind) -> Option<&DimensionValue> {
+    values.iter().find(|value| value.kind() == kind)
+}
diff --git a/crates/domain/src/dimension/mod.rs b/crates/domain/src/dimension/mod.rs
new file mode 100644
index 0000000..3568414
--- /dev/null
+++ b/crates/domain/src/dimension/mod.rs
@@ -0,0 +1,8 @@
+mod composed_entry;
+mod dimension_kind;
+mod dimension_value;
+pub mod lookup;
+
+pub use composed_entry::ComposedEntry;
+pub use dimension_kind::DimensionKind;
+pub use dimension_value::DimensionValue;
diff --git a/crates/domain/src/entry/date.rs b/crates/domain/src/entry/date.rs
new file mode 100644
index 0000000..8df4ed2
--- /dev/null
+++ b/crates/domain/src/entry/date.rs
@@ -0,0 +1,40 @@
+use chrono::{DateTime, FixedOffset, NaiveDate};
+
+use crate::user::Timezone;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Date(NaiveDate);
+
+impl Date {
+    pub fn from_instant(instant: &DateTime<FixedOffset>, timezone: &Timezone) -> Self {
+        Self(instant.with_timezone(&timezone.resolve()).date_naive())
+    }
+
+    pub fn from_persistence(date: NaiveDate) -> Self {
+        Self(date)
+    }
+}
+
+impl Date {
+    pub fn value(&self) -> NaiveDate {
+        self.0
+    }
+
+    pub fn previous(&self) -> Self {
+        Self(self.0.pred_opt().unwrap_or(self.0))
+    }
+
+    pub fn next(&self) -> Self {
+        Self(self.0.succ_opt().unwrap_or(self.0))
+    }
+
+    pub fn days_since(&self, other: &Date) -> i64 {
+        (self.0 - other.0).num_days()
+    }
+}
+
+impl std::fmt::Display for Date {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
diff --git a/crates/domain/src/entry/date_span.rs b/crates/domain/src/entry/date_span.rs
new file mode 100644
index 0000000..157af72
--- /dev/null
+++ b/crates/domain/src/entry/date_span.rs
@@ -0,0 +1,35 @@
+use crate::errors::DomainError;
+
+use super::Date;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct DateSpan {
+    start: Date,
+    end: Date,
+}
+
+impl DateSpan {
+    pub fn new(start: Date, end: Date) -> Result<Self, DomainError> {
+        if start > end {
+            return Err(DomainError::InvalidInput(
+                "date span start must be on or before its end".into(),
+            ));
+        }
+
+        Ok(Self { start, end })
+    }
+}
+
+impl DateSpan {
+    pub fn start(&self) -> &Date {
+        &self.start
+    }
+
+    pub fn end(&self) -> &Date {
+        &self.end
+    }
+
+    pub fn contains(&self, date: &Date) -> bool {
+        self.start <= *date && *date <= self.end
+    }
+}
diff --git a/crates/domain/src/entry/day_mood.rs b/crates/domain/src/entry/day_mood.rs
new file mode 100644
index 0000000..1905bad
--- /dev/null
+++ b/crates/domain/src/entry/day_mood.rs
@@ -0,0 +1,26 @@
+use super::Mood;
+
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct DayMood(f64);
+
+impl DayMood {
+    pub fn of(moods: &[Mood]) -> Option<Self> {
+        if moods.is_empty() {
+            return None;
+        }
+
+        let sum: u32 = moods.iter().map(|mood| u32::from(mood.value())).sum();
+
+        Some(Self(f64::from(sum) / moods.len() as f64))
+    }
+}
+
+impl DayMood {
+    pub fn value(&self) -> f64 {
+        self.0
+    }
+
+    pub fn rounded(&self) -> Mood {
+        Mood::try_from(self.0.round() as u8).unwrap_or(Mood::Meh)
+    }
+}
diff --git a/crates/domain/src/entry/mod.rs b/crates/domain/src/entry/mod.rs
index aeac3c4..21ee0e8 100644
--- a/crates/domain/src/entry/mod.rs
+++ b/crates/domain/src/entry/mod.rs
@@ -1,11 +1,17 @@
 mod content;
+mod date;
 mod date_range;
+mod date_span;
+mod day_mood;
 mod mood;
 mod mood_entry;
 mod mood_entry_id;
 
 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 mood::Mood;
 pub use mood_entry::{MoodEntry, MoodEntryData};
 pub use mood_entry_id::MoodEntryId;
diff --git a/crates/domain/src/entry/mood_entry.rs b/crates/domain/src/entry/mood_entry.rs
index 63dfa43..a87ded5 100644
--- a/crates/domain/src/entry/mood_entry.rs
+++ b/crates/domain/src/entry/mood_entry.rs
@@ -1,20 +1,14 @@
 use chrono::{DateTime, FixedOffset, Utc};
 
-use crate::activity::ActivityId;
-use crate::attachment::{PhotoId, VoiceMemoId};
 use crate::user::UserId;
 
-use super::{Content, Mood, MoodEntryId};
+use super::{Mood, MoodEntryId};
 
 pub struct MoodEntryData {
     pub id: MoodEntryId,
     pub user_id: UserId,
     pub mood: Mood,
     pub logged_at: DateTime<FixedOffset>,
-    pub activities: Vec<ActivityId>,
-    pub content: Option<Content>,
-    pub photos: Vec<PhotoId>,
-    pub voice_memos: Vec<VoiceMemoId>,
     pub created_at: DateTime<Utc>,
     pub updated_at: DateTime<Utc>,
 }
@@ -25,10 +19,6 @@ pub struct MoodEntry {
     user_id: UserId,
     mood: Mood,
     logged_at: DateTime<FixedOffset>,
-    activities: Vec<ActivityId>,
-    content: Option<Content>,
-    photos: Vec<PhotoId>,
-    voice_memos: Vec<VoiceMemoId>,
     created_at: DateTime<Utc>,
     updated_at: DateTime<Utc>,
 }
@@ -41,10 +31,6 @@ impl MoodEntry {
             user_id,
             mood,
             logged_at,
-            activities: Vec::new(),
-            content: None,
-            photos: Vec::new(),
-            voice_memos: Vec::new(),
             created_at: now,
             updated_at: now,
         }
@@ -56,10 +42,6 @@ impl MoodEntry {
             user_id: data.user_id,
             mood: data.mood,
             logged_at: data.logged_at,
-            activities: data.activities,
-            content: data.content,
-            photos: data.photos,
-            voice_memos: data.voice_memos,
             created_at: data.created_at,
             updated_at: data.updated_at,
         }
@@ -83,22 +65,6 @@ impl MoodEntry {
         &self.logged_at
     }
 
-    pub fn activities(&self) -> &[ActivityId] {
-        &self.activities
-    }
-
-    pub fn content(&self) -> Option<&Content> {
-        self.content.as_ref()
-    }
-
-    pub fn photos(&self) -> &[PhotoId] {
-        &self.photos
-    }
-
-    pub fn voice_memos(&self) -> &[VoiceMemoId] {
-        &self.voice_memos
-    }
-
     pub fn created_at(&self) -> &DateTime<Utc> {
         &self.created_at
     }
@@ -119,28 +85,6 @@ impl MoodEntry {
         self.touch();
     }
 
-    pub fn set_content(&mut self, content: Option<Content>) {
-        self.content = content;
-        self.touch();
-    }
-
-    pub fn set_activities(&mut self, mut activities: Vec<ActivityId>) {
-        activities.sort();
-        activities.dedup();
-        self.activities = activities;
-        self.touch();
-    }
-
-    pub fn set_photos(&mut self, photos: Vec<PhotoId>) {
-        self.photos = photos;
-        self.touch();
-    }
-
-    pub fn set_voice_memos(&mut self, voice_memos: Vec<VoiceMemoId>) {
-        self.voice_memos = voice_memos;
-        self.touch();
-    }
-
     fn touch(&mut self) {
         self.updated_at = Utc::now();
     }
diff --git a/crates/domain/src/job/job.rs b/crates/domain/src/job/job.rs
new file mode 100644
index 0000000..0dfef0b
--- /dev/null
+++ b/crates/domain/src/job/job.rs
@@ -0,0 +1,101 @@
+use chrono::{DateTime, Utc};
+
+use super::{JobId, JobKind, JobStatus, JobSubject};
+
+pub struct JobData {
+    pub id: JobId,
+    pub kind: JobKind,
+    pub subject: JobSubject,
+    pub status: JobStatus,
+    pub attempts: u32,
+    pub last_error: Option<String>,
+    pub enqueued_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Job {
+    id: JobId,
+    kind: JobKind,
+    subject: JobSubject,
+    status: JobStatus,
+    attempts: u32,
+    last_error: Option<String>,
+    enqueued_at: DateTime<Utc>,
+    updated_at: DateTime<Utc>,
+}
+
+impl Job {
+    pub fn pending(kind: JobKind, subject: JobSubject) -> Self {
+        let now = Utc::now();
+
+        Self {
+            id: JobId::generate(),
+            kind,
+            subject,
+            status: JobStatus::Pending,
+            attempts: 0,
+            last_error: None,
+            enqueued_at: now,
+            updated_at: now,
+        }
+    }
+
+    pub fn from_persistence(data: JobData) -> Self {
+        Self {
+            id: data.id,
+            kind: data.kind,
+            subject: data.subject,
+            status: data.status,
+            attempts: data.attempts,
+            last_error: data.last_error,
+            enqueued_at: data.enqueued_at,
+            updated_at: data.updated_at,
+        }
+    }
+}
+
+impl Job {
+    pub fn id(&self) -> &JobId {
+        &self.id
+    }
+
+    pub fn kind(&self) -> JobKind {
+        self.kind
+    }
+
+    pub fn subject(&self) -> &JobSubject {
+        &self.subject
+    }
+
+    pub fn status(&self) -> JobStatus {
+        self.status
+    }
+
+    pub fn attempts(&self) -> u32 {
+        self.attempts
+    }
+
+    pub fn last_error(&self) -> Option<&str> {
+        self.last_error.as_deref()
+    }
+
+    pub fn enqueued_at(&self) -> &DateTime<Utc> {
+        &self.enqueued_at
+    }
+
+    pub fn updated_at(&self) -> &DateTime<Utc> {
+        &self.updated_at
+    }
+
+    pub fn is_worth_another_attempt(&self, most_attempts: u32) -> bool {
+        self.attempts < most_attempts
+    }
+}
+
+impl Job {
+    pub fn attempted(&mut self) {
+        self.attempts += 1;
+        self.updated_at = Utc::now();
+    }
+}
diff --git a/crates/domain/src/job/job_id.rs b/crates/domain/src/job/job_id.rs
new file mode 100644
index 0000000..690d4e2
--- /dev/null
+++ b/crates/domain/src/job/job_id.rs
@@ -0,0 +1,3 @@
+use crate::macros::uuid_id;
+
+uuid_id!(JobId);
diff --git a/crates/domain/src/job/job_kind.rs b/crates/domain/src/job/job_kind.rs
new file mode 100644
index 0000000..a5257ad
--- /dev/null
+++ b/crates/domain/src/job/job_kind.rs
@@ -0,0 +1,27 @@
+const BACKFILL_RECORDING_IDENTITY: &str = "backfillRecordingIdentity";
+const OBSERVE_WEATHER: &str = "observeWeather";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum JobKind {
+    BackfillRecordingIdentity,
+    ObserveWeather,
+}
+
+impl JobKind {
+    pub const ALL: [JobKind; 2] = [Self::BackfillRecordingIdentity, Self::ObserveWeather];
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::BackfillRecordingIdentity => BACKFILL_RECORDING_IDENTITY,
+            Self::ObserveWeather => OBSERVE_WEATHER,
+        }
+    }
+
+    pub fn from_name(name: &str) -> Option<Self> {
+        match name {
+            BACKFILL_RECORDING_IDENTITY => Some(Self::BackfillRecordingIdentity),
+            OBSERVE_WEATHER => Some(Self::ObserveWeather),
+            _ => None,
+        }
+    }
+}
diff --git a/crates/domain/src/job/job_status.rs b/crates/domain/src/job/job_status.rs
new file mode 100644
index 0000000..32b23c5
--- /dev/null
+++ b/crates/domain/src/job/job_status.rs
@@ -0,0 +1,29 @@
+const PENDING: &str = "pending";
+const RUNNING: &str = "running";
+const EXHAUSTED: &str = "exhausted";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum JobStatus {
+    Pending,
+    Running,
+    Exhausted,
+}
+
+impl JobStatus {
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::Pending => PENDING,
+            Self::Running => RUNNING,
+            Self::Exhausted => EXHAUSTED,
+        }
+    }
+
+    pub fn from_name(name: &str) -> Option<Self> {
+        match name {
+            PENDING => Some(Self::Pending),
+            RUNNING => Some(Self::Running),
+            EXHAUSTED => Some(Self::Exhausted),
+            _ => None,
+        }
+    }
+}
diff --git a/crates/domain/src/job/job_subject.rs b/crates/domain/src/job/job_subject.rs
new file mode 100644
index 0000000..5d7539e
--- /dev/null
+++ b/crates/domain/src/job/job_subject.rs
@@ -0,0 +1,21 @@
+use crate::entry::MoodEntryId;
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum JobSubject {
+    Entry(MoodEntryId),
+}
+
+impl JobSubject {
+    pub fn key(&self) -> String {
+        match self {
+            Self::Entry(id) => id.value().to_string(),
+        }
+    }
+
+    pub fn from_key(key: &str) -> Option<Self> {
+        key.parse()
+            .ok()
+            .map(MoodEntryId::from_uuid)
+            .map(Self::Entry)
+    }
+}
diff --git a/crates/domain/src/job/mod.rs b/crates/domain/src/job/mod.rs
new file mode 100644
index 0000000..f1fd1d8
--- /dev/null
+++ b/crates/domain/src/job/mod.rs
@@ -0,0 +1,11 @@
+mod job;
+mod job_id;
+mod job_kind;
+mod job_status;
+mod job_subject;
+
+pub use job::{Job, JobData};
+pub use job_id::JobId;
+pub use job_kind::JobKind;
+pub use job_status::JobStatus;
+pub use job_subject::JobSubject;
diff --git a/crates/domain/src/lib.rs b/crates/domain/src/lib.rs
index 85882d7..41c0227 100644
--- a/crates/domain/src/lib.rs
+++ b/crates/domain/src/lib.rs
@@ -1,16 +1,28 @@
 #![allow(clippy::module_inception)]
 
 pub mod activity;
+pub mod api_token;
 pub mod attachment;
 pub mod auth;
+pub mod correlation;
+pub mod cycle;
+pub mod dimension;
 pub mod entry;
 pub mod errors;
 pub mod events;
+pub mod job;
+pub mod location;
+pub mod metric;
+pub mod moon;
 pub mod ports;
+pub mod provider;
 pub mod push;
+pub mod rejection;
 pub mod reminder;
 pub mod services;
+pub mod song;
 pub mod user;
+pub mod weather;
 
 mod macros;
 
diff --git a/crates/domain/src/location/coordinates.rs b/crates/domain/src/location/coordinates.rs
new file mode 100644
index 0000000..4d906fd
--- /dev/null
+++ b/crates/domain/src/location/coordinates.rs
@@ -0,0 +1,33 @@
+use crate::errors::DomainError;
+
+use super::{Latitude, Longitude};
+
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct Coordinates {
+    latitude: Latitude,
+    longitude: Longitude,
+}
+
+impl Coordinates {
+    pub fn new(latitude: f64, longitude: f64) -> Result<Self, DomainError> {
+        Ok(Self {
+            latitude: Latitude::new(latitude)?,
+            longitude: Longitude::new(longitude)?,
+        })
+    }
+
+    pub fn from_persistence(latitude: f64, longitude: f64) -> Self {
+        Self {
+            latitude: Latitude::from_persistence(latitude),
+            longitude: Longitude::from_persistence(longitude),
+        }
+    }
+
+    pub fn latitude(&self) -> Latitude {
+        self.latitude
+    }
+
+    pub fn longitude(&self) -> Longitude {
+        self.longitude
+    }
+}
diff --git a/crates/domain/src/location/latitude.rs b/crates/domain/src/location/latitude.rs
new file mode 100644
index 0000000..040d06c
--- /dev/null
+++ b/crates/domain/src/location/latitude.rs
@@ -0,0 +1,31 @@
+use crate::errors::DomainError;
+
+const MIN_LATITUDE: f64 = -90.0;
+const MAX_LATITUDE: f64 = 90.0;
+
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct Latitude(f64);
+
+impl Latitude {
+    pub fn new(degrees: f64) -> Result<Self, DomainError> {
+        if !degrees.is_finite() {
+            return Err(DomainError::InvalidInput(
+                "latitude must be a finite number".into(),
+            ));
+        }
+        if !(MIN_LATITUDE..=MAX_LATITUDE).contains(&degrees) {
+            return Err(DomainError::InvalidInput(format!(
+                "latitude must be between {MIN_LATITUDE} and {MAX_LATITUDE}, got {degrees}"
+            )));
+        }
+        Ok(Self(degrees))
+    }
+
+    pub fn from_persistence(degrees: f64) -> Self {
+        Self(degrees)
+    }
+
+    pub fn value(&self) -> f64 {
+        self.0
+    }
+}
diff --git a/crates/domain/src/location/longitude.rs b/crates/domain/src/location/longitude.rs
new file mode 100644
index 0000000..b8fb685
--- /dev/null
+++ b/crates/domain/src/location/longitude.rs
@@ -0,0 +1,31 @@
+use crate::errors::DomainError;
+
+const MIN_LONGITUDE: f64 = -180.0;
+const MAX_LONGITUDE: f64 = 180.0;
+
+#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct Longitude(f64);
+
+impl Longitude {
+    pub fn new(degrees: f64) -> Result<Self, DomainError> {
+        if !degrees.is_finite() {
+            return Err(DomainError::InvalidInput(
+                "longitude must be a finite number".into(),
+            ));
+        }
+        if !(MIN_LONGITUDE..=MAX_LONGITUDE).contains(&degrees) {
+            return Err(DomainError::InvalidInput(format!(
+                "longitude must be between {MIN_LONGITUDE} and {MAX_LONGITUDE}, got {degrees}"
+            )));
+        }
+        Ok(Self(degrees))
+    }
+
+    pub fn from_persistence(degrees: f64) -> Self {
+        Self(degrees)
+    }
+
+    pub fn value(&self) -> f64 {
+        self.0
+    }
+}
diff --git a/crates/domain/src/location/mod.rs b/crates/domain/src/location/mod.rs
new file mode 100644
index 0000000..4e4c393
--- /dev/null
+++ b/crates/domain/src/location/mod.rs
@@ -0,0 +1,7 @@
+mod coordinates;
+mod latitude;
+mod longitude;
+
+pub use coordinates::Coordinates;
+pub use latitude::Latitude;
+pub use longitude::Longitude;
diff --git a/crates/domain/src/macros.rs b/crates/domain/src/macros.rs
index c38e840..ee7028d 100644
--- a/crates/domain/src/macros.rs
+++ b/crates/domain/src/macros.rs
@@ -41,3 +41,33 @@ macro_rules! uuid_id {
 }
 
 pub(crate) use uuid_id;
+
+macro_rules! bounded_metric {
+    ($name:ident, $inner:ty, $min:expr, $max:expr, $label:literal) => {
+        #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        pub struct $name($inner);
+
+        impl $name {
+            pub fn new(value: $inner) -> Result<Self, crate::errors::DomainError> {
+                if !($min..=$max).contains(&value) {
+                    return Err(crate::errors::DomainError::InvalidInput(format!(
+                        concat!($label, " must be between {} and {}, got {}"),
+                        $min, $max, value
+                    )));
+                }
+
+                Ok(Self(value))
+            }
+
+            pub fn from_persistence(value: $inner) -> Self {
+                Self(value)
+            }
+
+            pub fn value(&self) -> $inner {
+                self.0
+            }
+        }
+    };
+}
+
+pub(crate) use bounded_metric;
diff --git a/crates/domain/src/metric/alcoholic_drinks.rs b/crates/domain/src/metric/alcoholic_drinks.rs
new file mode 100644
index 0000000..bfa2afb
--- /dev/null
+++ b/crates/domain/src/metric/alcoholic_drinks.rs
@@ -0,0 +1,12 @@
+use crate::macros::bounded_metric;
+
+const MIN_ALCOHOLIC_DRINKS: u16 = 0;
+const MAX_ALCOHOLIC_DRINKS: u16 = 60;
+
+bounded_metric!(
+    AlcoholicDrinks,
+    u16,
+    MIN_ALCOHOLIC_DRINKS,
+    MAX_ALCOHOLIC_DRINKS,
+    "alcoholic drinks"
+);
diff --git a/crates/domain/src/metric/awake_minutes.rs b/crates/domain/src/metric/awake_minutes.rs
new file mode 100644
index 0000000..f2cce1f
--- /dev/null
+++ b/crates/domain/src/metric/awake_minutes.rs
@@ -0,0 +1,12 @@
+use crate::macros::bounded_metric;
+
+const MIN_AWAKE_MINUTES: u16 = 0;
+const MAX_AWAKE_MINUTES: u16 = 1_440;
+
+bounded_metric!(
+    AwakeMinutes,
+    u16,
+    MIN_AWAKE_MINUTES,
+    MAX_AWAKE_MINUTES,
+    "awake minutes"
+);
diff --git a/crates/domain/src/metric/daily_metric.rs b/crates/domain/src/metric/daily_metric.rs
new file mode 100644
index 0000000..5a1a9ee
--- /dev/null
+++ b/crates/domain/src/metric/daily_metric.rs
@@ -0,0 +1,49 @@
+use crate::entry::Date;
+use crate::user::UserId;
+
+use super::{MetricKind, MetricValue, Source};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DailyMetric {
+    user_id: UserId,
+    date: Date,
+    value: MetricValue,
+    source: Source,
+}
+
+impl DailyMetric {
+    pub fn new(user_id: UserId, date: Date, value: MetricValue, source: Source) -> Self {
+        Self {
+            user_id,
+            date,
+            value,
+            source,
+        }
+    }
+}
+
+impl DailyMetric {
+    pub fn user_id(&self) -> &UserId {
+        &self.user_id
+    }
+
+    pub fn date(&self) -> &Date {
+        &self.date
+    }
+
+    pub fn value(&self) -> &MetricValue {
+        &self.value
+    }
+
+    pub fn source(&self) -> &Source {
+        &self.source
+    }
+
+    pub fn kind(&self) -> MetricKind {
+        self.value.kind()
+    }
+
+    pub fn supersedes(&self, stored: &DailyMetric) -> bool {
+        stored.source.is_superseded_by(&self.source)
+    }
+}
diff --git a/crates/domain/src/metric/exercise_minutes.rs b/crates/domain/src/metric/exercise_minutes.rs
new file mode 100644
index 0000000..7ef2285
--- /dev/null
+++ b/crates/domain/src/metric/exercise_minutes.rs
@@ -0,0 +1,12 @@
+use crate::macros::bounded_metric;
+
+const MIN_EXERCISE_MINUTES: u16 = 0;
+const MAX_EXERCISE_MINUTES: u16 = 1_440;
+
+bounded_metric!(
+    ExerciseMinutes,
+    u16,
+    MIN_EXERCISE_MINUTES,
+    MAX_EXERCISE_MINUTES,
+    "exercise minutes"
+);
diff --git a/crates/domain/src/metric/hrv.rs b/crates/domain/src/metric/hrv.rs
new file mode 100644
index 0000000..f121e48
--- /dev/null
+++ b/crates/domain/src/metric/hrv.rs
@@ -0,0 +1,6 @@
+use crate::macros::bounded_metric;
+
+const MIN_HRV: u16 = 1;
+const MAX_HRV: u16 = 300;
+
+bounded_metric!(Hrv, u16, MIN_HRV, MAX_HRV, "heart rate variability");
diff --git a/crates/domain/src/metric/metric_kind.rs b/crates/domain/src/metric/metric_kind.rs
new file mode 100644
index 0000000..2dec488
--- /dev/null
+++ b/crates/domain/src/metric/metric_kind.rs
@@ -0,0 +1,60 @@
+const STEPS: &str = "steps";
+const SLEEP_MINUTES: &str = "sleepMinutes";
+const AWAKE_MINUTES: &str = "awakeMinutes";
+const RESTING_HEART_RATE: &str = "restingHeartRate";
+const HRV: &str = "hrv";
+const EXERCISE_MINUTES: &str = "exerciseMinutes";
+const SCREEN_TIME_MINUTES: &str = "screenTimeMinutes";
+const ALCOHOLIC_DRINKS: &str = "alcoholicDrinks";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum MetricKind {
+    Steps,
+    SleepMinutes,
+    AwakeMinutes,
+    RestingHeartRate,
+    Hrv,
+    ExerciseMinutes,
+    ScreenTimeMinutes,
+    AlcoholicDrinks,
+}
+
+impl MetricKind {
+    pub const ALL: [MetricKind; 8] = [
+        Self::Steps,
+        Self::SleepMinutes,
+        Self::AwakeMinutes,
+        Self::RestingHeartRate,
+        Self::Hrv,
+        Self::ExerciseMinutes,
+        Self::ScreenTimeMinutes,
+        Self::AlcoholicDrinks,
+    ];
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::Steps => STEPS,
+            Self::SleepMinutes => SLEEP_MINUTES,
+            Self::AwakeMinutes => AWAKE_MINUTES,
+            Self::RestingHeartRate => RESTING_HEART_RATE,
+            Self::Hrv => HRV,
+            Self::ExerciseMinutes => EXERCISE_MINUTES,
+            Self::ScreenTimeMinutes => SCREEN_TIME_MINUTES,
+            Self::AlcoholicDrinks => ALCOHOLIC_DRINKS,
+        }
+    }
+
+    pub fn from_name(name: &str) -> Option<Self> {
+        match name {
+            STEPS => Some(Self::Steps),
+            SLEEP_MINUTES => Some(Self::SleepMinutes),
+            AWAKE_MINUTES => Some(Self::AwakeMinutes),
+            RESTING_HEART_RATE => Some(Self::RestingHeartRate),
+            HRV => Some(Self::Hrv),
+            EXERCISE_MINUTES => Some(Self::ExerciseMinutes),
+            SCREEN_TIME_MINUTES => Some(Self::ScreenTimeMinutes),
+            ALCOHOLIC_DRINKS => Some(Self::AlcoholicDrinks),
+            _ => None,
+        }
+    }
+}
diff --git a/crates/domain/src/metric/metric_value.rs b/crates/domain/src/metric/metric_value.rs
new file mode 100644
index 0000000..eda0a8a
--- /dev/null
+++ b/crates/domain/src/metric/metric_value.rs
@@ -0,0 +1,79 @@
+use crate::errors::DomainError;
+
+use super::{
+    AlcoholicDrinks, AwakeMinutes, ExerciseMinutes, Hrv, MetricKind, RestingHeartRate,
+    ScreenTimeMinutes, SleepMinutes, Steps,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MetricValue {
+    Steps(Steps),
+    SleepMinutes(SleepMinutes),
+    AwakeMinutes(AwakeMinutes),
+    RestingHeartRate(RestingHeartRate),
+    Hrv(Hrv),
+    ExerciseMinutes(ExerciseMinutes),
+    ScreenTimeMinutes(ScreenTimeMinutes),
+    AlcoholicDrinks(AlcoholicDrinks),
+}
+
+impl MetricValue {
+    pub fn of_kind(kind: MetricKind, count: i64) -> Result<Self, DomainError> {
+        match kind {
+            MetricKind::Steps => Ok(Self::Steps(Steps::new(narrow(count, kind)?)?)),
+            MetricKind::SleepMinutes => {
+                Ok(Self::SleepMinutes(SleepMinutes::new(narrow(count, kind)?)?))
+            }
+            MetricKind::AwakeMinutes => {
+                Ok(Self::AwakeMinutes(AwakeMinutes::new(narrow(count, kind)?)?))
+            }
+            MetricKind::RestingHeartRate => Ok(Self::RestingHeartRate(RestingHeartRate::new(
+                narrow(count, kind)?,
+            )?)),
+            MetricKind::Hrv => Ok(Self::Hrv(Hrv::new(narrow(count, kind)?)?)),
+            MetricKind::ExerciseMinutes => Ok(Self::ExerciseMinutes(ExerciseMinutes::new(
+                narrow(count, kind)?,
+            )?)),
+            MetricKind::ScreenTimeMinutes => Ok(Self::ScreenTimeMinutes(ScreenTimeMinutes::new(
+                narrow(count, kind)?,
+            )?)),
+            MetricKind::AlcoholicDrinks => Ok(Self::AlcoholicDrinks(AlcoholicDrinks::new(
+                narrow(count, kind)?,
+            )?)),
+        }
+    }
+}
+
+impl MetricValue {
+    pub fn kind(&self) -> MetricKind {
+        match self {
+            Self::Steps(_) => MetricKind::Steps,
+            Self::SleepMinutes(_) => MetricKind::SleepMinutes,
+            Self::AwakeMinutes(_) => MetricKind::AwakeMinutes,
+            Self::RestingHeartRate(_) => MetricKind::RestingHeartRate,
+            Self::Hrv(_) => MetricKind::Hrv,
+            Self::ExerciseMinutes(_) => MetricKind::ExerciseMinutes,
+            Self::ScreenTimeMinutes(_) => MetricKind::ScreenTimeMinutes,
+            Self::AlcoholicDrinks(_) => MetricKind::AlcoholicDrinks,
+        }
+    }
+
+    pub fn count(&self) -> i64 {
+        match self {
+            Self::Steps(steps) => i64::from(steps.value()),
+            Self::SleepMinutes(minutes) => i64::from(minutes.value()),
+            Self::AwakeMinutes(minutes) => i64::from(minutes.value()),
+            Self::RestingHeartRate(beats) => i64::from(beats.value()),
+            Self::Hrv(milliseconds) => i64::from(milliseconds.value()),
+            Self::ExerciseMinutes(minutes) => i64::from(minutes.value()),
+            Self::ScreenTimeMinutes(minutes) => i64::from(minutes.value()),
+            Self::AlcoholicDrinks(drinks) => i64::from(drinks.value()),
+        }
+    }
+}
+
+fn narrow<T: TryFrom<i64>>(count: i64, kind: MetricKind) -> Result<T, DomainError> {
+    T::try_from(count).map_err(|_| {
+        DomainError::InvalidInput(format!("{} cannot hold the value {count}", kind.name()))
+    })
+}
diff --git a/crates/domain/src/metric/mod.rs b/crates/domain/src/metric/mod.rs
new file mode 100644
index 0000000..cf3b47f
--- /dev/null
+++ b/crates/domain/src/metric/mod.rs
@@ -0,0 +1,25 @@
+mod alcoholic_drinks;
+mod awake_minutes;
+mod daily_metric;
+mod exercise_minutes;
+mod hrv;
+mod metric_kind;
+mod metric_value;
+mod resting_heart_rate;
+mod screen_time_minutes;
+mod sleep_minutes;
+mod source;
+mod steps;
+
+pub use alcoholic_drinks::AlcoholicDrinks;
+pub use awake_minutes::AwakeMinutes;
+pub use daily_metric::DailyMetric;
+pub use exercise_minutes::ExerciseMinutes;
+pub use hrv::Hrv;
+pub use metric_kind::MetricKind;
+pub use metric_value::MetricValue;
+pub use resting_heart_rate::RestingHeartRate;
+pub use screen_time_minutes::ScreenTimeMinutes;
+pub use sleep_minutes::SleepMinutes;
+pub use source::Source;
+pub use steps::Steps;
diff --git a/crates/domain/src/metric/resting_heart_rate.rs b/crates/domain/src/metric/resting_heart_rate.rs
new file mode 100644
index 0000000..ae43585
--- /dev/null
+++ b/crates/domain/src/metric/resting_heart_rate.rs
@@ -0,0 +1,12 @@
+use crate::macros::bounded_metric;
+
+const MIN_RESTING_HEART_RATE: u16 = 25;
+const MAX_RESTING_HEART_RATE: u16 = 120;
+
+bounded_metric!(
+    RestingHeartRate,
+    u16,
+    MIN_RESTING_HEART_RATE,
+    MAX_RESTING_HEART_RATE,
+    "resting heart rate"
+);
diff --git a/crates/domain/src/metric/screen_time_minutes.rs b/crates/domain/src/metric/screen_time_minutes.rs
new file mode 100644
index 0000000..9508a0a
--- /dev/null
+++ b/crates/domain/src/metric/screen_time_minutes.rs
@@ -0,0 +1,12 @@
+use crate::macros::bounded_metric;
+
+const MIN_SCREEN_TIME_MINUTES: u16 = 0;
+const MAX_SCREEN_TIME_MINUTES: u16 = 1_440;
+
+bounded_metric!(
+    ScreenTimeMinutes,
+    u16,
+    MIN_SCREEN_TIME_MINUTES,
+    MAX_SCREEN_TIME_MINUTES,
+    "screen time minutes"
+);
diff --git a/crates/domain/src/metric/sleep_minutes.rs b/crates/domain/src/metric/sleep_minutes.rs
new file mode 100644
index 0000000..18adad8
--- /dev/null
+++ b/crates/domain/src/metric/sleep_minutes.rs
@@ -0,0 +1,12 @@
+use crate::macros::bounded_metric;
+
+const MIN_SLEEP_MINUTES: u16 = 0;
+const MAX_SLEEP_MINUTES: u16 = 1_440;
+
+bounded_metric!(
+    SleepMinutes,
+    u16,
+    MIN_SLEEP_MINUTES,
+    MAX_SLEEP_MINUTES,
+    "sleep minutes"
+);
diff --git a/crates/domain/src/metric/source.rs b/crates/domain/src/metric/source.rs
new file mode 100644
index 0000000..694439b
--- /dev/null
+++ b/crates/domain/src/metric/source.rs
@@ -0,0 +1,24 @@
+use crate::provider::ProviderName;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Source {
+    Manual,
+    Provider(ProviderName),
+}
+
+impl Source {
+    pub fn is_manual(&self) -> bool {
+        matches!(self, Self::Manual)
+    }
+
+    pub fn is_superseded_by(&self, incoming: &Source) -> bool {
+        incoming.is_manual() || !self.is_manual()
+    }
+
+    pub fn provider(&self) -> Option<&ProviderName> {
+        match self {
+            Self::Manual => None,
+            Self::Provider(name) => Some(name),
+        }
+    }
+}
diff --git a/crates/domain/src/metric/steps.rs b/crates/domain/src/metric/steps.rs
new file mode 100644
index 0000000..468ab2e
--- /dev/null
+++ b/crates/domain/src/metric/steps.rs
@@ -0,0 +1,12 @@
+use crate::macros::bounded_metric;
+
+const MIN_STEPS_PER_DAY: u32 = 0;
+const MAX_STEPS_PER_DAY: u32 = 200_000;
+
+bounded_metric!(
+    Steps,
+    u32,
+    MIN_STEPS_PER_DAY,
+    MAX_STEPS_PER_DAY,
+    "step count"
+);
diff --git a/crates/domain/src/moon/mod.rs b/crates/domain/src/moon/mod.rs
new file mode 100644
index 0000000..ea0fbee
--- /dev/null
+++ b/crates/domain/src/moon/mod.rs
@@ -0,0 +1,3 @@
+mod moon_phase;
+
+pub use moon_phase::MoonPhase;
diff --git a/crates/domain/src/moon/moon_phase.rs b/crates/domain/src/moon/moon_phase.rs
new file mode 100644
index 0000000..267527b
--- /dev/null
+++ b/crates/domain/src/moon/moon_phase.rs
@@ -0,0 +1,46 @@
+use chrono::NaiveDate;
+
+use crate::entry::Date;
+
+const SYNODIC_MONTH_IN_DAYS: f64 = 29.530_588_853;
+const NAMED_PHASES: [&str; 8] = [
+    "New",
+    "Waxing Crescent",
+    "First Quarter",
+    "Waxing Gibbous",
+    "Full",
+    "Waning Gibbous",
+    "Last Quarter",
+    "Waning Crescent",
+];
+
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct MoonPhase(f64);
+
+impl MoonPhase {
+    pub fn on(date: &Date) -> Self {
+        let days = (date.value() - known_new_moon()).num_days() as f64;
+        let through_the_cycle = days.rem_euclid(SYNODIC_MONTH_IN_DAYS) / SYNODIC_MONTH_IN_DAYS;
+
+        Self(through_the_cycle)
+    }
+}
+
+impl MoonPhase {
+    pub fn illumination(&self) -> f64 {
+        let lit = (1.0 - (std::f64::consts::TAU * self.0).cos()) / 2.0;
+
+        lit.clamp(0.0, 1.0)
+    }
+
+    pub fn name(&self) -> &'static str {
+        let segments = NAMED_PHASES.len() as f64;
+        let segment = (self.0 * segments).round() as usize % NAMED_PHASES.len();
+
+        NAMED_PHASES[segment]
+    }
+}
+
+fn known_new_moon() -> NaiveDate {
+    NaiveDate::from_ymd_opt(2000, 1, 6).unwrap_or_default()
+}
diff --git a/crates/domain/src/ports/api_token.rs b/crates/domain/src/ports/api_token.rs
new file mode 100644
index 0000000..61405b5
--- /dev/null
+++ b/crates/domain/src/ports/api_token.rs
@@ -0,0 +1,21 @@
+use crate::api_token::{ApiToken, ApiTokenId, TokenDigest};
+use crate::errors::DomainError;
+use crate::user::UserId;
+
+pub trait ApiTokenSecretPort: Send + Sync {
+    fn mint(&self) -> String;
+    fn digest(&self, secret: &str) -> TokenDigest;
+}
+
+#[async_trait::async_trait]
+pub trait ApiTokenCommandPort: Send + Sync {
+    async fn save(&self, token: &ApiToken) -> Result<(), DomainError>;
+    async fn revoke(&self, user_id: &UserId, id: &ApiTokenId) -> Result<(), DomainError>;
+    async fn mark_used(&self, id: &ApiTokenId) -> Result<(), DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait ApiTokenQueryPort: Send + Sync {
+    async fn find_by_digest(&self, digest: &TokenDigest) -> Result<Option<ApiToken>, DomainError>;
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<ApiToken>, DomainError>;
+}
diff --git a/crates/domain/src/ports/cycle.rs b/crates/domain/src/ports/cycle.rs
new file mode 100644
index 0000000..2d560aa
--- /dev/null
+++ b/crates/domain/src/ports/cycle.rs
@@ -0,0 +1,24 @@
+use crate::entry::Date;
+use crate::errors::DomainError;
+use crate::user::{UserId, UserPreferences};
+
+#[async_trait::async_trait]
+pub trait CycleStartCommandPort: Send + Sync {
+    async fn record(&self, user_id: &UserId, date: &Date) -> Result<(), DomainError>;
+    async fn forget(&self, user_id: &UserId, date: &Date) -> Result<(), DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait CycleStartQueryPort: Send + Sync {
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<Date>, DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait UserPreferencesCommandPort: Send + Sync {
+    async fn save(&self, preferences: &UserPreferences) -> Result<(), DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait UserPreferencesQueryPort: Send + Sync {
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Option<UserPreferences>, DomainError>;
+}
diff --git a/crates/domain/src/ports/dimension.rs b/crates/domain/src/ports/dimension.rs
new file mode 100644
index 0000000..5fa2820
--- /dev/null
+++ b/crates/domain/src/ports/dimension.rs
@@ -0,0 +1,19 @@
+use std::collections::HashMap;
+
+use crate::dimension::DimensionValue;
+use crate::entry::MoodEntryId;
+use crate::errors::DomainError;
+
+#[async_trait::async_trait]
+pub trait EntryDimensionPort: Send + Sync {
+    async fn load(
+        &self,
+        entry_ids: &[MoodEntryId],
+    ) -> Result<HashMap<MoodEntryId, DimensionValue>, DomainError>;
+
+    async fn save(
+        &self,
+        entry_id: &MoodEntryId,
+        values: &[DimensionValue],
+    ) -> Result<(), DomainError>;
+}
diff --git a/crates/domain/src/ports/import_export.rs b/crates/domain/src/ports/import_export.rs
index 83bc512..adec9c4 100644
--- a/crates/domain/src/ports/import_export.rs
+++ b/crates/domain/src/ports/import_export.rs
@@ -1,24 +1,44 @@
 use crate::activity::Activity;
-use crate::entry::MoodEntry;
+use crate::cycle::CycleStartRestore;
+use crate::dimension::ComposedEntry;
 use crate::errors::DomainError;
+use crate::metric::DailyMetric;
 use crate::reminder::Reminder;
+use crate::user::UserPreferences;
 
 pub struct MediaBlob {
     pub id: String,
     pub data: Vec<u8>,
 }
 
-pub struct UserExport {
-    pub entries: Vec<MoodEntry>,
-    pub activities: Vec<Activity>,
-    pub reminders: Vec<Reminder>,
+pub struct BackupMedia {
     pub photos: Vec<MediaBlob>,
     pub voice_memos: Vec<MediaBlob>,
 }
 
+pub struct UserBackup {
+    pub entries: Vec<ComposedEntry>,
+    pub metrics: Vec<DailyMetric>,
+    pub cycle_starts: Vec<CycleStartRestore>,
+    pub activities: Vec<Activity>,
+    pub reminders: Vec<Reminder>,
+    pub preferences: UserPreferences,
+    pub media: BackupMedia,
+}
+
+pub struct SharedExtract {
+    pub entries: Vec<ComposedEntry>,
+    pub activities: Vec<Activity>,
+}
+
 #[async_trait::async_trait]
-pub trait ExportPort: Send + Sync {
-    async fn export_user_data(&self, data: &UserExport) -> Result<Vec<u8>, DomainError>;
+pub trait BackupWriterPort: Send + Sync {
+    async fn write(&self, backup: &UserBackup) -> Result<Vec<u8>, DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait ExtractWriterPort: Send + Sync {
+    async fn write(&self, extract: &SharedExtract) -> Result<Vec<u8>, DomainError>;
 }
 
 #[async_trait::async_trait]
@@ -26,6 +46,7 @@ pub trait ImportSourcePort: Send + Sync {
     async fn read_entries(&self, data: &[u8]) -> Result<Vec<ImportedRow>, DomainError>;
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ImportedRow {
     pub mood: u8,
     pub date: String,
diff --git a/crates/domain/src/ports/job.rs b/crates/domain/src/ports/job.rs
new file mode 100644
index 0000000..ed7e1b9
--- /dev/null
+++ b/crates/domain/src/ports/job.rs
@@ -0,0 +1,81 @@
+use crate::errors::DomainError;
+use crate::job::{Job, JobId, JobKind, JobSubject};
+use crate::user::UserId;
+
+#[async_trait::async_trait]
+pub trait JobQueueCommandPort: Send + Sync {
+    async fn enqueue(&self, kind: JobKind, subject: &JobSubject) -> Result<bool, DomainError>;
+
+    async fn claim(&self, kind: JobKind, most: usize) -> Result<Vec<Job>, DomainError>;
+
+    async fn finish(&self, id: &JobId) -> Result<(), DomainError>;
+
+    async fn release(&self, id: &JobId, reason: &str) -> Result<(), DomainError>;
+
+    async fn exhaust(&self, id: &JobId, reason: &str) -> Result<(), DomainError>;
+
+    async fn reclaim_stalled(&self, stalled_after_seconds: i64) -> Result<u64, DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait JobQueueQueryPort: Send + Sync {
+    async fn find_exhausted(&self, most: usize) -> Result<Vec<Job>, DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait WeatherLookupPort: Send + Sync {
+    fn provider(&self) -> &crate::provider::ProviderName;
+
+    async fn observed_at(
+        &self,
+        coordinates: &crate::location::Coordinates,
+        instant: &chrono::DateTime<chrono::FixedOffset>,
+    ) -> Result<Option<crate::weather::Weather>, DomainError>;
+}
+
+pub struct UnwatchedPlace {
+    pub entry_id: crate::entry::MoodEntryId,
+    pub coordinates: crate::location::Coordinates,
+    pub logged_at: chrono::DateTime<chrono::FixedOffset>,
+}
+
+impl UnwatchedPlace {
+    pub fn subject(&self) -> JobSubject {
+        JobSubject::Entry(self.entry_id.clone())
+    }
+}
+
+#[async_trait::async_trait]
+pub trait WeatherBacklogQueryPort: Send + Sync {
+    async fn find_places_without_weather(
+        &self,
+        most: usize,
+    ) -> Result<Vec<UnwatchedPlace>, DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait RecordingBackfillQueryPort: Send + Sync {
+    async fn find_songs_without_a_recording(
+        &self,
+        most: usize,
+    ) -> Result<Vec<UnidentifiedSong>, DomainError>;
+
+    async fn record_identity(
+        &self,
+        entry_id: &crate::entry::MoodEntryId,
+        recording_id: &crate::song::RecordingId,
+    ) -> Result<(), DomainError>;
+}
+
+pub struct UnidentifiedSong {
+    pub entry_id: crate::entry::MoodEntryId,
+    pub user_id: UserId,
+    pub title: String,
+    pub artist: String,
+}
+
+impl UnidentifiedSong {
+    pub fn subject(&self) -> JobSubject {
+        JobSubject::Entry(self.entry_id.clone())
+    }
+}
diff --git a/crates/domain/src/ports/metric.rs b/crates/domain/src/ports/metric.rs
new file mode 100644
index 0000000..bc6f1e0
--- /dev/null
+++ b/crates/domain/src/ports/metric.rs
@@ -0,0 +1,25 @@
+use crate::entry::{Date, DateSpan};
+use crate::errors::DomainError;
+use crate::metric::{DailyMetric, MetricKind};
+use crate::user::UserId;
+
+#[async_trait::async_trait]
+pub trait DailyMetricCommandPort: Send + Sync {
+    async fn save(&self, metrics: &[DailyMetric]) -> Result<usize, DomainError>;
+
+    async fn delete(
+        &self,
+        user_id: &UserId,
+        date: &Date,
+        kinds: &[MetricKind],
+    ) -> Result<(), DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait DailyMetricQueryPort: Send + Sync {
+    async fn find_by_span(
+        &self,
+        user_id: &UserId,
+        span: &DateSpan,
+    ) -> Result<Vec<DailyMetric>, DomainError>;
+}
diff --git a/crates/domain/src/ports/mod.rs b/crates/domain/src/ports/mod.rs
index 16150cd..2fb903b 100644
--- a/crates/domain/src/ports/mod.rs
+++ b/crates/domain/src/ports/mod.rs
@@ -1,23 +1,53 @@
 mod activity;
+mod api_token;
 mod auth;
 mod cascade;
+mod cycle;
+mod dimension;
 mod entry;
 mod event;
 mod import_export;
+mod job;
 mod media;
+mod metric;
+mod music;
+mod provider;
 mod push;
+mod rejection;
 mod reminder;
+mod restore;
 mod user;
 
 pub use activity::{ActivityCommandPort, ActivityQueryPort};
+pub use api_token::{ApiTokenCommandPort, ApiTokenQueryPort, ApiTokenSecretPort};
 pub use auth::{
     AuthServicePort, PasswordHasherPort, RefreshSessionCommandPort, RefreshSessionQueryPort,
 };
 pub use cascade::CascadeDeletePort;
+pub use cycle::{
+    CycleStartCommandPort, CycleStartQueryPort, UserPreferencesCommandPort,
+    UserPreferencesQueryPort,
+};
+pub use dimension::EntryDimensionPort;
 pub use entry::{MoodEntryCommandPort, MoodEntryQueryPort};
 pub use event::EventPublisherPort;
-pub use import_export::{ExportPort, ImportSourcePort, ImportedRow, MediaBlob, UserExport};
+pub use import_export::{
+    BackupMedia, BackupWriterPort, ExtractWriterPort, ImportSourcePort, ImportedRow, MediaBlob,
+    SharedExtract, UserBackup,
+};
+pub use job::{
+    JobQueueCommandPort, JobQueueQueryPort, RecordingBackfillQueryPort, UnidentifiedSong,
+    UnwatchedPlace, WeatherBacklogQueryPort, WeatherLookupPort,
+};
 pub use media::{MediaFile, MediaStoragePort};
+pub use metric::{DailyMetricCommandPort, DailyMetricQueryPort};
+pub use music::{NowPlayingPort, RecordingLookupPort};
+pub use provider::{ProviderConnectionCommandPort, ProviderConnectionQueryPort};
 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,
+};
 pub use user::{UserCommandPort, UserQueryPort};
diff --git a/crates/domain/src/ports/music.rs b/crates/domain/src/ports/music.rs
new file mode 100644
index 0000000..92729ea
--- /dev/null
+++ b/crates/domain/src/ports/music.rs
@@ -0,0 +1,18 @@
+use crate::errors::DomainError;
+use crate::song::{RecordingId, Song};
+
+#[async_trait::async_trait]
+pub trait NowPlayingPort: Send + Sync {
+    fn provider(&self) -> &str;
+
+    async fn now_playing(&self, credential: &[u8]) -> Result<Option<Song>, DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait RecordingLookupPort: Send + Sync {
+    async fn find_recording(
+        &self,
+        title: &str,
+        artist: &str,
+    ) -> Result<Option<RecordingId>, DomainError>;
+}
diff --git a/crates/domain/src/ports/provider.rs b/crates/domain/src/ports/provider.rs
new file mode 100644
index 0000000..d45f3a3
--- /dev/null
+++ b/crates/domain/src/ports/provider.rs
@@ -0,0 +1,21 @@
+use crate::errors::DomainError;
+use crate::provider::{ProviderConnection, ProviderName};
+use crate::user::UserId;
+
+#[async_trait::async_trait]
+pub trait ProviderConnectionCommandPort: Send + Sync {
+    async fn save(&self, connection: &ProviderConnection) -> Result<(), DomainError>;
+
+    async fn delete(&self, user_id: &UserId, provider: &ProviderName) -> Result<(), DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait ProviderConnectionQueryPort: Send + Sync {
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<ProviderConnection>, DomainError>;
+
+    async fn find_by_user_and_provider(
+        &self,
+        user_id: &UserId,
+        provider: &ProviderName,
+    ) -> Result<Option<ProviderConnection>, DomainError>;
+}
diff --git a/crates/domain/src/ports/rejection.rs b/crates/domain/src/ports/rejection.rs
new file mode 100644
index 0000000..5f0a81e
--- /dev/null
+++ b/crates/domain/src/ports/rejection.rs
@@ -0,0 +1,16 @@
+use crate::errors::DomainError;
+use crate::rejection::RejectedMetric;
+use crate::user::UserId;
+
+#[async_trait::async_trait]
+pub trait RejectionCommandPort: Send + Sync {
+    async fn record(&self, rejections: &[RejectedMetric]) -> Result<(), DomainError>;
+}
+
+#[async_trait::async_trait]
+pub trait RejectionQueryPort: Send + Sync {
+    async fn find_recent_by_user(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<RejectedMetric>, DomainError>;
+}
diff --git a/crates/domain/src/ports/restore.rs b/crates/domain/src/ports/restore.rs
new file mode 100644
index 0000000..a0ce671
--- /dev/null
+++ b/crates/domain/src/ports/restore.rs
@@ -0,0 +1,42 @@
+use crate::errors::DomainError;
+
+pub struct RestorableEntry {
+    pub mood: u8,
+    pub logged_at: String,
+    pub dimensions: Vec<crate::dimension::DimensionValue>,
+}
+
+pub struct RestorableMetric {
+    pub date: String,
+    pub kind: String,
+    pub value: i64,
+    pub provider: Option<String>,
+}
+
+pub struct RestorableActivity {
+    pub id: String,
+    pub name: String,
+    pub category: Option<String>,
+    pub archived: bool,
+}
+
+pub struct RestorableReminder {
+    pub enabled: bool,
+    pub times: [Option<String>; 7],
+}
+
+pub struct RestorableContents {
+    pub entries: Vec<RestorableEntry>,
+    pub metrics: Vec<RestorableMetric>,
+    pub cycle_starts: Vec<String>,
+    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>)>,
+}
+
+#[async_trait::async_trait]
+pub trait BackupReaderPort: Send + Sync {
+    async fn read(&self, data: &[u8]) -> Result<RestorableContents, DomainError>;
+}
diff --git a/crates/domain/src/provider/encrypted_credential.rs b/crates/domain/src/provider/encrypted_credential.rs
new file mode 100644
index 0000000..2a235cd
--- /dev/null
+++ b/crates/domain/src/provider/encrypted_credential.rs
@@ -0,0 +1,26 @@
+use crate::errors::DomainError;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct EncryptedCredential(Vec<u8>);
+
+impl EncryptedCredential {
+    pub fn from_persistence(ciphertext: Vec<u8>) -> Self {
+        Self(ciphertext)
+    }
+
+    pub fn value(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl std::fmt::Debug for EncryptedCredential {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "EncryptedCredential(<redacted {} bytes>)", self.0.len())
+    }
+}
+
+#[async_trait::async_trait]
+pub trait CredentialCipher: Send + Sync {
+    fn encrypt(&self, plaintext: &[u8]) -> Result<EncryptedCredential, DomainError>;
+    fn decrypt(&self, credential: &EncryptedCredential) -> Result<Vec<u8>, DomainError>;
+}
diff --git a/crates/domain/src/provider/mod.rs b/crates/domain/src/provider/mod.rs
new file mode 100644
index 0000000..9b509f0
--- /dev/null
+++ b/crates/domain/src/provider/mod.rs
@@ -0,0 +1,9 @@
+mod encrypted_credential;
+mod provider_connection;
+mod provider_connection_id;
+mod provider_name;
+
+pub use encrypted_credential::{CredentialCipher, EncryptedCredential};
+pub use provider_connection::{ProviderConnection, ProviderConnectionData};
+pub use provider_connection_id::ProviderConnectionId;
+pub use provider_name::ProviderName;
diff --git a/crates/domain/src/provider/provider_connection.rs b/crates/domain/src/provider/provider_connection.rs
new file mode 100644
index 0000000..d5fb4cc
--- /dev/null
+++ b/crates/domain/src/provider/provider_connection.rs
@@ -0,0 +1,82 @@
+use chrono::{DateTime, Utc};
+
+use crate::user::UserId;
+
+use super::{EncryptedCredential, ProviderConnectionId, ProviderName};
+
+pub struct ProviderConnectionData {
+    pub id: ProviderConnectionId,
+    pub user_id: UserId,
+    pub provider: ProviderName,
+    pub credential: EncryptedCredential,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ProviderConnection {
+    id: ProviderConnectionId,
+    user_id: UserId,
+    provider: ProviderName,
+    credential: EncryptedCredential,
+    created_at: DateTime<Utc>,
+    updated_at: DateTime<Utc>,
+}
+
+impl ProviderConnection {
+    pub fn new(user_id: UserId, provider: ProviderName, credential: EncryptedCredential) -> Self {
+        let now = Utc::now();
+        Self {
+            id: ProviderConnectionId::generate(),
+            user_id,
+            provider,
+            credential,
+            created_at: now,
+            updated_at: now,
+        }
+    }
+
+    pub fn from_persistence(data: ProviderConnectionData) -> Self {
+        Self {
+            id: data.id,
+            user_id: data.user_id,
+            provider: data.provider,
+            credential: data.credential,
+            created_at: data.created_at,
+            updated_at: data.updated_at,
+        }
+    }
+}
+
+impl ProviderConnection {
+    pub fn id(&self) -> &ProviderConnectionId {
+        &self.id
+    }
+
+    pub fn user_id(&self) -> &UserId {
+        &self.user_id
+    }
+
+    pub fn provider(&self) -> &ProviderName {
+        &self.provider
+    }
+
+    pub fn credential(&self) -> &EncryptedCredential {
+        &self.credential
+    }
+
+    pub fn created_at(&self) -> &DateTime<Utc> {
+        &self.created_at
+    }
+
+    pub fn updated_at(&self) -> &DateTime<Utc> {
+        &self.updated_at
+    }
+}
+
+impl ProviderConnection {
+    pub fn replace_credential(&mut self, credential: EncryptedCredential) {
+        self.credential = credential;
+        self.updated_at = Utc::now();
+    }
+}
diff --git a/crates/domain/src/provider/provider_connection_id.rs b/crates/domain/src/provider/provider_connection_id.rs
new file mode 100644
index 0000000..c97f136
--- /dev/null
+++ b/crates/domain/src/provider/provider_connection_id.rs
@@ -0,0 +1 @@
+crate::macros::uuid_id!(ProviderConnectionId);
diff --git a/crates/domain/src/provider/provider_name.rs b/crates/domain/src/provider/provider_name.rs
new file mode 100644
index 0000000..f220b4a
--- /dev/null
+++ b/crates/domain/src/provider/provider_name.rs
@@ -0,0 +1,34 @@
+use crate::errors::DomainError;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+pub struct ProviderName(String);
+
+impl ProviderName {
+    pub fn new(name: impl Into<String>) -> Result<Self, DomainError> {
+        let normalised = name.into().trim().to_lowercase();
+
+        if normalised.is_empty() {
+            return Err(DomainError::InvalidInput(
+                "provider name cannot be empty".into(),
+            ));
+        }
+        if !normalised
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '-')
+        {
+            return Err(DomainError::InvalidInput(
+                "provider name must contain only letters, digits and hyphens".into(),
+            ));
+        }
+
+        Ok(Self(normalised))
+    }
+
+    pub fn from_persistence(name: String) -> Self {
+        Self(name)
+    }
+
+    pub fn value(&self) -> &str {
+        &self.0
+    }
+}
diff --git a/crates/domain/src/rejection/mod.rs b/crates/domain/src/rejection/mod.rs
new file mode 100644
index 0000000..d4f5b34
--- /dev/null
+++ b/crates/domain/src/rejection/mod.rs
@@ -0,0 +1,9 @@
+mod rejected_metric;
+mod rejection_detail;
+mod rejection_id;
+mod rejection_origin;
+
+pub use rejected_metric::{RejectedMetric, RejectedMetricData};
+pub use rejection_detail::RejectionDetail;
+pub use rejection_id::RejectionId;
+pub use rejection_origin::RejectionOrigin;
diff --git a/crates/domain/src/rejection/rejected_metric.rs b/crates/domain/src/rejection/rejected_metric.rs
new file mode 100644
index 0000000..ac4925b
--- /dev/null
+++ b/crates/domain/src/rejection/rejected_metric.rs
@@ -0,0 +1,79 @@
+use chrono::{DateTime, Utc};
+
+use crate::user::UserId;
+
+use super::{RejectionDetail, RejectionId, RejectionOrigin};
+
+pub struct RejectedMetricData {
+    pub id: RejectionId,
+    pub user_id: UserId,
+    pub origin: RejectionOrigin,
+    pub detail: RejectionDetail,
+    pub reason: String,
+    pub recorded_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone)]
+pub struct RejectedMetric {
+    id: RejectionId,
+    user_id: UserId,
+    origin: RejectionOrigin,
+    detail: RejectionDetail,
+    reason: String,
+    recorded_at: DateTime<Utc>,
+}
+
+impl RejectedMetric {
+    pub fn new(
+        user_id: UserId,
+        origin: RejectionOrigin,
+        detail: RejectionDetail,
+        reason: impl Into<String>,
+    ) -> Self {
+        Self {
+            id: RejectionId::generate(),
+            user_id,
+            origin,
+            detail,
+            reason: reason.into(),
+            recorded_at: Utc::now(),
+        }
+    }
+
+    pub fn from_persistence(data: RejectedMetricData) -> Self {
+        Self {
+            id: data.id,
+            user_id: data.user_id,
+            origin: data.origin,
+            detail: data.detail,
+            reason: data.reason,
+            recorded_at: data.recorded_at,
+        }
+    }
+}
+
+impl RejectedMetric {
+    pub fn id(&self) -> &RejectionId {
+        &self.id
+    }
+
+    pub fn user_id(&self) -> &UserId {
+        &self.user_id
+    }
+
+    pub fn origin(&self) -> RejectionOrigin {
+        self.origin
+    }
+
+    pub fn detail(&self) -> &RejectionDetail {
+        &self.detail
+    }
+
+    pub fn reason(&self) -> &str {
+        &self.reason
+    }
+
+    pub fn recorded_at(&self) -> &DateTime<Utc> {
+        &self.recorded_at
+    }
+}
diff --git a/crates/domain/src/rejection/rejection_detail.rs b/crates/domain/src/rejection/rejection_detail.rs
new file mode 100644
index 0000000..b4a62ef
--- /dev/null
+++ b/crates/domain/src/rejection/rejection_detail.rs
@@ -0,0 +1,44 @@
+use crate::entry::Date;
+use crate::provider::ProviderName;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RejectionDetail {
+    provider: Option<ProviderName>,
+    date: Option<Date>,
+    kind: String,
+    value: Option<i64>,
+}
+
+impl RejectionDetail {
+    pub fn new(
+        provider: Option<ProviderName>,
+        date: Option<Date>,
+        kind: impl Into<String>,
+        value: Option<i64>,
+    ) -> Self {
+        Self {
+            provider,
+            date,
+            kind: kind.into(),
+            value,
+        }
+    }
+}
+
+impl RejectionDetail {
+    pub fn provider(&self) -> Option<&ProviderName> {
+        self.provider.as_ref()
+    }
+
+    pub fn date(&self) -> Option<&Date> {
+        self.date.as_ref()
+    }
+
+    pub fn kind(&self) -> &str {
+        &self.kind
+    }
+
+    pub fn value(&self) -> Option<i64> {
+        self.value
+    }
+}
diff --git a/crates/domain/src/rejection/rejection_id.rs b/crates/domain/src/rejection/rejection_id.rs
new file mode 100644
index 0000000..5ade8e5
--- /dev/null
+++ b/crates/domain/src/rejection/rejection_id.rs
@@ -0,0 +1,3 @@
+use crate::macros::uuid_id;
+
+uuid_id!(RejectionId);
diff --git a/crates/domain/src/rejection/rejection_origin.rs b/crates/domain/src/rejection/rejection_origin.rs
new file mode 100644
index 0000000..e856bba
--- /dev/null
+++ b/crates/domain/src/rejection/rejection_origin.rs
@@ -0,0 +1,25 @@
+const IMPORT: &str = "import";
+const STORED_ROW: &str = "storedRow";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum RejectionOrigin {
+    Import,
+    StoredRow,
+}
+
+impl RejectionOrigin {
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::Import => IMPORT,
+            Self::StoredRow => STORED_ROW,
+        }
+    }
+
+    pub fn from_name(name: &str) -> Option<Self> {
+        match name {
+            IMPORT => Some(Self::Import),
+            STORED_ROW => Some(Self::StoredRow),
+            _ => None,
+        }
+    }
+}
diff --git a/crates/domain/src/services/mood_analyzer.rs b/crates/domain/src/services/mood_analyzer.rs
index 2f9414e..b5b2faf 100644
--- a/crates/domain/src/services/mood_analyzer.rs
+++ b/crates/domain/src/services/mood_analyzer.rs
@@ -1,7 +1,4 @@
-use chrono::Utc;
-
-use crate::activity::ActivityId;
-use crate::entry::{Mood, MoodEntry};
+use crate::entry::{Date, Mood, MoodEntry};
 
 pub struct MoodAnalyzerService;
 
@@ -32,64 +29,28 @@ impl MoodAnalyzerService {
             .collect()
     }
 
-    #[tracing::instrument(skip(entries), fields(entry_count = entries.len()))]
-    pub fn current_streak(entries: &[MoodEntry]) -> usize {
-        if entries.is_empty() {
-            return 0;
-        }
-
-        let mut dates: Vec<_> = entries.iter().map(|e| e.logged_at().date_naive()).collect();
+    #[tracing::instrument(skip(dates), fields(date_count = dates.len()))]
+    pub fn current_streak(dates: &[Date], today: Date) -> usize {
+        let mut dates = dates.to_vec();
         dates.sort();
         dates.dedup();
 
-        let today = Utc::now().date_naive();
+        let Some(most_recent) = dates.last() else {
+            return 0;
+        };
 
-        let last_date = *dates.last().unwrap();
-        let diff_to_today = (today - last_date).num_days();
-        if diff_to_today > 1 {
+        if today.days_since(most_recent) > 1 {
             return 0;
         }
 
         let mut streak = 1;
         for window in dates.windows(2).rev() {
-            let diff = window[1] - window[0];
-            if diff.num_days() == 1 {
-                streak += 1;
-            } else {
+            if window[1].days_since(&window[0]) != 1 {
                 break;
             }
+            streak += 1;
         }
 
         streak
     }
-
-    #[tracing::instrument(skip(entries), fields(entry_count = entries.len()))]
-    pub fn activity_mood_correlation(
-        entries: &[MoodEntry],
-        activity_id: &ActivityId,
-    ) -> Option<f64> {
-        let with: Vec<_> = entries
-            .iter()
-            .filter(|e| e.activities().contains(activity_id))
-            .collect();
-
-        let without: Vec<_> = entries
-            .iter()
-            .filter(|e| !e.activities().contains(activity_id))
-            .collect();
-
-        let avg_with = Self::average_mood_from_refs(&with)?;
-        let avg_without = Self::average_mood_from_refs(&without)?;
-
-        Some(avg_with - avg_without)
-    }
-
-    fn average_mood_from_refs(entries: &[&MoodEntry]) -> Option<f64> {
-        if entries.is_empty() {
-            return None;
-        }
-
-        let sum: u32 = entries.iter().map(|e| e.mood().value() as u32).sum();
-        Some(sum as f64 / entries.len() as f64)
-    }
 }
diff --git a/crates/domain/src/song/album_name.rs b/crates/domain/src/song/album_name.rs
new file mode 100644
index 0000000..90269be
--- /dev/null
+++ b/crates/domain/src/song/album_name.rs
@@ -0,0 +1,24 @@
+use crate::errors::DomainError;
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct AlbumName(String);
+
+impl AlbumName {
+    pub fn new(name: impl Into<String>) -> Result<Self, DomainError> {
+        let trimmed = name.into().trim().to_string();
+        if trimmed.is_empty() {
+            return Err(DomainError::InvalidInput(
+                "album name cannot be empty".into(),
+            ));
+        }
+        Ok(Self(trimmed))
+    }
+
+    pub fn from_persistence(name: String) -> Self {
+        Self(name)
+    }
+
+    pub fn value(&self) -> &str {
+        &self.0
+    }
+}
diff --git a/crates/domain/src/song/artist_name.rs b/crates/domain/src/song/artist_name.rs
new file mode 100644
index 0000000..5902d30
--- /dev/null
+++ b/crates/domain/src/song/artist_name.rs
@@ -0,0 +1,24 @@
+use crate::errors::DomainError;
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct ArtistName(String);
+
+impl ArtistName {
+    pub fn new(name: impl Into<String>) -> Result<Self, DomainError> {
+        let trimmed = name.into().trim().to_string();
+        if trimmed.is_empty() {
+            return Err(DomainError::InvalidInput(
+                "artist name cannot be empty".into(),
+            ));
+        }
+        Ok(Self(trimmed))
+    }
+
+    pub fn from_persistence(name: String) -> Self {
+        Self(name)
+    }
+
+    pub fn value(&self) -> &str {
+        &self.0
+    }
+}
diff --git a/crates/domain/src/song/mod.rs b/crates/domain/src/song/mod.rs
new file mode 100644
index 0000000..126b720
--- /dev/null
+++ b/crates/domain/src/song/mod.rs
@@ -0,0 +1,11 @@
+mod album_name;
+mod artist_name;
+mod recording_id;
+mod song;
+mod song_title;
+
+pub use album_name::AlbumName;
+pub use artist_name::ArtistName;
+pub use recording_id::RecordingId;
+pub use song::Song;
+pub use song_title::SongTitle;
diff --git a/crates/domain/src/song/recording_id.rs b/crates/domain/src/song/recording_id.rs
new file mode 100644
index 0000000..9a31c5c
--- /dev/null
+++ b/crates/domain/src/song/recording_id.rs
@@ -0,0 +1,21 @@
+use crate::errors::DomainError;
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct RecordingId(uuid::Uuid);
+
+impl RecordingId {
+    pub fn new(id: &str) -> Result<Self, DomainError> {
+        id.trim()
+            .parse::<uuid::Uuid>()
+            .map(Self)
+            .map_err(|_| DomainError::InvalidInput("recording id must be a UUID".into()))
+    }
+
+    pub fn from_uuid(id: uuid::Uuid) -> Self {
+        Self(id)
+    }
+
+    pub fn value(&self) -> uuid::Uuid {
+        self.0
+    }
+}
diff --git a/crates/domain/src/song/song.rs b/crates/domain/src/song/song.rs
new file mode 100644
index 0000000..05d7664
--- /dev/null
+++ b/crates/domain/src/song/song.rs
@@ -0,0 +1,59 @@
+use crate::errors::DomainError;
+
+use super::{AlbumName, ArtistName, RecordingId, SongTitle};
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct Song {
+    title: SongTitle,
+    artist: ArtistName,
+    album: Option<AlbumName>,
+    recording_id: Option<RecordingId>,
+}
+
+impl Song {
+    pub fn new(
+        title: impl Into<String>,
+        artist: impl Into<String>,
+        album: Option<String>,
+        recording_id: Option<RecordingId>,
+    ) -> Result<Self, DomainError> {
+        Ok(Self {
+            title: SongTitle::new(title)?,
+            artist: ArtistName::new(artist)?,
+            album: album.and_then(|name| AlbumName::new(name).ok()),
+            recording_id,
+        })
+    }
+
+    pub fn from_persistence(
+        title: SongTitle,
+        artist: ArtistName,
+        album: Option<AlbumName>,
+        recording_id: Option<RecordingId>,
+    ) -> Self {
+        Self {
+            title,
+            artist,
+            album,
+            recording_id,
+        }
+    }
+}
+
+impl Song {
+    pub fn title(&self) -> &SongTitle {
+        &self.title
+    }
+
+    pub fn artist(&self) -> &ArtistName {
+        &self.artist
+    }
+
+    pub fn album(&self) -> Option<&AlbumName> {
+        self.album.as_ref()
+    }
+
+    pub fn recording_id(&self) -> Option<&RecordingId> {
+        self.recording_id.as_ref()
+    }
+}
diff --git a/crates/domain/src/song/song_title.rs b/crates/domain/src/song/song_title.rs
new file mode 100644
index 0000000..7498296
--- /dev/null
+++ b/crates/domain/src/song/song_title.rs
@@ -0,0 +1,24 @@
+use crate::errors::DomainError;
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct SongTitle(String);
+
+impl SongTitle {
+    pub fn new(title: impl Into<String>) -> Result<Self, DomainError> {
+        let trimmed = title.into().trim().to_string();
+        if trimmed.is_empty() {
+            return Err(DomainError::InvalidInput(
+                "song title cannot be empty".into(),
+            ));
+        }
+        Ok(Self(trimmed))
+    }
+
+    pub fn from_persistence(title: String) -> Self {
+        Self(title)
+    }
+
+    pub fn value(&self) -> &str {
+        &self.0
+    }
+}
diff --git a/crates/domain/src/testing/fakes/api_token_secret.rs b/crates/domain/src/testing/fakes/api_token_secret.rs
new file mode 100644
index 0000000..3fdf33f
--- /dev/null
+++ b/crates/domain/src/testing/fakes/api_token_secret.rs
@@ -0,0 +1,33 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use crate::api_token::TokenDigest;
+
+pub struct FakeApiTokenSecret {
+    minted: AtomicUsize,
+}
+
+impl FakeApiTokenSecret {
+    pub fn new() -> Self {
+        Self {
+            minted: AtomicUsize::new(0),
+        }
+    }
+}
+
+impl Default for FakeApiTokenSecret {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl crate::ports::ApiTokenSecretPort for FakeApiTokenSecret {
+    fn mint(&self) -> String {
+        let number = self.minted.fetch_add(1, Ordering::SeqCst);
+
+        format!("kmood_secret_{number}")
+    }
+
+    fn digest(&self, secret: &str) -> TokenDigest {
+        TokenDigest::from_persistence(format!("digest-of-{secret}"))
+    }
+}
diff --git a/crates/domain/src/testing/fakes/cipher.rs b/crates/domain/src/testing/fakes/cipher.rs
new file mode 100644
index 0000000..fa7ed0c
--- /dev/null
+++ b/crates/domain/src/testing/fakes/cipher.rs
@@ -0,0 +1,18 @@
+use crate::errors::DomainError;
+use crate::provider::{CredentialCipher, EncryptedCredential};
+
+const MASK: u8 = 0x5a;
+
+pub struct FakeCredentialCipher;
+
+impl CredentialCipher for FakeCredentialCipher {
+    fn encrypt(&self, plaintext: &[u8]) -> Result<EncryptedCredential, DomainError> {
+        Ok(EncryptedCredential::from_persistence(
+            plaintext.iter().map(|byte| byte ^ MASK).collect(),
+        ))
+    }
+
+    fn decrypt(&self, credential: &EncryptedCredential) -> Result<Vec<u8>, DomainError> {
+        Ok(credential.value().iter().map(|byte| byte ^ MASK).collect())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/dimension_store.rs b/crates/domain/src/testing/fakes/dimension_store.rs
new file mode 100644
index 0000000..9a38eb9
--- /dev/null
+++ b/crates/domain/src/testing/fakes/dimension_store.rs
@@ -0,0 +1,63 @@
+use std::collections::HashMap;
+use std::sync::RwLock;
+
+use crate::dimension::{DimensionKind, DimensionValue};
+use crate::entry::MoodEntryId;
+use crate::errors::DomainError;
+
+pub struct InMemoryDimensionStore {
+    kind: DimensionKind,
+    values: RwLock<HashMap<MoodEntryId, DimensionValue>>,
+}
+
+impl InMemoryDimensionStore {
+    pub fn new(kind: DimensionKind) -> Self {
+        Self {
+            kind,
+            values: RwLock::new(HashMap::new()),
+        }
+    }
+
+    pub fn forget(&self, entry_id: &MoodEntryId) {
+        self.values.write().unwrap().remove(entry_id);
+    }
+
+    pub fn holds_count(&self) -> usize {
+        self.values.read().unwrap().len()
+    }
+
+    pub fn holds(&self, entry_id: &MoodEntryId) -> bool {
+        self.values.read().unwrap().contains_key(entry_id)
+    }
+
+    pub fn put(&self, entry_id: &MoodEntryId, value: DimensionValue) {
+        self.values.write().unwrap().insert(entry_id.clone(), value);
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::EntryDimensionPort for InMemoryDimensionStore {
+    async fn load(
+        &self,
+        entry_ids: &[MoodEntryId],
+    ) -> Result<HashMap<MoodEntryId, DimensionValue>, DomainError> {
+        let stored = self.values.read().unwrap();
+        Ok(entry_ids
+            .iter()
+            .filter_map(|id| stored.get(id).map(|value| (id.clone(), value.clone())))
+            .collect())
+    }
+
+    async fn save(
+        &self,
+        entry_id: &MoodEntryId,
+        values: &[DimensionValue],
+    ) -> Result<(), DomainError> {
+        let mut stored = self.values.write().unwrap();
+        match values.iter().find(|value| value.kind() == self.kind) {
+            Some(value) => stored.insert(entry_id.clone(), value.clone()),
+            None => stored.remove(entry_id),
+        };
+        Ok(())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/media_storage.rs b/crates/domain/src/testing/fakes/media_storage.rs
new file mode 100644
index 0000000..15bc607
--- /dev/null
+++ b/crates/domain/src/testing/fakes/media_storage.rs
@@ -0,0 +1,137 @@
+use std::collections::HashMap;
+use std::sync::RwLock;
+
+use crate::attachment::{ContentType, MediaUpload, PhotoId, VoiceMemoId};
+use crate::errors::DomainError;
+use crate::ports::MediaFile;
+
+pub struct FakeMediaStorage {
+    photos: RwLock<HashMap<PhotoId, Vec<u8>>>,
+    voice_memos: RwLock<HashMap<VoiceMemoId, Vec<u8>>>,
+    deletions_attempted: RwLock<Vec<String>>,
+    refusing_to_delete: bool,
+}
+
+impl FakeMediaStorage {
+    pub fn holding_nothing() -> Self {
+        Self {
+            photos: RwLock::new(HashMap::new()),
+            voice_memos: RwLock::new(HashMap::new()),
+            deletions_attempted: RwLock::new(Vec::new()),
+            refusing_to_delete: false,
+        }
+    }
+
+    pub fn refusing_to_delete() -> Self {
+        Self {
+            refusing_to_delete: true,
+            ..Self::holding_nothing()
+        }
+    }
+
+    pub fn put_photo(&self, id: &PhotoId, bytes: &[u8]) {
+        self.photos
+            .write()
+            .unwrap()
+            .insert(id.clone(), bytes.to_vec());
+    }
+
+    pub fn put_voice_memo(&self, id: &VoiceMemoId, bytes: &[u8]) {
+        self.voice_memos
+            .write()
+            .unwrap()
+            .insert(id.clone(), bytes.to_vec());
+    }
+
+    pub fn holds_photo(&self, id: &PhotoId) -> bool {
+        self.photos.read().unwrap().contains_key(id)
+    }
+
+    pub fn holds_voice_memo(&self, id: &VoiceMemoId) -> bool {
+        self.voice_memos.read().unwrap().contains_key(id)
+    }
+
+    pub fn blobs_held(&self) -> usize {
+        self.photos.read().unwrap().len() + self.voice_memos.read().unwrap().len()
+    }
+
+    pub fn deletions_attempted(&self) -> Vec<String> {
+        self.deletions_attempted.read().unwrap().clone()
+    }
+}
+
+impl Default for FakeMediaStorage {
+    fn default() -> Self {
+        Self::holding_nothing()
+    }
+}
+
+#[async_trait::async_trait]
+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());
+
+        Ok(id)
+    }
+
+    async fn store_voice_memo(&self, upload: MediaUpload) -> Result<VoiceMemoId, DomainError> {
+        let id = VoiceMemoId::generate();
+        self.put_voice_memo(&id, upload.data());
+
+        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()),
+        }))
+    }
+
+    async fn get_voice_memo(&self, id: &VoiceMemoId) -> Result<Option<MediaFile>, DomainError> {
+        Ok(self
+            .voice_memos
+            .read()
+            .unwrap()
+            .get(id)
+            .map(|bytes| MediaFile {
+                data: bytes.clone(),
+                content_type: ContentType::from_persistence("audio/webm".into()),
+            }))
+    }
+
+    async fn delete_photo(&self, id: &PhotoId) -> Result<(), DomainError> {
+        self.deletions_attempted
+            .write()
+            .unwrap()
+            .push(id.value().to_string());
+
+        if self.refusing_to_delete {
+            return Err(DomainError::InvalidInput(
+                "the blob store refused to delete this photo".into(),
+            ));
+        }
+
+        self.photos.write().unwrap().remove(id);
+
+        Ok(())
+    }
+
+    async fn delete_voice_memo(&self, id: &VoiceMemoId) -> Result<(), DomainError> {
+        self.deletions_attempted
+            .write()
+            .unwrap()
+            .push(id.value().to_string());
+
+        if self.refusing_to_delete {
+            return Err(DomainError::InvalidInput(
+                "the blob store refused to delete this voice memo".into(),
+            ));
+        }
+
+        self.voice_memos.write().unwrap().remove(id);
+
+        Ok(())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/mod.rs b/crates/domain/src/testing/fakes/mod.rs
index 7ddc454..01b8a10 100644
--- a/crates/domain/src/testing/fakes/mod.rs
+++ b/crates/domain/src/testing/fakes/mod.rs
@@ -1,11 +1,31 @@
+mod api_token_secret;
+mod cipher;
+mod dimension_store;
+mod media_storage;
+mod music;
 mod password_hasher;
+mod refusing;
 mod store;
 mod store_activity;
+mod store_api_token;
 mod store_auth;
+mod store_cycle;
 mod store_entry;
 mod store_infra;
+mod store_job;
+mod store_metric;
+mod store_provider;
+mod store_rejection;
 mod store_reminder;
 mod store_user;
+mod weather;
 
+pub use api_token_secret::FakeApiTokenSecret;
+pub use cipher::FakeCredentialCipher;
+pub use dimension_store::InMemoryDimensionStore;
+pub use media_storage::FakeMediaStorage;
+pub use music::{FakeNowPlaying, FakeRecordingLookup};
 pub use password_hasher::FakePasswordHasher;
+pub use refusing::{OneTokenStore, RefusingApiTokenStore, RefusingRejectionTrace};
 pub use store::InMemoryStore;
+pub use weather::FakeWeatherLookup;
diff --git a/crates/domain/src/testing/fakes/music.rs b/crates/domain/src/testing/fakes/music.rs
new file mode 100644
index 0000000..40424df
--- /dev/null
+++ b/crates/domain/src/testing/fakes/music.rs
@@ -0,0 +1,90 @@
+use crate::errors::DomainError;
+use crate::ports::{NowPlayingPort, RecordingLookupPort};
+use crate::song::{RecordingId, Song};
+
+pub struct FakeNowPlaying {
+    provider: String,
+    playing: Option<Song>,
+    failing_with: Option<String>,
+}
+
+impl FakeNowPlaying {
+    pub fn playing(provider: &str, song: Song) -> Self {
+        Self {
+            provider: provider.to_string(),
+            playing: Some(song),
+            failing_with: None,
+        }
+    }
+
+    pub fn silent(provider: &str) -> Self {
+        Self {
+            provider: provider.to_string(),
+            playing: None,
+            failing_with: None,
+        }
+    }
+
+    pub fn failing(provider: &str, reason: impl Into<String>) -> Self {
+        Self {
+            provider: provider.to_string(),
+            playing: None,
+            failing_with: Some(reason.into()),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl NowPlayingPort for FakeNowPlaying {
+    fn provider(&self) -> &str {
+        &self.provider
+    }
+
+    async fn now_playing(&self, _credential: &[u8]) -> Result<Option<Song>, DomainError> {
+        if let Some(reason) = &self.failing_with {
+            return Err(DomainError::InvalidInput(reason.clone()));
+        }
+
+        Ok(self.playing.clone())
+    }
+}
+
+pub struct FakeRecordingLookup {
+    found: Option<RecordingId>,
+    failing_with: Option<String>,
+}
+
+impl FakeRecordingLookup {
+    pub fn finding(found: Option<RecordingId>) -> Self {
+        Self {
+            found,
+            failing_with: None,
+        }
+    }
+
+    pub fn finding_nothing() -> Self {
+        Self::finding(None)
+    }
+
+    pub fn failing(reason: impl Into<String>) -> Self {
+        Self {
+            found: None,
+            failing_with: Some(reason.into()),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl RecordingLookupPort for FakeRecordingLookup {
+    async fn find_recording(
+        &self,
+        _title: &str,
+        _artist: &str,
+    ) -> Result<Option<RecordingId>, DomainError> {
+        if let Some(reason) = &self.failing_with {
+            return Err(DomainError::InvalidInput(reason.clone()));
+        }
+
+        Ok(self.found.clone())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/refusing.rs b/crates/domain/src/testing/fakes/refusing.rs
new file mode 100644
index 0000000..22b6271
--- /dev/null
+++ b/crates/domain/src/testing/fakes/refusing.rs
@@ -0,0 +1,55 @@
+use crate::api_token::{ApiToken, ApiTokenId, TokenDigest};
+use crate::errors::DomainError;
+use crate::rejection::RejectedMetric;
+use crate::user::UserId;
+
+pub struct RefusingRejectionTrace;
+
+#[async_trait::async_trait]
+impl crate::ports::RejectionCommandPort for RefusingRejectionTrace {
+    async fn record(&self, _rejections: &[RejectedMetric]) -> Result<(), DomainError> {
+        Err(DomainError::InvalidInput(
+            "the rejection trace is unwritable".into(),
+        ))
+    }
+}
+
+pub struct RefusingApiTokenStore;
+
+#[async_trait::async_trait]
+impl crate::ports::ApiTokenCommandPort for RefusingApiTokenStore {
+    async fn save(&self, _token: &ApiToken) -> Result<(), DomainError> {
+        Err(DomainError::InvalidInput("cannot write a token".into()))
+    }
+
+    async fn revoke(&self, _user_id: &UserId, _id: &ApiTokenId) -> Result<(), DomainError> {
+        Err(DomainError::InvalidInput("cannot revoke a token".into()))
+    }
+
+    async fn mark_used(&self, _id: &ApiTokenId) -> Result<(), DomainError> {
+        Err(DomainError::InvalidInput(
+            "cannot record that a token was used".into(),
+        ))
+    }
+}
+
+pub struct OneTokenStore(pub ApiToken);
+
+#[async_trait::async_trait]
+impl crate::ports::ApiTokenQueryPort for OneTokenStore {
+    async fn find_by_digest(&self, digest: &TokenDigest) -> Result<Option<ApiToken>, DomainError> {
+        if self.0.digest() == digest {
+            return Ok(Some(self.0.clone()));
+        }
+
+        Ok(None)
+    }
+
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<ApiToken>, DomainError> {
+        if self.0.user_id() == user_id {
+            return Ok(vec![self.0.clone()]);
+        }
+
+        Ok(Vec::new())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/store.rs b/crates/domain/src/testing/fakes/store.rs
index 8c0004e..590e92c 100644
--- a/crates/domain/src/testing/fakes/store.rs
+++ b/crates/domain/src/testing/fakes/store.rs
@@ -1,21 +1,48 @@
 use std::collections::HashMap;
 use std::sync::RwLock;
 
+use super::InMemoryDimensionStore;
 use crate::activity::{Activity, ActivityId};
+use crate::api_token::ApiToken;
 use crate::auth::RefreshSession;
+use crate::entry::Date;
 use crate::entry::{MoodEntry, MoodEntryId};
 use crate::events::EventEnvelope;
+use crate::job::Job;
+use crate::metric::DailyMetric;
+use crate::provider::ProviderConnection;
 use crate::push::{PushSubscription, PushSubscriptionId};
+use crate::rejection::RejectedMetric;
 use crate::reminder::{Reminder, ReminderId};
-use crate::user::{User, UserId};
+use crate::song::RecordingId;
+use crate::user::{User, UserId, UserPreferences};
 
 pub struct InMemoryStore {
     pub(super) entries: RwLock<HashMap<MoodEntryId, MoodEntry>>,
+    pub(super) entry_activities: RwLock<HashMap<MoodEntryId, Vec<ActivityId>>>,
     pub(super) activities: RwLock<HashMap<ActivityId, Activity>>,
     pub(super) users: RwLock<HashMap<UserId, User>>,
     pub(super) reminders: RwLock<HashMap<ReminderId, Reminder>>,
     pub refresh_sessions: RwLock<Vec<RefreshSession>>,
     pub(super) push_subscriptions: RwLock<HashMap<PushSubscriptionId, PushSubscription>>,
+    pub(super) provider_connections: RwLock<Vec<ProviderConnection>>,
+    pub(super) daily_metrics: RwLock<Vec<DailyMetric>>,
+    pub(super) api_tokens: RwLock<Vec<ApiToken>>,
+    pub(super) rejections: RwLock<Vec<RejectedMetric>>,
+    pub(super) cycle_starts: RwLock<Vec<(UserId, Date)>>,
+    pub(super) preferences: RwLock<Vec<UserPreferences>>,
+    pub(super) jobs: RwLock<Vec<Job>>,
+    pub(super) unidentified_songs: RwLock<Vec<(MoodEntryId, String, String)>>,
+    pub(super) recordings: RwLock<Vec<(MoodEntryId, RecordingId)>>,
+    pub(super) places_without_weather: RwLock<
+        Vec<(
+            MoodEntryId,
+            crate::location::Coordinates,
+            chrono::DateTime<chrono::FixedOffset>,
+        )>,
+    >,
+    pub(super) observed_weather: RwLock<Vec<(MoodEntryId, crate::weather::Weather)>>,
+    pub(super) dependent_dimensions: RwLock<Vec<std::sync::Arc<InMemoryDimensionStore>>>,
     pub(super) events: RwLock<Vec<EventEnvelope>>,
     pub(super) sent_reminders: RwLock<Vec<UserId>>,
 }
@@ -24,16 +51,44 @@ impl InMemoryStore {
     pub fn new() -> Self {
         Self {
             entries: RwLock::new(HashMap::new()),
+            entry_activities: RwLock::new(HashMap::new()),
             activities: RwLock::new(HashMap::new()),
             users: RwLock::new(HashMap::new()),
             reminders: RwLock::new(HashMap::new()),
             refresh_sessions: RwLock::new(Vec::new()),
             push_subscriptions: RwLock::new(HashMap::new()),
+            provider_connections: RwLock::new(Vec::new()),
+            daily_metrics: RwLock::new(Vec::new()),
+            api_tokens: RwLock::new(Vec::new()),
+            rejections: RwLock::new(Vec::new()),
+            cycle_starts: RwLock::new(Vec::new()),
+            preferences: RwLock::new(Vec::new()),
+            jobs: RwLock::new(Vec::new()),
+            unidentified_songs: RwLock::new(Vec::new()),
+            recordings: RwLock::new(Vec::new()),
+            places_without_weather: RwLock::new(Vec::new()),
+            observed_weather: RwLock::new(Vec::new()),
+            dependent_dimensions: RwLock::new(Vec::new()),
             events: RwLock::new(Vec::new()),
             sent_reminders: RwLock::new(Vec::new()),
         }
     }
 
+    pub fn cascades_to(&self, dimensions: &std::sync::Arc<InMemoryDimensionStore>) {
+        self.dependent_dimensions
+            .write()
+            .unwrap()
+            .push(dimensions.clone());
+    }
+
+    pub(super) fn cascade_to_dimensions(&self, entry_ids: &[MoodEntryId]) {
+        for store in self.dependent_dimensions.read().unwrap().iter() {
+            for entry_id in entry_ids {
+                store.forget(entry_id);
+            }
+        }
+    }
+
     pub fn published_events(&self) -> Vec<EventEnvelope> {
         self.events.read().unwrap().clone()
     }
@@ -64,3 +119,12 @@ impl Default for InMemoryStore {
         Self::new()
     }
 }
+
+impl InMemoryStore {
+    pub fn assign_activities(&self, entry_id: &MoodEntryId, activities: Vec<ActivityId>) {
+        self.entry_activities
+            .write()
+            .unwrap()
+            .insert(entry_id.clone(), activities);
+    }
+}
diff --git a/crates/domain/src/testing/fakes/store_api_token.rs b/crates/domain/src/testing/fakes/store_api_token.rs
new file mode 100644
index 0000000..4904d0f
--- /dev/null
+++ b/crates/domain/src/testing/fakes/store_api_token.rs
@@ -0,0 +1,77 @@
+use crate::api_token::{ApiToken, ApiTokenId, TokenDigest};
+use crate::errors::DomainError;
+use crate::user::UserId;
+
+use super::InMemoryStore;
+
+#[async_trait::async_trait]
+impl crate::ports::ApiTokenCommandPort for InMemoryStore {
+    async fn save(&self, token: &ApiToken) -> Result<(), DomainError> {
+        let mut stored = self.api_tokens.write().unwrap();
+
+        let name_taken = stored.iter().any(|held: &ApiToken| {
+            held.user_id() == token.user_id()
+                && held.name() == token.name()
+                && held.id() != token.id()
+        });
+
+        if name_taken {
+            return Err(DomainError::Conflict(format!(
+                "a token named {} already exists",
+                token.name().value()
+            )));
+        }
+
+        stored.retain(|held| held.id() != token.id());
+        stored.push(token.clone());
+
+        Ok(())
+    }
+
+    async fn revoke(&self, user_id: &UserId, id: &ApiTokenId) -> Result<(), DomainError> {
+        let mut stored = self.api_tokens.write().unwrap();
+        let held = stored.len();
+
+        stored.retain(|token| token.user_id() != user_id || token.id() != id);
+
+        if stored.len() == held {
+            return Err(DomainError::NotFound("token not found".into()));
+        }
+
+        Ok(())
+    }
+
+    async fn mark_used(&self, id: &ApiTokenId) -> Result<(), DomainError> {
+        let mut stored = self.api_tokens.write().unwrap();
+
+        if let Some(token) = stored.iter_mut().find(|token| token.id() == id) {
+            token.mark_used();
+        }
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::ApiTokenQueryPort for InMemoryStore {
+    async fn find_by_digest(&self, digest: &TokenDigest) -> Result<Option<ApiToken>, DomainError> {
+        Ok(self
+            .api_tokens
+            .read()
+            .unwrap()
+            .iter()
+            .find(|token| token.digest() == digest)
+            .cloned())
+    }
+
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<ApiToken>, DomainError> {
+        Ok(self
+            .api_tokens
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|token| token.user_id() == user_id)
+            .cloned()
+            .collect())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/store_cycle.rs b/crates/domain/src/testing/fakes/store_cycle.rs
new file mode 100644
index 0000000..f638a9e
--- /dev/null
+++ b/crates/domain/src/testing/fakes/store_cycle.rs
@@ -0,0 +1,65 @@
+use crate::entry::Date;
+use crate::errors::DomainError;
+use crate::user::{UserId, UserPreferences};
+
+use super::InMemoryStore;
+
+#[async_trait::async_trait]
+impl crate::ports::CycleStartCommandPort for InMemoryStore {
+    async fn record(&self, user_id: &UserId, date: &Date) -> Result<(), DomainError> {
+        let mut stored = self.cycle_starts.write().unwrap();
+
+        if !stored.iter().any(|held| held == &(user_id.clone(), *date)) {
+            stored.push((user_id.clone(), *date));
+        }
+
+        Ok(())
+    }
+
+    async fn forget(&self, user_id: &UserId, date: &Date) -> Result<(), DomainError> {
+        self.cycle_starts
+            .write()
+            .unwrap()
+            .retain(|held| held.0 != *user_id || held.1 != *date);
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::CycleStartQueryPort for InMemoryStore {
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<Date>, DomainError> {
+        Ok(self
+            .cycle_starts
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|held| held.0 == *user_id)
+            .map(|held| held.1)
+            .collect())
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::UserPreferencesCommandPort for InMemoryStore {
+    async fn save(&self, preferences: &UserPreferences) -> Result<(), DomainError> {
+        let mut stored = self.preferences.write().unwrap();
+        stored.retain(|held| held.user_id() != preferences.user_id());
+        stored.push(preferences.clone());
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::UserPreferencesQueryPort for InMemoryStore {
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Option<UserPreferences>, DomainError> {
+        Ok(self
+            .preferences
+            .read()
+            .unwrap()
+            .iter()
+            .find(|held| held.user_id() == user_id)
+            .cloned())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/store_entry.rs b/crates/domain/src/testing/fakes/store_entry.rs
index 1ac2779..629d709 100644
--- a/crates/domain/src/testing/fakes/store_entry.rs
+++ b/crates/domain/src/testing/fakes/store_entry.rs
@@ -55,28 +55,25 @@ impl crate::ports::MoodEntryCommandPort for InMemoryStore {
         old_activity_id: &ActivityId,
         new_activity_id: &ActivityId,
     ) -> Result<u64, DomainError> {
-        let mut store = self.entries.write().unwrap();
+        let entries = self.entries.read().unwrap();
+        let mut assignments = self.entry_activities.write().unwrap();
         let mut count = 0u64;
-        for entry in store.values_mut() {
-            if entry.user_id() != user_id {
+
+        for (entry_id, activities) in assignments.iter_mut() {
+            let owned_by_user = entries
+                .get(entry_id)
+                .is_some_and(|entry| entry.user_id() == user_id);
+            if !owned_by_user || !activities.contains(old_activity_id) {
                 continue;
             }
-            let activities: Vec<_> = entry.activities().to_vec();
-            if activities.contains(old_activity_id) {
-                let replaced: Vec<_> = activities
-                    .into_iter()
-                    .map(|a| {
-                        if &a == old_activity_id {
-                            new_activity_id.clone()
-                        } else {
-                            a
-                        }
-                    })
-                    .collect();
-                entry.set_activities(replaced);
-                count += 1;
+            for activity in activities.iter_mut() {
+                if activity == old_activity_id {
+                    *activity = new_activity_id.clone();
+                }
             }
+            count += 1;
         }
+
         Ok(count)
     }
 }
@@ -153,7 +150,15 @@ impl crate::ports::MoodEntryQueryPort for InMemoryStore {
             .read()
             .unwrap()
             .values()
-            .filter(|e| e.user_id() == user_id && e.activities().contains(activity_id))
+            .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())
     }
diff --git a/crates/domain/src/testing/fakes/store_infra.rs b/crates/domain/src/testing/fakes/store_infra.rs
index 4a33a68..92c66f8 100644
--- a/crates/domain/src/testing/fakes/store_infra.rs
+++ b/crates/domain/src/testing/fakes/store_infra.rs
@@ -52,6 +52,8 @@ impl crate::ports::MediaStoragePort for InMemoryStore {
 #[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()
@@ -64,10 +66,16 @@ impl crate::ports::CascadeDeletePort for InMemoryStore {
             .write()
             .unwrap()
             .retain(|_, r| r.user_id() != user_id);
+        self.daily_metrics
+            .write()
+            .unwrap()
+            .retain(|m| m.user_id() != 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()
@@ -88,6 +96,10 @@ impl crate::ports::CascadeDeletePort for InMemoryStore {
             .write()
             .unwrap()
             .retain(|_, s| s.user_id() != user_id);
+        self.daily_metrics
+            .write()
+            .unwrap()
+            .retain(|m| m.user_id() != user_id);
         self.users.write().unwrap().remove(user_id);
         Ok(())
     }
@@ -110,10 +122,28 @@ impl crate::ports::CascadeDeletePort for InMemoryStore {
                 true
             }
         });
+        drop(entries);
+
+        let gone: Vec<crate::entry::MoodEntryId> =
+            removed.iter().map(|entry| entry.id().clone()).collect();
+        self.cascade_to_dimensions(&gone);
+
         Ok(removed)
     }
 }
 
+impl InMemoryStore {
+    fn entry_ids_of(&self, user_id: &UserId) -> Vec<crate::entry::MoodEntryId> {
+        self.entries
+            .read()
+            .unwrap()
+            .values()
+            .filter(|entry| entry.user_id() == user_id)
+            .map(|entry| entry.id().clone())
+            .collect()
+    }
+}
+
 #[async_trait::async_trait]
 impl crate::ports::PushSubscriptionCommandPort for InMemoryStore {
     async fn save(&self, subscription: &PushSubscription) -> Result<(), DomainError> {
@@ -174,12 +204,16 @@ impl crate::ports::PushSubscriptionQueryPort for InMemoryStore {
 }
 
 #[async_trait::async_trait]
-impl crate::ports::ExportPort for InMemoryStore {
-    async fn export_user_data(
-        &self,
-        _data: &crate::ports::UserExport,
-    ) -> Result<Vec<u8>, DomainError> {
-        Ok(b"exported".to_vec())
+impl crate::ports::BackupWriterPort for InMemoryStore {
+    async fn write(&self, _backup: &crate::ports::UserBackup) -> Result<Vec<u8>, DomainError> {
+        Ok(b"backup".to_vec())
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::ExtractWriterPort for InMemoryStore {
+    async fn write(&self, _extract: &crate::ports::SharedExtract) -> Result<Vec<u8>, DomainError> {
+        Ok(b"extract".to_vec())
     }
 }
 
diff --git a/crates/domain/src/testing/fakes/store_job.rs b/crates/domain/src/testing/fakes/store_job.rs
new file mode 100644
index 0000000..29f8f28
--- /dev/null
+++ b/crates/domain/src/testing/fakes/store_job.rs
@@ -0,0 +1,244 @@
+use chrono::Utc;
+
+use crate::errors::DomainError;
+use crate::job::{Job, JobId, JobKind, JobStatus, JobSubject};
+use crate::ports::UnidentifiedSong;
+
+use super::InMemoryStore;
+
+impl InMemoryStore {
+    pub fn put_place_without_weather(
+        &self,
+        entry_id: &crate::entry::MoodEntryId,
+        coordinates: crate::location::Coordinates,
+        logged_at: chrono::DateTime<chrono::FixedOffset>,
+    ) {
+        self.places_without_weather.write().unwrap().push((
+            entry_id.clone(),
+            coordinates,
+            logged_at,
+        ));
+    }
+
+    pub fn every_job(&self) -> Vec<Job> {
+        self.jobs.read().unwrap().clone()
+    }
+
+    pub fn lose_every_job(&self) {
+        self.jobs.write().unwrap().clear();
+    }
+
+    pub fn put_unidentified_song(
+        &self,
+        entry_id: &crate::entry::MoodEntryId,
+        title: &str,
+        artist: &str,
+    ) {
+        self.unidentified_songs.write().unwrap().push((
+            entry_id.clone(),
+            title.to_string(),
+            artist.to_string(),
+        ));
+    }
+
+    pub fn recording_of(
+        &self,
+        entry_id: &crate::entry::MoodEntryId,
+    ) -> Option<crate::song::RecordingId> {
+        self.recordings
+            .read()
+            .unwrap()
+            .iter()
+            .find(|held| &held.0 == entry_id)
+            .map(|held| held.1.clone())
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::JobQueueCommandPort for InMemoryStore {
+    async fn enqueue(&self, kind: JobKind, subject: &JobSubject) -> Result<bool, DomainError> {
+        let mut queued = self.jobs.write().unwrap();
+
+        let already_here = queued
+            .iter()
+            .any(|job| job.kind() == kind && job.subject() == subject);
+
+        if already_here {
+            return Ok(false);
+        }
+
+        queued.push(Job::pending(kind, subject.clone()));
+
+        Ok(true)
+    }
+
+    async fn claim(&self, kind: JobKind, most: usize) -> Result<Vec<Job>, DomainError> {
+        let mut queued = self.jobs.write().unwrap();
+        let mut claimed = Vec::new();
+
+        for job in queued.iter_mut() {
+            if claimed.len() == most {
+                break;
+            }
+
+            if job.kind() != kind || job.status() != JobStatus::Pending {
+                continue;
+            }
+
+            *job = running(job);
+            claimed.push(job.clone());
+        }
+
+        Ok(claimed)
+    }
+
+    async fn finish(&self, id: &JobId) -> Result<(), DomainError> {
+        self.jobs.write().unwrap().retain(|job| job.id() != id);
+
+        Ok(())
+    }
+
+    async fn release(&self, id: &JobId, reason: &str) -> Result<(), DomainError> {
+        self.rewrite(id, JobStatus::Pending, Some(reason), true);
+
+        Ok(())
+    }
+
+    async fn exhaust(&self, id: &JobId, reason: &str) -> Result<(), DomainError> {
+        self.rewrite(id, JobStatus::Exhausted, Some(reason), true);
+
+        Ok(())
+    }
+
+    async fn reclaim_stalled(&self, stalled_after_seconds: i64) -> Result<u64, DomainError> {
+        let mut queued = self.jobs.write().unwrap();
+        let mut reclaimed = 0;
+
+        for job in queued.iter_mut() {
+            let stalled = (Utc::now() - *job.updated_at()).num_seconds() >= stalled_after_seconds;
+
+            if job.status() == JobStatus::Running && stalled {
+                *job = rebuilt(job, JobStatus::Pending, job.last_error(), false);
+                reclaimed += 1;
+            }
+        }
+
+        Ok(reclaimed)
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::JobQueueQueryPort for InMemoryStore {
+    async fn find_exhausted(&self, most: usize) -> Result<Vec<Job>, DomainError> {
+        Ok(self
+            .jobs
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|job| job.status() == JobStatus::Exhausted)
+            .take(most)
+            .cloned()
+            .collect())
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::RecordingBackfillQueryPort for InMemoryStore {
+    async fn find_songs_without_a_recording(
+        &self,
+        most: usize,
+    ) -> Result<Vec<UnidentifiedSong>, DomainError> {
+        let identified: Vec<crate::entry::MoodEntryId> = self
+            .recordings
+            .read()
+            .unwrap()
+            .iter()
+            .map(|held| held.0.clone())
+            .collect();
+
+        Ok(self
+            .unidentified_songs
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|held| !identified.contains(&held.0))
+            .take(most)
+            .map(|held| UnidentifiedSong {
+                entry_id: held.0.clone(),
+                user_id: crate::user::UserId::generate(),
+                title: held.1.clone(),
+                artist: held.2.clone(),
+            })
+            .collect())
+    }
+
+    async fn record_identity(
+        &self,
+        entry_id: &crate::entry::MoodEntryId,
+        recording_id: &crate::song::RecordingId,
+    ) -> Result<(), DomainError> {
+        self.recordings
+            .write()
+            .unwrap()
+            .push((entry_id.clone(), recording_id.clone()));
+
+        Ok(())
+    }
+}
+
+impl InMemoryStore {
+    fn rewrite(&self, id: &JobId, status: JobStatus, reason: Option<&str>, counted: bool) {
+        let mut queued = self.jobs.write().unwrap();
+
+        if let Some(job) = queued.iter_mut().find(|job| job.id() == id) {
+            *job = rebuilt(job, status, reason, counted);
+        }
+    }
+}
+
+fn running(job: &Job) -> Job {
+    rebuilt(job, JobStatus::Running, job.last_error(), false)
+}
+
+fn rebuilt(job: &Job, status: JobStatus, reason: Option<&str>, counted: bool) -> Job {
+    Job::from_persistence(crate::job::JobData {
+        id: job.id().clone(),
+        kind: job.kind(),
+        subject: job.subject().clone(),
+        status,
+        attempts: job.attempts() + u32::from(counted),
+        last_error: reason.map(|reason| reason.to_string()),
+        enqueued_at: *job.enqueued_at(),
+        updated_at: Utc::now(),
+    })
+}
+
+#[async_trait::async_trait]
+impl crate::ports::WeatherBacklogQueryPort for InMemoryStore {
+    async fn find_places_without_weather(
+        &self,
+        most: usize,
+    ) -> Result<Vec<crate::ports::UnwatchedPlace>, DomainError> {
+        let watched: Vec<crate::entry::MoodEntryId> = self
+            .observed_weather
+            .read()
+            .unwrap()
+            .iter()
+            .map(|held| held.0.clone())
+            .collect();
+
+        Ok(self
+            .places_without_weather
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|held| !watched.contains(&held.0))
+            .take(most)
+            .map(|held| crate::ports::UnwatchedPlace {
+                entry_id: held.0.clone(),
+                coordinates: held.1,
+                logged_at: held.2,
+            })
+            .collect())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/store_metric.rs b/crates/domain/src/testing/fakes/store_metric.rs
new file mode 100644
index 0000000..b90d588
--- /dev/null
+++ b/crates/domain/src/testing/fakes/store_metric.rs
@@ -0,0 +1,67 @@
+use crate::entry::{Date, DateSpan};
+use crate::errors::DomainError;
+use crate::metric::{DailyMetric, MetricKind};
+use crate::user::UserId;
+
+use super::InMemoryStore;
+
+#[async_trait::async_trait]
+impl crate::ports::DailyMetricCommandPort for InMemoryStore {
+    async fn save(&self, metrics: &[DailyMetric]) -> Result<usize, DomainError> {
+        let mut stored = self.daily_metrics.write().unwrap();
+        let mut written = 0;
+
+        for incoming in metrics {
+            let existing = stored.iter().position(|held: &DailyMetric| {
+                held.user_id() == incoming.user_id()
+                    && held.date() == incoming.date()
+                    && held.kind() == incoming.kind()
+            });
+
+            match existing {
+                Some(index) if incoming.supersedes(&stored[index]) => {
+                    stored[index] = incoming.clone();
+                    written += 1;
+                }
+                Some(_) => continue,
+                None => {
+                    stored.push(incoming.clone());
+                    written += 1;
+                }
+            }
+        }
+
+        Ok(written)
+    }
+
+    async fn delete(
+        &self,
+        user_id: &UserId,
+        date: &Date,
+        kinds: &[MetricKind],
+    ) -> Result<(), DomainError> {
+        self.daily_metrics.write().unwrap().retain(|held| {
+            held.user_id() != user_id || held.date() != date || !kinds.contains(&held.kind())
+        });
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::DailyMetricQueryPort for InMemoryStore {
+    async fn find_by_span(
+        &self,
+        user_id: &UserId,
+        span: &DateSpan,
+    ) -> Result<Vec<DailyMetric>, DomainError> {
+        Ok(self
+            .daily_metrics
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|metric| metric.user_id() == user_id && span.contains(metric.date()))
+            .cloned()
+            .collect())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/store_provider.rs b/crates/domain/src/testing/fakes/store_provider.rs
new file mode 100644
index 0000000..f1fc953
--- /dev/null
+++ b/crates/domain/src/testing/fakes/store_provider.rs
@@ -0,0 +1,54 @@
+use crate::errors::DomainError;
+use crate::provider::{ProviderConnection, ProviderName};
+use crate::user::UserId;
+
+use super::InMemoryStore;
+
+#[async_trait::async_trait]
+impl crate::ports::ProviderConnectionCommandPort for InMemoryStore {
+    async fn save(&self, connection: &ProviderConnection) -> Result<(), DomainError> {
+        let mut stored = self.provider_connections.write().unwrap();
+        stored.retain(|existing| {
+            existing.user_id() != connection.user_id()
+                || existing.provider() != connection.provider()
+        });
+        stored.push(connection.clone());
+        Ok(())
+    }
+
+    async fn delete(&self, user_id: &UserId, provider: &ProviderName) -> Result<(), DomainError> {
+        self.provider_connections
+            .write()
+            .unwrap()
+            .retain(|existing| existing.user_id() != user_id || existing.provider() != provider);
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::ProviderConnectionQueryPort for InMemoryStore {
+    async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<ProviderConnection>, DomainError> {
+        Ok(self
+            .provider_connections
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|existing| existing.user_id() == user_id)
+            .cloned()
+            .collect())
+    }
+
+    async fn find_by_user_and_provider(
+        &self,
+        user_id: &UserId,
+        provider: &ProviderName,
+    ) -> Result<Option<ProviderConnection>, DomainError> {
+        Ok(self
+            .provider_connections
+            .read()
+            .unwrap()
+            .iter()
+            .find(|existing| existing.user_id() == user_id && existing.provider() == provider)
+            .cloned())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/store_rejection.rs b/crates/domain/src/testing/fakes/store_rejection.rs
new file mode 100644
index 0000000..570d565
--- /dev/null
+++ b/crates/domain/src/testing/fakes/store_rejection.rs
@@ -0,0 +1,34 @@
+use crate::errors::DomainError;
+use crate::rejection::RejectedMetric;
+use crate::user::UserId;
+
+use super::InMemoryStore;
+
+#[async_trait::async_trait]
+impl crate::ports::RejectionCommandPort for InMemoryStore {
+    async fn record(&self, rejections: &[RejectedMetric]) -> Result<(), DomainError> {
+        self.rejections
+            .write()
+            .unwrap()
+            .extend(rejections.iter().cloned());
+
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::RejectionQueryPort for InMemoryStore {
+    async fn find_recent_by_user(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Vec<RejectedMetric>, DomainError> {
+        Ok(self
+            .rejections
+            .read()
+            .unwrap()
+            .iter()
+            .filter(|rejection| rejection.user_id() == user_id)
+            .cloned()
+            .collect())
+    }
+}
diff --git a/crates/domain/src/testing/fakes/weather.rs b/crates/domain/src/testing/fakes/weather.rs
new file mode 100644
index 0000000..2d5fca7
--- /dev/null
+++ b/crates/domain/src/testing/fakes/weather.rs
@@ -0,0 +1,58 @@
+use chrono::{DateTime, FixedOffset};
+
+use crate::errors::DomainError;
+use crate::location::Coordinates;
+use crate::provider::ProviderName;
+use crate::weather::Weather;
+
+pub struct FakeWeatherLookup {
+    provider: ProviderName,
+    observed: Option<Weather>,
+    failing_with: Option<String>,
+    asked: std::sync::atomic::AtomicUsize,
+}
+
+impl FakeWeatherLookup {
+    pub fn observing(observed: Option<Weather>) -> Self {
+        Self {
+            provider: ProviderName::from_persistence("open-meteo".into()),
+            observed,
+            failing_with: None,
+            asked: std::sync::atomic::AtomicUsize::new(0),
+        }
+    }
+
+    pub fn failing(reason: impl Into<String>) -> Self {
+        Self {
+            provider: ProviderName::from_persistence("open-meteo".into()),
+            observed: None,
+            failing_with: Some(reason.into()),
+            asked: std::sync::atomic::AtomicUsize::new(0),
+        }
+    }
+
+    pub fn times_asked(&self) -> usize {
+        self.asked.load(std::sync::atomic::Ordering::SeqCst)
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::ports::WeatherLookupPort for FakeWeatherLookup {
+    fn provider(&self) -> &ProviderName {
+        &self.provider
+    }
+
+    async fn observed_at(
+        &self,
+        _coordinates: &Coordinates,
+        _instant: &DateTime<FixedOffset>,
+    ) -> Result<Option<Weather>, DomainError> {
+        self.asked.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+
+        if let Some(reason) = &self.failing_with {
+            return Err(DomainError::InvalidInput(reason.clone()));
+        }
+
+        Ok(self.observed.clone())
+    }
+}
diff --git a/crates/domain/src/testing/mod.rs b/crates/domain/src/testing/mod.rs
index 7b95261..663ec68 100644
--- a/crates/domain/src/testing/mod.rs
+++ b/crates/domain/src/testing/mod.rs
@@ -2,4 +2,8 @@ mod factories;
 mod fakes;
 
 pub use factories::*;
-pub use fakes::{FakePasswordHasher, InMemoryStore};
+pub use fakes::{
+    FakeApiTokenSecret, FakeCredentialCipher, FakeMediaStorage, FakeNowPlaying, FakePasswordHasher,
+    FakeRecordingLookup, FakeWeatherLookup, InMemoryDimensionStore, InMemoryStore, OneTokenStore,
+    RefusingApiTokenStore, RefusingRejectionTrace,
+};
diff --git a/crates/domain/src/user/mod.rs b/crates/domain/src/user/mod.rs
index 1a4c930..09b14b5 100644
--- a/crates/domain/src/user/mod.rs
+++ b/crates/domain/src/user/mod.rs
@@ -4,6 +4,7 @@ mod password_hash;
 mod timezone;
 mod user;
 mod user_id;
+mod user_preferences;
 mod user_role;
 mod username;
 
@@ -13,5 +14,6 @@ pub use password_hash::PasswordHash;
 pub use timezone::Timezone;
 pub use user::{User, UserData};
 pub use user_id::UserId;
+pub use user_preferences::UserPreferences;
 pub use user_role::UserRole;
 pub use username::Username;
diff --git a/crates/domain/src/user/timezone.rs b/crates/domain/src/user/timezone.rs
index 0430652..e684d5c 100644
--- a/crates/domain/src/user/timezone.rs
+++ b/crates/domain/src/user/timezone.rs
@@ -1,27 +1,30 @@
 use crate::errors::DomainError;
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
-pub struct Timezone(String);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+pub struct Timezone(chrono_tz::Tz);
 
 impl Timezone {
-    pub fn new(tz: impl Into<String>) -> Result<Self, DomainError> {
-        let trimmed = tz.into().trim().to_string();
+    pub fn new(name: impl AsRef<str>) -> Result<Self, DomainError> {
+        let trimmed = name.as_ref().trim();
+
         if trimmed.is_empty() {
             return Err(DomainError::InvalidInput("timezone cannot be empty".into()));
         }
-        if !trimmed.contains('/') {
-            return Err(DomainError::InvalidInput(
-                "timezone must be in IANA format (e.g. Europe/Warsaw)".into(),
-            ));
-        }
-        Ok(Self(trimmed))
+
+        trimmed.parse::<chrono_tz::Tz>().map(Self).map_err(|_| {
+            DomainError::InvalidInput(format!("{trimmed} is not a timezone in the IANA database"))
+        })
     }
 
-    pub fn from_persistence(tz: String) -> Self {
-        Self(tz)
+    pub fn from_persistence(name: &str) -> Result<Self, DomainError> {
+        Self::new(name)
     }
 
     pub fn value(&self) -> &str {
-        &self.0
+        self.0.name()
+    }
+
+    pub fn resolve(&self) -> chrono_tz::Tz {
+        self.0
     }
 }
diff --git a/crates/domain/src/user/user_preferences.rs b/crates/domain/src/user/user_preferences.rs
new file mode 100644
index 0000000..732c3c8
--- /dev/null
+++ b/crates/domain/src/user/user_preferences.rs
@@ -0,0 +1,37 @@
+use super::UserId;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UserPreferences {
+    user_id: UserId,
+    tracks_cycle: bool,
+}
+
+impl UserPreferences {
+    pub fn off_by_default(user_id: UserId) -> Self {
+        Self {
+            user_id,
+            tracks_cycle: false,
+        }
+    }
+
+    pub fn from_persistence(user_id: UserId, tracks_cycle: bool) -> Self {
+        Self {
+            user_id,
+            tracks_cycle,
+        }
+    }
+}
+
+impl UserPreferences {
+    pub fn user_id(&self) -> &UserId {
+        &self.user_id
+    }
+
+    pub fn tracks_cycle(&self) -> bool {
+        self.tracks_cycle
+    }
+
+    pub fn track_cycle(&mut self, tracks_cycle: bool) {
+        self.tracks_cycle = tracks_cycle;
+    }
+}
diff --git a/crates/domain/src/weather/celsius.rs b/crates/domain/src/weather/celsius.rs
new file mode 100644
index 0000000..0ee0772
--- /dev/null
+++ b/crates/domain/src/weather/celsius.rs
@@ -0,0 +1,33 @@
+use crate::errors::DomainError;
+
+const COLDEST_RECORDED: f64 = -90.0;
+const HOTTEST_RECORDED: f64 = 60.0;
+
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct Celsius(f64);
+
+impl Celsius {
+    pub fn new(degrees: f64) -> Result<Self, DomainError> {
+        if !degrees.is_finite() {
+            return Err(DomainError::InvalidInput(
+                "a temperature must be a finite number".into(),
+            ));
+        }
+
+        if !(COLDEST_RECORDED..=HOTTEST_RECORDED).contains(&degrees) {
+            return Err(DomainError::InvalidInput(format!(
+                "a temperature on earth is between {COLDEST_RECORDED} and {HOTTEST_RECORDED} degrees, got {degrees}"
+            )));
+        }
+
+        Ok(Self(degrees))
+    }
+
+    pub fn from_persistence(degrees: f64) -> Self {
+        Self(degrees)
+    }
+
+    pub fn value(&self) -> f64 {
+        self.0
+    }
+}
diff --git a/crates/domain/src/weather/condition.rs b/crates/domain/src/weather/condition.rs
new file mode 100644
index 0000000..2717baa
--- /dev/null
+++ b/crates/domain/src/weather/condition.rs
@@ -0,0 +1,55 @@
+const CLEAR: &str = "clear";
+const CLOUDY: &str = "cloudy";
+const FOG: &str = "fog";
+const DRIZZLE: &str = "drizzle";
+const RAIN: &str = "rain";
+const SNOW: &str = "snow";
+const THUNDERSTORM: &str = "thunderstorm";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Condition {
+    Clear,
+    Cloudy,
+    Fog,
+    Drizzle,
+    Rain,
+    Snow,
+    Thunderstorm,
+}
+
+impl Condition {
+    pub const ALL: [Condition; 7] = [
+        Self::Clear,
+        Self::Cloudy,
+        Self::Fog,
+        Self::Drizzle,
+        Self::Rain,
+        Self::Snow,
+        Self::Thunderstorm,
+    ];
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::Clear => CLEAR,
+            Self::Cloudy => CLOUDY,
+            Self::Fog => FOG,
+            Self::Drizzle => DRIZZLE,
+            Self::Rain => RAIN,
+            Self::Snow => SNOW,
+            Self::Thunderstorm => THUNDERSTORM,
+        }
+    }
+
+    pub fn from_name(name: &str) -> Option<Self> {
+        match name {
+            CLEAR => Some(Self::Clear),
+            CLOUDY => Some(Self::Cloudy),
+            FOG => Some(Self::Fog),
+            DRIZZLE => Some(Self::Drizzle),
+            RAIN => Some(Self::Rain),
+            SNOW => Some(Self::Snow),
+            THUNDERSTORM => Some(Self::Thunderstorm),
+            _ => None,
+        }
+    }
+}
diff --git a/crates/domain/src/weather/mod.rs b/crates/domain/src/weather/mod.rs
new file mode 100644
index 0000000..ca13609
--- /dev/null
+++ b/crates/domain/src/weather/mod.rs
@@ -0,0 +1,7 @@
+mod celsius;
+mod condition;
+mod weather;
+
+pub use celsius::Celsius;
+pub use condition::Condition;
+pub use weather::Weather;
diff --git a/crates/domain/src/weather/weather.rs b/crates/domain/src/weather/weather.rs
new file mode 100644
index 0000000..66c3f50
--- /dev/null
+++ b/crates/domain/src/weather/weather.rs
@@ -0,0 +1,34 @@
+use crate::provider::ProviderName;
+
+use super::{Celsius, Condition};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Weather {
+    condition: Condition,
+    temperature: Celsius,
+    observed_by: ProviderName,
+}
+
+impl Weather {
+    pub fn new(condition: Condition, temperature: Celsius, observed_by: ProviderName) -> Self {
+        Self {
+            condition,
+            temperature,
+            observed_by,
+        }
+    }
+}
+
+impl Weather {
+    pub fn condition(&self) -> Condition {
+        self.condition
+    }
+
+    pub fn temperature(&self) -> Celsius {
+        self.temperature
+    }
+
+    pub fn observed_by(&self) -> &ProviderName {
+        &self.observed_by
+    }
+}
diff --git a/crates/domain/tests/api_token.rs b/crates/domain/tests/api_token.rs
new file mode 100644
index 0000000..ca02339
--- /dev/null
+++ b/crates/domain/tests/api_token.rs
@@ -0,0 +1,2 @@
+#[path = "api_token/api_token_test.rs"]
+mod api_token_test;
diff --git a/crates/domain/tests/api_token/api_token_test.rs b/crates/domain/tests/api_token/api_token_test.rs
new file mode 100644
index 0000000..7ccbccc
--- /dev/null
+++ b/crates/domain/tests/api_token/api_token_test.rs
@@ -0,0 +1,57 @@
+use domain::api_token::{ApiToken, MintedApiToken, TokenDigest, TokenScope};
+use domain::provider::ProviderName;
+use domain::user::UserId;
+
+fn a_token() -> ApiToken {
+    ApiToken::new(
+        UserId::generate(),
+        ProviderName::new("iphone-shortcuts").unwrap(),
+        TokenDigest::from_persistence("digest-of-the-secret".into()),
+    )
+}
+
+#[test]
+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);
+}
+
+#[test]
+fn a_token_remembers_when_it_was_last_used() {
+    let mut token = a_token();
+
+    token.mark_used();
+
+    assert!(token.last_used_at().is_some());
+}
+
+#[test]
+fn the_name_a_token_carries_is_the_provider_its_writes_are_attributed_to() {
+    let token = a_token();
+
+    assert_eq!(token.name().value(), "iphone-shortcuts");
+}
+
+#[test]
+fn every_scope_survives_a_round_trip_through_its_name() {
+    assert_eq!(
+        TokenScope::from_name(TokenScope::WriteMetrics.name()),
+        Some(TokenScope::WriteMetrics)
+    );
+    assert_eq!(TokenScope::from_name("read-everything"), None);
+}
+
+#[test]
+fn a_minted_token_keeps_the_secret_out_of_its_debug_output() {
+    let minted = MintedApiToken::new(a_token(), "kmood_supersecretvalue".into());
+
+    let printed = format!("{minted:?}");
+
+    assert!(
+        !printed.contains("supersecret"),
+        "the secret leaked: {printed}"
+    );
+    assert_eq!(minted.secret(), "kmood_supersecretvalue");
+}
diff --git a/crates/domain/tests/correlation.rs b/crates/domain/tests/correlation.rs
new file mode 100644
index 0000000..a1e8477
--- /dev/null
+++ b/crates/domain/tests/correlation.rs
@@ -0,0 +1,14 @@
+#[path = "correlation/spearman_test.rs"]
+mod spearman_test;
+
+#[path = "correlation/moon_phase_test.rs"]
+mod moon_phase_test;
+
+#[path = "correlation/strategy_test.rs"]
+mod strategy_test;
+
+#[path = "correlation/significance_test.rs"]
+mod significance_test;
+
+#[path = "correlation/adjustment_test.rs"]
+mod adjustment_test;
diff --git a/crates/domain/tests/correlation/adjustment_test.rs b/crates/domain/tests/correlation/adjustment_test.rs
new file mode 100644
index 0000000..781fdfa
--- /dev/null
+++ b/crates/domain/tests/correlation/adjustment_test.rs
@@ -0,0 +1,180 @@
+use domain::correlation::{Adjustment, PValue};
+
+fn p_values(values: &[f64]) -> Vec<PValue> {
+    values
+        .iter()
+        .map(|value| PValue::new(*value).unwrap())
+        .collect()
+}
+
+#[test]
+fn the_step_up_procedure_keeps_everything_below_the_largest_passing_rank() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    let held = adjustment.holds_up(&p_values(&[0.001, 0.008, 0.039, 0.041, 0.42]));
+
+    assert_eq!(held, [true, true, true, true, false]);
+}
+
+#[test]
+fn a_result_below_its_own_threshold_is_carried_by_a_stronger_one() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    let held = adjustment.holds_up(&p_values(&[0.001, 0.079]));
+
+    assert_eq!(
+        held,
+        [true, true],
+        "0.079 exceeds rank 1's threshold but rank 2 passes, so both hold"
+    );
+}
+
+#[test]
+fn order_of_the_set_does_not_change_who_holds_up() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    let held = adjustment.holds_up(&p_values(&[0.42, 0.041, 0.001, 0.039, 0.008]));
+
+    assert_eq!(held, [false, true, true, true, true]);
+}
+
+#[test]
+fn nothing_holds_up_when_nothing_is_small_enough() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    let held = adjustment.holds_up(&p_values(&[0.4, 0.5, 0.6]));
+
+    assert_eq!(held, [false, false, false]);
+}
+
+#[test]
+fn a_larger_set_makes_each_result_work_harder() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    let alone = adjustment.holds_up(&p_values(&[0.04]));
+    let among_ten = adjustment.holds_up(&p_values(&[
+        0.04, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
+    ]));
+
+    assert_eq!(alone, [true]);
+    assert!(!among_ten[0], "0.04 needs to beat 0.01 once ten are tested");
+}
+
+#[test]
+fn the_threshold_is_whatever_it_is_configured_to_be() {
+    let strict = Adjustment::controlling_false_discovery_at(0.01);
+    let loose = Adjustment::controlling_false_discovery_at(0.20);
+
+    let borderline = p_values(&[0.03, 0.5]);
+
+    assert_eq!(strict.holds_up(&borderline), [false, false]);
+    assert_eq!(loose.holds_up(&borderline), [true, false]);
+}
+
+#[test]
+fn an_empty_set_holds_nothing_up_and_does_not_panic() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    assert!(adjustment.holds_up(&[]).is_empty());
+}
+
+use domain::correlation::{CorrelationStrategy, Family, Tested};
+
+fn tested(family: Family, strategy: CorrelationStrategy, p: f64) -> Tested {
+    Tested {
+        family,
+        strategy,
+        p_value: PValue::new(p).unwrap(),
+    }
+}
+
+fn measurement(p: f64) -> Tested {
+    tested(Family::Measurements, CorrelationStrategy::Spearman, p)
+}
+
+#[test]
+fn a_result_is_corrected_against_the_others_in_its_own_group() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    let held = adjustment.holds_up_across(&[measurement(0.04), measurement(0.5)]);
+
+    assert_eq!(held, [true, false]);
+}
+
+#[test]
+fn how_many_activities_are_kept_does_not_change_a_measurement_result() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    let mut entries = vec![measurement(0.04), measurement(0.5)];
+    for _ in 0..20 {
+        entries.push(tested(
+            Family::Activities,
+            CorrelationStrategy::MeanDifference,
+            0.5,
+        ));
+    }
+
+    let held = adjustment.holds_up_across(&entries);
+
+    assert!(
+        held[0],
+        "a measurement must not be corrected against activities"
+    );
+}
+
+#[test]
+fn measuring_the_same_thing_several_ways_is_not_several_hypotheses() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    let mut entries = vec![measurement(0.04), measurement(0.5)];
+    for other in [CorrelationStrategy::Pearson, CorrelationStrategy::Kendall] {
+        for _ in 0..10 {
+            entries.push(tested(Family::Measurements, other, 0.5));
+        }
+    }
+
+    let held = adjustment.holds_up_across(&entries);
+
+    assert!(
+        held[0],
+        "correcting across strategies would penalise measuring carefully"
+    );
+}
+
+#[test]
+fn more_of_the_same_question_does_make_a_result_work_harder() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    let mut entries = vec![measurement(0.04)];
+    for _ in 0..20 {
+        entries.push(measurement(0.5));
+    }
+
+    let held = adjustment.holds_up_across(&entries);
+
+    assert!(
+        !held[0],
+        "twenty more measurements under the same strategy is twenty more comparisons"
+    );
+}
+
+#[test]
+fn two_families_are_corrected_apart_even_under_one_strategy() {
+    let adjustment = Adjustment::controlling_false_discovery_at(0.10);
+
+    let mut entries = vec![measurement(0.04), measurement(0.5)];
+    for _ in 0..20 {
+        entries.push(tested(
+            Family::Activities,
+            CorrelationStrategy::Spearman,
+            0.5,
+        ));
+    }
+
+    let held = adjustment.holds_up_across(&entries);
+
+    assert!(
+        held[0],
+        "a Family is a question: activities never dilute a measurement, whichever strategy scored them"
+    );
+}
diff --git a/crates/domain/tests/correlation/moon_phase_test.rs b/crates/domain/tests/correlation/moon_phase_test.rs
new file mode 100644
index 0000000..c7ece4e
--- /dev/null
+++ b/crates/domain/tests/correlation/moon_phase_test.rs
@@ -0,0 +1,58 @@
+use domain::entry::Date;
+use domain::moon::MoonPhase;
+
+fn on(day: &str) -> MoonPhase {
+    MoonPhase::on(&Date::from_persistence(day.parse().unwrap()))
+}
+
+#[test]
+fn a_total_solar_eclipse_happens_at_a_new_moon() {
+    for day in ["2017-08-21", "2024-04-08"] {
+        let illumination = on(day).illumination();
+
+        assert!(
+            illumination < 0.02,
+            "{day} should be dark, got {illumination}"
+        );
+    }
+}
+
+#[test]
+fn a_total_lunar_eclipse_happens_at_a_full_moon() {
+    for day in ["2000-01-21", "2018-01-31", "2019-01-21", "2022-05-16"] {
+        let illumination = on(day).illumination();
+
+        assert!(
+            illumination > 0.98,
+            "{day} should be full, got {illumination}"
+        );
+    }
+}
+
+#[test]
+fn illumination_never_leaves_its_bounds() {
+    let mut day = Date::from_persistence("2024-01-01".parse().unwrap());
+
+    for _ in 0..800 {
+        let illumination = MoonPhase::on(&day).illumination();
+        assert!((0.0..=1.0).contains(&illumination), "got {illumination}");
+        day = day.next();
+    }
+}
+
+#[test]
+fn the_same_illumination_is_told_apart_by_waxing_and_waning() {
+    let waxing = on("2024-04-15");
+    let waning = on("2024-04-30");
+
+    assert!((waxing.illumination() - 0.5).abs() < 0.15);
+    assert!((waning.illumination() - 0.5).abs() < 0.15);
+    assert_eq!(waxing.name(), "First Quarter");
+    assert_eq!(waning.name(), "Last Quarter");
+}
+
+#[test]
+fn the_extremes_are_named_for_what_they_are() {
+    assert_eq!(on("2024-04-08").name(), "New");
+    assert_eq!(on("2022-05-16").name(), "Full");
+}
diff --git a/crates/domain/tests/correlation/significance_test.rs b/crates/domain/tests/correlation/significance_test.rs
new file mode 100644
index 0000000..4f43a5a
--- /dev/null
+++ b/crates/domain/tests/correlation/significance_test.rs
@@ -0,0 +1,107 @@
+use domain::correlation::{CorrelationStrategy, Observation, PValue};
+use domain::entry::{DayMood, Mood};
+
+fn day(mood: Mood) -> DayMood {
+    DayMood::of(&[mood]).unwrap()
+}
+
+fn mood_of(value: u8) -> Mood {
+    Mood::try_from(value).unwrap()
+}
+
+fn loosely_rising() -> Vec<Observation> {
+    let moods = [3, 1, 4, 2, 3, 5, 2, 4, 3, 5, 4, 3];
+
+    moods
+        .iter()
+        .enumerate()
+        .map(|(index, mood)| Observation::new(index as f64 + 1.0, day(mood_of(*mood))))
+        .collect()
+}
+
+fn significance(strategy: CorrelationStrategy, observations: &[Observation]) -> f64 {
+    strategy
+        .significance(observations)
+        .expect("a scored series has a p-value")
+        .value()
+}
+
+#[test]
+fn the_familiar_thresholds_come_out_of_the_normal_tail() {
+    assert!((PValue::from_standard_score(1.96).value() - 0.05).abs() < 1e-4);
+    assert!((PValue::from_standard_score(1.645).value() - 0.10).abs() < 1e-4);
+}
+
+#[test]
+fn a_standard_score_of_nothing_is_certain_to_be_nothing() {
+    assert!((PValue::from_standard_score(0.0).value() - 1.0).abs() < 1e-9);
+}
+
+#[test]
+fn direction_does_not_change_how_surprising_a_score_is() {
+    let positive = PValue::from_standard_score(2.5).value();
+    let negative = PValue::from_standard_score(-2.5).value();
+
+    assert!((positive - negative).abs() < 1e-12);
+}
+
+#[test]
+fn each_strategy_turns_its_own_statistic_into_a_p_value() {
+    let observations = loosely_rising();
+
+    let pearson = significance(CorrelationStrategy::Pearson, &observations);
+    let spearman = significance(CorrelationStrategy::Spearman, &observations);
+    let kendall = significance(CorrelationStrategy::Kendall, &observations);
+
+    assert!((pearson - 0.198_050_956_8).abs() < 1e-4, "got {pearson}");
+    assert!((spearman - 0.241_732_162_6).abs() < 1e-4, "got {spearman}");
+    assert!((kendall - 0.201_603_352_7).abs() < 1e-4, "got {kendall}");
+}
+
+#[test]
+fn a_relationship_that_holds_all_the_way_is_hard_to_put_down_to_chance() {
+    let tight: Vec<Observation> = (1..=12)
+        .map(|day_number| {
+            let mood = mood_of(((day_number - 1) / 3 + 1) as u8);
+            Observation::new(day_number as f64, day(mood))
+        })
+        .collect();
+
+    assert!(significance(CorrelationStrategy::Pearson, &tight) < 0.001);
+    assert!(significance(CorrelationStrategy::Spearman, &tight) < 0.001);
+    assert!(significance(CorrelationStrategy::Kendall, &tight) < 0.001);
+}
+
+#[test]
+fn a_mean_difference_is_judged_by_the_spread_within_each_group() {
+    let observations: Vec<Observation> = [
+        (1.0, Mood::Good),
+        (1.0, Mood::Rad),
+        (1.0, Mood::Good),
+        (1.0, Mood::Rad),
+        (0.0, Mood::Bad),
+        (0.0, Mood::Meh),
+        (0.0, Mood::Bad),
+        (0.0, Mood::Awful),
+    ]
+    .into_iter()
+    .map(|(value, mood)| Observation::new(value, day(mood)))
+    .collect();
+
+    let p = significance(CorrelationStrategy::MeanDifference, &observations);
+
+    assert!((p - 0.000_000_573_3).abs() < 1e-9, "got {p}");
+}
+
+#[test]
+fn a_series_that_cannot_be_scored_has_nothing_to_report() {
+    let unvarying: Vec<Observation> = (1..=10)
+        .map(|day_number| Observation::new(day_number as f64, day(Mood::Meh)))
+        .collect();
+
+    assert!(
+        CorrelationStrategy::Spearman
+            .significance(&unvarying)
+            .is_none()
+    );
+}
diff --git a/crates/domain/tests/correlation/spearman_test.rs b/crates/domain/tests/correlation/spearman_test.rs
new file mode 100644
index 0000000..480153c
--- /dev/null
+++ b/crates/domain/tests/correlation/spearman_test.rs
@@ -0,0 +1,117 @@
+use domain::correlation::{CorrelationStrategy, Observation};
+use domain::entry::{DayMood, Mood};
+
+fn day(mood: Mood) -> DayMood {
+    DayMood::of(&[mood]).unwrap()
+}
+
+fn observations(pairs: &[(f64, Mood)]) -> Vec<Observation> {
+    pairs
+        .iter()
+        .map(|(value, mood)| Observation::new(*value, day(*mood)))
+        .collect()
+}
+
+fn spearman(pairs: &[(f64, Mood)]) -> Option<f64> {
+    CorrelationStrategy::Spearman
+        .score(&observations(pairs))
+        .map(|coefficient| coefficient.value())
+}
+
+#[test]
+fn a_perfectly_ordered_pair_of_series_scores_one() {
+    let score = spearman(&[
+        (1.0, Mood::Awful),
+        (2.0, Mood::Bad),
+        (3.0, Mood::Meh),
+        (4.0, Mood::Good),
+    ])
+    .unwrap();
+
+    assert!((score - 1.0).abs() < 1e-12);
+}
+
+#[test]
+fn a_perfectly_inverted_pair_of_series_scores_minus_one() {
+    let score = spearman(&[
+        (1.0, Mood::Rad),
+        (2.0, Mood::Good),
+        (3.0, Mood::Meh),
+        (4.0, Mood::Bad),
+    ])
+    .unwrap();
+
+    assert!((score + 1.0).abs() < 1e-12);
+}
+
+#[test]
+fn only_the_order_matters_not_the_distance() {
+    let gentle = spearman(&[
+        (1.0, Mood::Awful),
+        (2.0, Mood::Bad),
+        (3.0, Mood::Meh),
+        (4.0, Mood::Good),
+    ])
+    .unwrap();
+
+    let one_enormous_day = spearman(&[
+        (1.0, Mood::Awful),
+        (2.0, Mood::Bad),
+        (3.0, Mood::Meh),
+        (100_000.0, Mood::Good),
+    ])
+    .unwrap();
+
+    assert!((gentle - one_enormous_day).abs() < f64::EPSILON);
+}
+
+#[test]
+fn tied_moods_share_their_average_rank_rather_than_taking_the_shortcut() {
+    let score = spearman(&[
+        (1_000.0, Mood::Meh),
+        (2_000.0, Mood::Meh),
+        (3_000.0, Mood::Meh),
+        (4_000.0, Mood::Good),
+        (5_000.0, Mood::Good),
+        (6_000.0, Mood::Rad),
+    ])
+    .unwrap();
+
+    let tie_corrected = 0.925_820_099_8;
+    let textbook_shortcut = 0.928_571_428_6;
+
+    assert!(
+        (score - tie_corrected).abs() < 1e-9,
+        "expected the tie-corrected coefficient, got {score}"
+    );
+    assert!(
+        (score - textbook_shortcut).abs() > 1e-9,
+        "this is the 6*d^2 shortcut, which is wrong when ranks are tied"
+    );
+}
+
+#[test]
+fn a_day_count_below_two_scores_nothing() {
+    assert!(spearman(&[(1.0, Mood::Good)]).is_none());
+    assert!(spearman(&[]).is_none());
+}
+
+#[test]
+fn an_unvarying_series_scores_nothing() {
+    let same_mood_every_day = spearman(&[
+        (1.0, Mood::Meh),
+        (2.0, Mood::Meh),
+        (3.0, Mood::Meh),
+        (4.0, Mood::Meh),
+    ]);
+
+    let same_value_every_day = spearman(&[
+        (5_000.0, Mood::Awful),
+        (5_000.0, Mood::Bad),
+        (5_000.0, Mood::Good),
+        (5_000.0, Mood::Rad),
+    ]);
+
+    assert!(same_mood_every_day.is_none());
+    assert!(same_value_every_day.is_none());
+}
diff --git a/crates/domain/tests/correlation/strategy_test.rs b/crates/domain/tests/correlation/strategy_test.rs
new file mode 100644
index 0000000..f8f4bb5
--- /dev/null
+++ b/crates/domain/tests/correlation/strategy_test.rs
@@ -0,0 +1,180 @@
+use domain::activity::ActivityId;
+use domain::correlation::{CorrelationInput, CorrelationStrategy, Observation, SeriesShape};
+use domain::entry::{DayMood, Mood};
+use domain::metric::MetricKind;
+
+fn day(mood: Mood) -> DayMood {
+    DayMood::of(&[mood]).unwrap()
+}
+
+fn observations(pairs: &[(f64, Mood)]) -> Vec<Observation> {
+    pairs
+        .iter()
+        .map(|(value, mood)| Observation::new(*value, day(*mood)))
+        .collect()
+}
+
+fn score(strategy: CorrelationStrategy, pairs: &[(f64, Mood)]) -> Option<f64> {
+    strategy
+        .score(&observations(pairs))
+        .map(|coefficient| coefficient.value())
+}
+
+const TIED: [(f64, Mood); 6] = [
+    (1_000.0, Mood::Meh),
+    (2_000.0, Mood::Meh),
+    (3_000.0, Mood::Meh),
+    (4_000.0, Mood::Good),
+    (5_000.0, Mood::Good),
+    (6_000.0, Mood::Rad),
+];
+
+#[test]
+fn kendall_corrects_for_ties_rather_than_counting_pairs_alone() {
+    let score = score(CorrelationStrategy::Kendall, &TIED).unwrap();
+
+    let tau_b = 0.856_348_838_6;
+    let tau_a = 0.733_333_333_3;
+
+    assert!((score - tau_b).abs() < 1e-9, "expected tau-b, got {score}");
+    assert!(
+        (score - tau_a).abs() > 1e-9,
+        "this is tau-a, which overstates disagreement when ranks are tied"
+    );
+}
+
+#[test]
+fn kendall_reaches_both_extremes() {
+    let rising = score(
+        CorrelationStrategy::Kendall,
+        &[
+            (1.0, Mood::Awful),
+            (2.0, Mood::Bad),
+            (3.0, Mood::Meh),
+            (4.0, Mood::Good),
+        ],
+    )
+    .unwrap();
+
+    let falling = score(
+        CorrelationStrategy::Kendall,
+        &[
+            (1.0, Mood::Good),
+            (2.0, Mood::Meh),
+            (3.0, Mood::Bad),
+            (4.0, Mood::Awful),
+        ],
+    )
+    .unwrap();
+
+    assert!((rising - 1.0).abs() < 1e-12);
+    assert!((falling + 1.0).abs() < 1e-12);
+}
+
+#[test]
+fn pearson_measures_the_line_where_the_rank_methods_measure_the_order() {
+    let curved = [
+        (1.0, Mood::Awful),
+        (2.0, Mood::Bad),
+        (3.0, Mood::Meh),
+        (100.0, Mood::Good),
+    ];
+
+    let pearson = score(CorrelationStrategy::Pearson, &curved).unwrap();
+    let spearman = score(CorrelationStrategy::Spearman, &curved).unwrap();
+
+    assert!((spearman - 1.0).abs() < 1e-12, "the order is perfect");
+    assert!(
+        (pearson - 0.785_026_421).abs() < 1e-9,
+        "the line is not, got {pearson}"
+    );
+}
+
+#[test]
+fn a_mean_difference_is_told_as_a_share_of_the_mood_scale() {
+    let score = score(
+        CorrelationStrategy::MeanDifference,
+        &[
+            (1.0, Mood::Good),
+            (1.0, Mood::Rad),
+            (1.0, Mood::Good),
+            (1.0, Mood::Rad),
+            (0.0, Mood::Bad),
+            (0.0, Mood::Meh),
+            (0.0, Mood::Bad),
+            (0.0, Mood::Awful),
+        ],
+    )
+    .unwrap();
+
+    assert!(
+        (score - 0.625).abs() < 1e-12,
+        "two and a half mood points out of four, got {score}"
+    );
+}
+
+#[test]
+fn a_mean_difference_needs_days_on_both_sides() {
+    let only_present = score(
+        CorrelationStrategy::MeanDifference,
+        &[(1.0, Mood::Good), (1.0, Mood::Rad)],
+    );
+
+    let only_absent = score(
+        CorrelationStrategy::MeanDifference,
+        &[(0.0, Mood::Good), (0.0, Mood::Rad)],
+    );
+
+    assert!(only_present.is_none());
+    assert!(only_absent.is_none());
+}
+
+#[test]
+fn a_strategy_scores_one_shape_of_series_and_an_input_has_one() {
+    assert_eq!(
+        CorrelationStrategy::MeanDifference.scores(),
+        SeriesShape::Presence
+    );
+    assert_eq!(
+        CorrelationInput::Activity(ActivityId::generate()).series(),
+        SeriesShape::Presence
+    );
+
+    for continuous in [
+        CorrelationStrategy::Pearson,
+        CorrelationStrategy::Spearman,
+        CorrelationStrategy::Kendall,
+    ] {
+        assert_eq!(continuous.scores(), SeriesShape::Continuous);
+    }
+
+    assert_eq!(
+        CorrelationInput::Metric(MetricKind::Steps).series(),
+        SeriesShape::Continuous
+    );
+    assert_eq!(
+        CorrelationInput::MoonPhase.series(),
+        SeriesShape::Continuous
+    );
+}
+
+#[test]
+fn only_matching_strategies_are_offered_for_an_input() {
+    let steps = CorrelationInput::Metric(MetricKind::Steps);
+    let exercise = CorrelationInput::Activity(ActivityId::generate());
+
+    let for_steps: Vec<&str> = CorrelationStrategy::ALL
+        .into_iter()
+        .filter(|strategy| strategy.can_score(&steps))
+        .map(|strategy| strategy.name())
+        .collect();
+
+    let for_exercise: Vec<&str> = CorrelationStrategy::ALL
+        .into_iter()
+        .filter(|strategy| strategy.can_score(&exercise))
+        .map(|strategy| strategy.name())
+        .collect();
+
+    assert_eq!(for_steps, ["pearson", "spearman", "kendall"]);
+    assert_eq!(for_exercise, ["meanDifference"]);
+}
diff --git a/crates/domain/tests/cycle.rs b/crates/domain/tests/cycle.rs
new file mode 100644
index 0000000..d436508
--- /dev/null
+++ b/crates/domain/tests/cycle.rs
@@ -0,0 +1,2 @@
+#[path = "cycle/cycle_calendar_test.rs"]
+mod cycle_calendar_test;
diff --git a/crates/domain/tests/cycle/cycle_calendar_test.rs b/crates/domain/tests/cycle/cycle_calendar_test.rs
new file mode 100644
index 0000000..83e580e
--- /dev/null
+++ b/crates/domain/tests/cycle/cycle_calendar_test.rs
@@ -0,0 +1,139 @@
+use domain::cycle::CycleCalendar;
+use domain::entry::Date;
+
+fn on(day: &str) -> Date {
+    Date::from_persistence(day.parse().unwrap())
+}
+
+fn calendar(starts: &[&str]) -> CycleCalendar {
+    CycleCalendar::new(starts.iter().map(|day| on(day)).collect())
+}
+
+#[test]
+fn the_day_a_cycle_starts_is_its_first_day() {
+    let position = calendar(&["2026-01-01"])
+        .position_on(&on("2026-01-01"))
+        .unwrap();
+
+    assert_eq!(position.day().value(), 1);
+    assert!(position.progress().abs() < f64::EPSILON);
+}
+
+#[test]
+fn a_date_before_anything_was_recorded_has_no_place_in_a_cycle() {
+    assert!(
+        calendar(&["2026-02-01"])
+            .position_on(&on("2026-01-15"))
+            .is_none()
+    );
+}
+
+#[test]
+fn nothing_recorded_at_all_means_nothing_derived() {
+    assert!(calendar(&[]).position_on(&on("2026-01-15")).is_none());
+}
+
+#[test]
+fn a_closed_cycle_is_measured_by_its_own_length() {
+    let starts = calendar(&["2026-01-01", "2026-01-25"]);
+
+    let halfway = starts.position_on(&on("2026-01-13")).unwrap();
+
+    assert_eq!(halfway.day().value(), 13);
+    assert!(
+        (halfway.progress() - 0.5).abs() < 1e-12,
+        "twelve days into a twenty-four day cycle, got {}",
+        halfway.progress()
+    );
+}
+
+#[test]
+fn the_cycle_still_running_is_measured_against_the_usual_length() {
+    let starts = calendar(&["2026-01-01", "2026-01-21", "2026-02-10", "2026-03-02"]);
+
+    let open = starts.position_on(&on("2026-03-12")).unwrap();
+
+    assert_eq!(open.day().value(), 11);
+    assert!(
+        (open.progress() - 0.5).abs() < 1e-12,
+        "ten days into a twenty-day cycle, got {}",
+        open.progress()
+    );
+}
+
+#[test]
+fn with_nothing_to_go_on_the_usual_length_is_assumed() {
+    let starts = calendar(&["2026-01-01"]);
+
+    let position = starts.position_on(&on("2026-01-15")).unwrap();
+
+    assert_eq!(position.day().value(), 15);
+    assert!(
+        (position.progress() - 0.5).abs() < 1e-12,
+        "fourteen days into an assumed twenty-eight day cycle, got {}",
+        position.progress()
+    );
+}
+
+#[test]
+fn correcting_the_start_moves_every_day_that_depended_on_it() {
+    let before = calendar(&["2026-01-01"])
+        .position_on(&on("2026-01-10"))
+        .unwrap();
+    let after = calendar(&["2026-01-03"])
+        .position_on(&on("2026-01-10"))
+        .unwrap();
+
+    assert_eq!(before.day().value(), 10);
+    assert_eq!(after.day().value(), 8);
+}
+
+#[test]
+fn a_gap_too_long_to_be_one_cycle_means_a_start_was_missed() {
+    let position = calendar(&["2026-01-01"]).position_on(&on("2026-06-01"));
+
+    assert!(
+        position.is_none(),
+        "a hundred and fifty days is a missing record, not a long cycle"
+    );
+}
+
+#[test]
+fn the_order_and_repetition_of_what_was_recorded_does_not_matter() {
+    let tidy = calendar(&["2026-01-01", "2026-01-25"]);
+    let messy = calendar(&["2026-01-25", "2026-01-01", "2026-01-25"]);
+
+    let from_tidy = tidy.position_on(&on("2026-01-13")).unwrap();
+    let from_messy = messy.position_on(&on("2026-01-13")).unwrap();
+
+    assert_eq!(from_tidy.day().value(), from_messy.day().value());
+    assert!((from_tidy.progress() - from_messy.progress()).abs() < f64::EPSILON);
+}
+
+#[test]
+fn the_last_day_of_a_cycle_has_run_its_whole_course() {
+    let starts = calendar(&["2026-01-01", "2026-01-29"]);
+
+    let last = starts.position_on(&on("2026-01-28")).unwrap();
+
+    assert_eq!(last.day().value(), 28);
+    assert!(
+        (last.progress() - 27.0 / 28.0).abs() < 1e-12,
+        "got {}",
+        last.progress()
+    );
+}
+
+#[test]
+fn progress_never_runs_past_the_end_of_a_cycle() {
+    let starts = calendar(&["2026-01-01", "2026-01-15", "2026-01-29"]);
+
+    let overdue = starts.position_on(&on("2026-02-28")).unwrap();
+
+    assert_eq!(overdue.day().value(), 31);
+    assert!(
+        (overdue.progress() - 1.0).abs() < f64::EPSILON,
+        "a late cycle sits at its end rather than beyond it, got {}",
+        overdue.progress()
+    );
+}
diff --git a/crates/domain/tests/dimension.rs b/crates/domain/tests/dimension.rs
new file mode 100644
index 0000000..47c0c00
--- /dev/null
+++ b/crates/domain/tests/dimension.rs
@@ -0,0 +1,2 @@
+#[path = "dimension/dimension_value_test.rs"]
+mod dimension_value_test;
diff --git a/crates/domain/tests/dimension/dimension_value_test.rs b/crates/domain/tests/dimension/dimension_value_test.rs
new file mode 100644
index 0000000..ad06d79
--- /dev/null
+++ b/crates/domain/tests/dimension/dimension_value_test.rs
@@ -0,0 +1,30 @@
+use domain::activity::ActivityId;
+use domain::dimension::{DimensionKind, DimensionValue};
+
+#[test]
+fn activities_are_deduplicated_and_sorted() {
+    let first = ActivityId::generate();
+    let second = ActivityId::generate();
+
+    let value = DimensionValue::activities(vec![second.clone(), first.clone(), second.clone()]);
+
+    let DimensionValue::Activities(ids) = value else {
+        panic!("expected an activities dimension");
+    };
+
+    assert_eq!(ids.len(), 2);
+    assert!(ids[0] <= ids[1]);
+}
+
+#[test]
+fn every_value_reports_its_own_kind() {
+    assert_eq!(
+        DimensionValue::activities(vec![]).kind(),
+        DimensionKind::Activities
+    );
+    assert_eq!(DimensionValue::Photos(vec![]).kind(), DimensionKind::Photos);
+    assert_eq!(
+        DimensionValue::VoiceMemos(vec![]).kind(),
+        DimensionKind::VoiceMemos
+    );
+}
diff --git a/crates/domain/tests/entry.rs b/crates/domain/tests/entry.rs
index 94dc309..91b998a 100644
--- a/crates/domain/tests/entry.rs
+++ b/crates/domain/tests/entry.rs
@@ -9,3 +9,9 @@ mod mood_entry_test;
 
 #[path = "entry/date_range_test.rs"]
 mod date_range_test;
+
+#[path = "entry/date_test.rs"]
+mod date_test;
+
+#[path = "entry/day_mood_test.rs"]
+mod day_mood_test;
diff --git a/crates/domain/tests/entry/date_test.rs b/crates/domain/tests/entry/date_test.rs
new file mode 100644
index 0000000..65c8235
--- /dev/null
+++ b/crates/domain/tests/entry/date_test.rs
@@ -0,0 +1,58 @@
+use chrono::{DateTime, FixedOffset};
+
+use domain::entry::Date;
+use domain::user::Timezone;
+
+fn instant(text: &str) -> DateTime<FixedOffset> {
+    text.parse().unwrap()
+}
+
+fn zone(name: &str) -> Timezone {
+    Timezone::new(name).unwrap()
+}
+
+#[test]
+fn an_instant_resolves_to_the_calendar_day_in_the_users_zone() {
+    let date = Date::from_instant(
+        &instant("2025-03-15T09:00:00+13:00"),
+        &zone("Pacific/Auckland"),
+    );
+
+    assert_eq!(date.value().to_string(), "2025-03-15");
+}
+
+#[test]
+fn the_users_zone_decides_the_day_not_the_offset_the_client_sent() {
+    let same_moment = instant("2025-03-15T23:00:00+00:00");
+
+    let in_auckland = Date::from_instant(&same_moment, &zone("Pacific/Auckland"));
+    let in_warsaw = Date::from_instant(&same_moment, &zone("Europe/Warsaw"));
+
+    assert_eq!(in_auckland.value().to_string(), "2025-03-16");
+    assert_eq!(in_warsaw.value().to_string(), "2025-03-16");
+}
+
+#[test]
+fn an_evening_in_a_far_eastern_zone_is_not_the_utc_day() {
+    let evening = instant("2025-03-14T20:00:00+00:00");
+
+    let date = Date::from_instant(&evening, &zone("Pacific/Auckland"));
+
+    assert_eq!(date.value().to_string(), "2025-03-15");
+}
+
+#[test]
+fn a_day_knows_the_day_before_it() {
+    let date = Date::from_instant(&instant("2025-03-01T12:00:00+00:00"), &zone("UTC"));
+
+    assert_eq!(date.previous().value().to_string(), "2025-02-28");
+}
+
+#[test]
+fn days_between_two_dates_is_their_gap() {
+    let earlier = Date::from_instant(&instant("2025-03-01T12:00:00+00:00"), &zone("UTC"));
+    let later = Date::from_instant(&instant("2025-03-05T12:00:00+00:00"), &zone("UTC"));
+
+    assert_eq!(later.days_since(&earlier), 4);
+    assert_eq!(earlier.days_since(&later), -4);
+}
diff --git a/crates/domain/tests/entry/day_mood_test.rs b/crates/domain/tests/entry/day_mood_test.rs
new file mode 100644
index 0000000..5685fdc
--- /dev/null
+++ b/crates/domain/tests/entry/day_mood_test.rs
@@ -0,0 +1,57 @@
+use domain::entry::{DayMood, Mood};
+
+#[test]
+fn a_day_of_one_awful_and_one_rad_sits_in_the_middle() {
+    let day = DayMood::of(&[Mood::Awful, Mood::Rad]).unwrap();
+
+    assert!((day.value() - 3.0).abs() < f64::EPSILON);
+    assert_eq!(day.rounded(), Mood::Meh);
+}
+
+#[test]
+fn a_day_with_no_entries_has_no_mood() {
+    assert!(DayMood::of(&[]).is_none());
+}
+
+#[test]
+fn one_bad_day_among_four_middling_ones_still_shows() {
+    let mostly_meh = DayMood::of(&[Mood::Meh, Mood::Meh, Mood::Meh, Mood::Meh, Mood::Awful])
+        .unwrap()
+        .value();
+    let all_meh = DayMood::of(&[Mood::Meh, Mood::Meh, Mood::Meh, Mood::Meh, Mood::Meh])
+        .unwrap()
+        .value();
+
+    assert!(mostly_meh < all_meh);
+}
+
+#[test]
+fn a_single_entry_is_the_whole_day() {
+    let day = DayMood::of(&[Mood::Bad]).unwrap();
+
+    assert!((day.value() - 2.0).abs() < f64::EPSILON);
+    assert_eq!(day.rounded(), Mood::Bad);
+}
+
+#[test]
+fn a_day_exactly_between_two_moods_shows_the_better_one() {
+    let day = DayMood::of(&[Mood::Meh, Mood::Good]).unwrap();
+
+    assert!((day.value() - 3.5).abs() < f64::EPSILON);
+    assert_eq!(day.rounded(), Mood::Good);
+}
+
+#[test]
+fn every_whole_mean_rounds_to_its_own_mood() {
+    let pairs = [
+        (Mood::Awful, Mood::Awful),
+        (Mood::Bad, Mood::Bad),
+        (Mood::Meh, Mood::Meh),
+        (Mood::Good, Mood::Good),
+        (Mood::Rad, Mood::Rad),
+    ];
+
+    for (logged, expected) in pairs {
+        assert_eq!(DayMood::of(&[logged, logged]).unwrap().rounded(), expected);
+    }
+}
diff --git a/crates/domain/tests/entry/mood_entry_test.rs b/crates/domain/tests/entry/mood_entry_test.rs
index b562723..5ced031 100644
--- a/crates/domain/tests/entry/mood_entry_test.rs
+++ b/crates/domain/tests/entry/mood_entry_test.rs
@@ -1,8 +1,6 @@
 use chrono::{FixedOffset, TimeZone, Utc};
 
-use domain::activity::ActivityId;
-use domain::attachment::{PhotoId, VoiceMemoId};
-use domain::entry::{Content, Mood, MoodEntry, MoodEntryData};
+use domain::entry::{Mood, MoodEntry, MoodEntryData};
 use domain::user::UserId;
 
 fn sample_logged_at() -> chrono::DateTime<FixedOffset> {
@@ -19,10 +17,6 @@ fn new_entry_has_required_fields() {
 
     assert_eq!(*entry.user_id(), user_id);
     assert_eq!(entry.mood(), Mood::Good);
-    assert!(entry.activities().is_empty());
-    assert!(entry.content().is_none());
-    assert!(entry.photos().is_empty());
-    assert!(entry.voice_memos().is_empty());
 }
 
 #[test]
@@ -36,39 +30,10 @@ fn update_mood_changes_value_and_touches_updated_at() {
     assert!(*entry.updated_at() >= before);
 }
 
-#[test]
-fn set_activities_deduplicates_and_sorts() {
-    let mut entry = MoodEntry::new(UserId::generate(), Mood::Meh, sample_logged_at());
-    let a = ActivityId::generate();
-    let b = ActivityId::generate();
-
-    entry.set_activities(vec![b.clone(), a.clone(), b.clone()]);
-
-    assert_eq!(entry.activities().len(), 2);
-    let ids = entry.activities();
-    assert!(ids[0] <= ids[1]);
-}
-
-#[test]
-fn set_content_updates_and_clears() {
-    let mut entry = MoodEntry::new(UserId::generate(), Mood::Good, sample_logged_at());
-
-    let content = Content::new("great day").unwrap();
-    entry.set_content(Some(content));
-    assert!(entry.content().is_some());
-
-    entry.set_content(None);
-    assert!(entry.content().is_none());
-}
-
 #[test]
 fn from_persistence_reconstructs_all_fields() {
     let id = domain::entry::MoodEntryId::generate();
     let user_id = UserId::generate();
-    let activity_id = ActivityId::generate();
-    let photo_id = PhotoId::generate();
-    let voice_memo_id = VoiceMemoId::generate();
-    let content = Content::new("test").unwrap();
     let now = Utc::now();
 
     let entry = MoodEntry::from_persistence(MoodEntryData {
@@ -76,10 +41,6 @@ fn from_persistence_reconstructs_all_fields() {
         user_id: user_id.clone(),
         mood: Mood::Bad,
         logged_at: sample_logged_at(),
-        activities: vec![activity_id.clone()],
-        content: Some(content),
-        photos: vec![photo_id.clone()],
-        voice_memos: vec![voice_memo_id.clone()],
         created_at: now,
         updated_at: now,
     });
@@ -87,10 +48,7 @@ fn from_persistence_reconstructs_all_fields() {
     assert_eq!(*entry.id(), id);
     assert_eq!(*entry.user_id(), user_id);
     assert_eq!(entry.mood(), Mood::Bad);
-    assert_eq!(entry.activities().len(), 1);
-    assert!(entry.content().is_some());
-    assert_eq!(entry.photos().len(), 1);
-    assert_eq!(entry.voice_memos().len(), 1);
+    assert_eq!(*entry.logged_at(), sample_logged_at());
 }
 
 #[test]
@@ -105,32 +63,3 @@ fn update_logged_at_changes_timestamp() {
 
     assert_eq!(*entry.logged_at(), new_time);
 }
-
-#[test]
-fn set_photos_replaces_list() {
-    let mut entry = MoodEntry::new(UserId::generate(), Mood::Good, sample_logged_at());
-
-    let p1 = PhotoId::generate();
-    let p2 = PhotoId::generate();
-    entry.set_photos(vec![p1.clone(), p2.clone()]);
-    assert_eq!(entry.photos().len(), 2);
-
-    entry.set_photos(vec![p1.clone()]);
-    assert_eq!(entry.photos().len(), 1);
-
-    entry.set_photos(vec![]);
-    assert!(entry.photos().is_empty());
-}
-
-#[test]
-fn set_voice_memos_replaces_list() {
-    let mut entry = MoodEntry::new(UserId::generate(), Mood::Good, sample_logged_at());
-
-    let m1 = VoiceMemoId::generate();
-    let m2 = VoiceMemoId::generate();
-    entry.set_voice_memos(vec![m1.clone(), m2.clone()]);
-    assert_eq!(entry.voice_memos().len(), 2);
-
-    entry.set_voice_memos(vec![]);
-    assert!(entry.voice_memos().is_empty());
-}
diff --git a/crates/domain/tests/job.rs b/crates/domain/tests/job.rs
new file mode 100644
index 0000000..54c8e37
--- /dev/null
+++ b/crates/domain/tests/job.rs
@@ -0,0 +1,2 @@
+#[path = "job/job_test.rs"]
+mod job_test;
diff --git a/crates/domain/tests/job/job_test.rs b/crates/domain/tests/job/job_test.rs
new file mode 100644
index 0000000..b4105d5
--- /dev/null
+++ b/crates/domain/tests/job/job_test.rs
@@ -0,0 +1,75 @@
+use domain::entry::MoodEntryId;
+use domain::job::{Job, JobKind, JobStatus, JobSubject};
+
+fn a_job() -> Job {
+    Job::pending(
+        JobKind::BackfillRecordingIdentity,
+        JobSubject::Entry(MoodEntryId::generate()),
+    )
+}
+
+#[test]
+fn a_new_job_is_waiting_and_has_never_been_tried() {
+    let job = a_job();
+
+    assert_eq!(job.status(), JobStatus::Pending);
+    assert_eq!(job.attempts(), 0);
+    assert!(job.last_error().is_none());
+}
+
+#[test]
+fn a_job_with_attempts_left_is_worth_trying_again() {
+    let mut job = a_job();
+
+    job.attempted();
+
+    assert_eq!(job.attempts(), 1);
+    assert!(job.is_worth_another_attempt(3));
+}
+
+#[test]
+fn a_job_that_has_used_every_attempt_is_not_tried_again() {
+    let mut job = a_job();
+
+    for _ in 0..3 {
+        job.attempted();
+    }
+
+    assert_eq!(job.attempts(), 3);
+    assert!(!job.is_worth_another_attempt(3));
+}
+
+#[test]
+fn every_status_survives_a_round_trip_through_its_name() {
+    for status in [JobStatus::Pending, JobStatus::Running, JobStatus::Exhausted] {
+        assert_eq!(JobStatus::from_name(status.name()), Some(status));
+    }
+
+    assert_eq!(JobStatus::from_name("halfway"), None);
+}
+
+#[test]
+fn every_kind_survives_a_round_trip_through_its_name() {
+    for kind in JobKind::ALL {
+        assert_eq!(JobKind::from_name(kind.name()), Some(kind));
+    }
+
+    assert_eq!(JobKind::from_name("summon-rain"), None);
+}
+
+#[test]
+fn a_subject_names_the_thing_the_work_is_about() {
+    let entry_id = MoodEntryId::generate();
+    let subject = JobSubject::Entry(entry_id.clone());
+
+    assert_eq!(subject.key(), entry_id.value().to_string());
+    assert_eq!(
+        JobSubject::from_key(subject.key().as_str()),
+        Some(JobSubject::Entry(entry_id))
+    );
+}
+
+#[test]
+fn a_subject_that_is_not_an_identity_names_nothing() {
+    assert!(JobSubject::from_key("not-a-uuid").is_none());
+}
diff --git a/crates/domain/tests/location.rs b/crates/domain/tests/location.rs
new file mode 100644
index 0000000..87ac16c
--- /dev/null
+++ b/crates/domain/tests/location.rs
@@ -0,0 +1,2 @@
+#[path = "location/coordinates_test.rs"]
+mod coordinates_test;
diff --git a/crates/domain/tests/location/coordinates_test.rs b/crates/domain/tests/location/coordinates_test.rs
new file mode 100644
index 0000000..4045d59
--- /dev/null
+++ b/crates/domain/tests/location/coordinates_test.rs
@@ -0,0 +1,35 @@
+use domain::location::{Coordinates, Latitude, Longitude};
+
+#[test]
+fn coordinates_are_built_from_valid_bounds() {
+    let coordinates = Coordinates::new(52.2297, 21.0122).unwrap();
+
+    assert!((coordinates.latitude().value() - 52.2297).abs() < f64::EPSILON);
+    assert!((coordinates.longitude().value() - 21.0122).abs() < f64::EPSILON);
+}
+
+#[test]
+fn the_poles_and_the_antimeridian_are_valid() {
+    assert!(Latitude::new(90.0).is_ok());
+    assert!(Latitude::new(-90.0).is_ok());
+    assert!(Longitude::new(180.0).is_ok());
+    assert!(Longitude::new(-180.0).is_ok());
+}
+
+#[test]
+fn a_latitude_beyond_the_poles_is_rejected() {
+    assert!(Latitude::new(90.1).is_err());
+    assert!(Latitude::new(-90.1).is_err());
+}
+
+#[test]
+fn a_longitude_beyond_the_antimeridian_is_rejected() {
+    assert!(Longitude::new(180.1).is_err());
+    assert!(Longitude::new(-180.1).is_err());
+}
+
+#[test]
+fn a_coordinate_that_is_not_a_number_is_rejected() {
+    assert!(Latitude::new(f64::NAN).is_err());
+    assert!(Longitude::new(f64::INFINITY).is_err());
+}
diff --git a/crates/domain/tests/metric.rs b/crates/domain/tests/metric.rs
new file mode 100644
index 0000000..5d95cbb
--- /dev/null
+++ b/crates/domain/tests/metric.rs
@@ -0,0 +1,32 @@
+#[path = "metric/steps_test.rs"]
+mod steps_test;
+
+#[path = "metric/metric_value_test.rs"]
+mod metric_value_test;
+
+#[path = "metric/daily_metric_test.rs"]
+mod daily_metric_test;
+
+#[path = "metric/sleep_minutes_test.rs"]
+mod sleep_minutes_test;
+
+#[path = "metric/awake_minutes_test.rs"]
+mod awake_minutes_test;
+
+#[path = "metric/resting_heart_rate_test.rs"]
+mod resting_heart_rate_test;
+
+#[path = "metric/hrv_test.rs"]
+mod hrv_test;
+
+#[path = "metric/exercise_minutes_test.rs"]
+mod exercise_minutes_test;
+
+#[path = "metric/screen_time_minutes_test.rs"]
+mod screen_time_minutes_test;
+
+#[path = "metric/alcoholic_drinks_test.rs"]
+mod alcoholic_drinks_test;
+
+#[path = "metric/metric_kind_test.rs"]
+mod metric_kind_test;
diff --git a/crates/domain/tests/metric/alcoholic_drinks_test.rs b/crates/domain/tests/metric/alcoholic_drinks_test.rs
new file mode 100644
index 0000000..a0cfb7c
--- /dev/null
+++ b/crates/domain/tests/metric/alcoholic_drinks_test.rs
@@ -0,0 +1,12 @@
+use domain::metric::AlcoholicDrinks;
+
+#[test]
+fn a_count_of_drinks_no_one_survives_is_rejected() {
+    assert!(AlcoholicDrinks::new(61).is_err());
+}
+
+#[test]
+fn the_boundaries_of_a_days_drinking_are_valid() {
+    assert_eq!(AlcoholicDrinks::new(0).unwrap().value(), 0);
+    assert_eq!(AlcoholicDrinks::new(60).unwrap().value(), 60);
+}
diff --git a/crates/domain/tests/metric/awake_minutes_test.rs b/crates/domain/tests/metric/awake_minutes_test.rs
new file mode 100644
index 0000000..f0172f1
--- /dev/null
+++ b/crates/domain/tests/metric/awake_minutes_test.rs
@@ -0,0 +1,12 @@
+use domain::metric::AwakeMinutes;
+
+#[test]
+fn more_awake_minutes_than_a_day_holds_are_rejected() {
+    assert!(AwakeMinutes::new(1_441).is_err());
+}
+
+#[test]
+fn the_boundaries_of_time_spent_awake_are_valid() {
+    assert_eq!(AwakeMinutes::new(0).unwrap().value(), 0);
+    assert_eq!(AwakeMinutes::new(1_440).unwrap().value(), 1_440);
+}
diff --git a/crates/domain/tests/metric/daily_metric_test.rs b/crates/domain/tests/metric/daily_metric_test.rs
new file mode 100644
index 0000000..daad93f
--- /dev/null
+++ b/crates/domain/tests/metric/daily_metric_test.rs
@@ -0,0 +1,53 @@
+use domain::entry::Date;
+use domain::metric::{DailyMetric, MetricValue, Source, Steps};
+use domain::provider::ProviderName;
+use domain::user::UserId;
+
+fn a_date() -> Date {
+    Date::from_persistence("2026-08-26".parse().unwrap())
+}
+
+fn steps(count: u32, source: Source) -> DailyMetric {
+    DailyMetric::new(
+        UserId::generate(),
+        a_date(),
+        MetricValue::Steps(Steps::new(count).unwrap()),
+        source,
+    )
+}
+
+fn a_provider() -> Source {
+    Source::Provider(ProviderName::new("healthkit").unwrap())
+}
+
+#[test]
+fn a_manual_count_supersedes_one_a_provider_reported() {
+    let manual = steps(8_412, Source::Manual);
+    let imported = steps(8_000, a_provider());
+
+    assert!(manual.supersedes(&imported));
+}
+
+#[test]
+fn a_provider_does_not_overwrite_a_count_the_user_stated() {
+    let manual = steps(8_412, Source::Manual);
+    let imported = steps(8_000, a_provider());
+
+    assert!(!imported.supersedes(&manual));
+}
+
+#[test]
+fn a_later_import_replaces_an_earlier_one() {
+    let earlier = steps(8_000, a_provider());
+    let later = steps(8_412, a_provider());
+
+    assert!(later.supersedes(&earlier));
+}
+
+#[test]
+fn a_correction_replaces_the_count_the_user_stated_before() {
+    let stated = steps(8_000, Source::Manual);
+    let corrected = steps(8_412, Source::Manual);
+
+    assert!(corrected.supersedes(&stated));
+}
diff --git a/crates/domain/tests/metric/exercise_minutes_test.rs b/crates/domain/tests/metric/exercise_minutes_test.rs
new file mode 100644
index 0000000..2940ba1
--- /dev/null
+++ b/crates/domain/tests/metric/exercise_minutes_test.rs
@@ -0,0 +1,12 @@
+use domain::metric::ExerciseMinutes;
+
+#[test]
+fn more_exercise_than_a_day_holds_is_rejected() {
+    assert!(ExerciseMinutes::new(1_441).is_err());
+}
+
+#[test]
+fn the_boundaries_of_a_days_exercise_are_valid() {
+    assert_eq!(ExerciseMinutes::new(0).unwrap().value(), 0);
+    assert_eq!(ExerciseMinutes::new(1_440).unwrap().value(), 1_440);
+}
diff --git a/crates/domain/tests/metric/hrv_test.rs b/crates/domain/tests/metric/hrv_test.rs
new file mode 100644
index 0000000..faf6003
--- /dev/null
+++ b/crates/domain/tests/metric/hrv_test.rs
@@ -0,0 +1,17 @@
+use domain::metric::Hrv;
+
+#[test]
+fn a_variability_of_zero_is_rejected() {
+    assert!(Hrv::new(0).is_err());
+}
+
+#[test]
+fn a_variability_beyond_any_recorded_reading_is_rejected() {
+    assert!(Hrv::new(301).is_err());
+}
+
+#[test]
+fn the_boundaries_of_variability_are_valid() {
+    assert_eq!(Hrv::new(1).unwrap().value(), 1);
+    assert_eq!(Hrv::new(300).unwrap().value(), 300);
+}
diff --git a/crates/domain/tests/metric/metric_kind_test.rs b/crates/domain/tests/metric/metric_kind_test.rs
new file mode 100644
index 0000000..3473f36
--- /dev/null
+++ b/crates/domain/tests/metric/metric_kind_test.rs
@@ -0,0 +1,45 @@
+use domain::metric::MetricKind;
+
+const EVERY_KIND: [MetricKind; 8] = [
+    MetricKind::Steps,
+    MetricKind::SleepMinutes,
+    MetricKind::AwakeMinutes,
+    MetricKind::RestingHeartRate,
+    MetricKind::Hrv,
+    MetricKind::ExerciseMinutes,
+    MetricKind::ScreenTimeMinutes,
+    MetricKind::AlcoholicDrinks,
+];
+
+fn wire_name(kind: MetricKind) -> &'static str {
+    match kind {
+        MetricKind::Steps => "steps",
+        MetricKind::SleepMinutes => "sleepMinutes",
+        MetricKind::AwakeMinutes => "awakeMinutes",
+        MetricKind::RestingHeartRate => "restingHeartRate",
+        MetricKind::Hrv => "hrv",
+        MetricKind::ExerciseMinutes => "exerciseMinutes",
+        MetricKind::ScreenTimeMinutes => "screenTimeMinutes",
+        MetricKind::AlcoholicDrinks => "alcoholicDrinks",
+    }
+}
+
+#[test]
+fn every_kind_keeps_the_name_clients_and_rows_already_use() {
+    for kind in EVERY_KIND {
+        assert_eq!(kind.name(), wire_name(kind));
+    }
+}
+
+#[test]
+fn every_name_resolves_back_to_its_kind() {
+    for kind in EVERY_KIND {
+        assert_eq!(MetricKind::from_name(kind.name()), Some(kind));
+    }
+}
+
+#[test]
+fn a_name_this_build_does_not_know_resolves_to_nothing() {
+    assert_eq!(MetricKind::from_name("telepathy"), None);
+    assert_eq!(MetricKind::from_name("caffeine"), None);
+}
diff --git a/crates/domain/tests/metric/metric_value_test.rs b/crates/domain/tests/metric/metric_value_test.rs
new file mode 100644
index 0000000..2a8d4a4
--- /dev/null
+++ b/crates/domain/tests/metric/metric_value_test.rs
@@ -0,0 +1,8 @@
+use domain::metric::{MetricKind, MetricValue, Steps};
+
+#[test]
+fn a_values_kind_is_derived_from_the_value_itself() {
+    let value = MetricValue::Steps(Steps::new(8_412).unwrap());
+
+    assert_eq!(value.kind(), MetricKind::Steps);
+}
diff --git a/crates/domain/tests/metric/resting_heart_rate_test.rs b/crates/domain/tests/metric/resting_heart_rate_test.rs
new file mode 100644
index 0000000..524f0fd
--- /dev/null
+++ b/crates/domain/tests/metric/resting_heart_rate_test.rs
@@ -0,0 +1,13 @@
+use domain::metric::RestingHeartRate;
+
+#[test]
+fn a_resting_rate_no_living_person_has_is_rejected() {
+    assert!(RestingHeartRate::new(24).is_err());
+    assert!(RestingHeartRate::new(121).is_err());
+}
+
+#[test]
+fn the_range_covers_athletes_and_the_unwell() {
+    assert_eq!(RestingHeartRate::new(25).unwrap().value(), 25);
+    assert_eq!(RestingHeartRate::new(120).unwrap().value(), 120);
+}
diff --git a/crates/domain/tests/metric/screen_time_minutes_test.rs b/crates/domain/tests/metric/screen_time_minutes_test.rs
new file mode 100644
index 0000000..20d255e
--- /dev/null
+++ b/crates/domain/tests/metric/screen_time_minutes_test.rs
@@ -0,0 +1,12 @@
+use domain::metric::ScreenTimeMinutes;
+
+#[test]
+fn more_screen_time_than_a_day_holds_is_rejected() {
+    assert!(ScreenTimeMinutes::new(1_441).is_err());
+}
+
+#[test]
+fn the_boundaries_of_a_days_screen_time_are_valid() {
+    assert_eq!(ScreenTimeMinutes::new(0).unwrap().value(), 0);
+    assert_eq!(ScreenTimeMinutes::new(1_440).unwrap().value(), 1_440);
+}
diff --git a/crates/domain/tests/metric/sleep_minutes_test.rs b/crates/domain/tests/metric/sleep_minutes_test.rs
new file mode 100644
index 0000000..e9538a7
--- /dev/null
+++ b/crates/domain/tests/metric/sleep_minutes_test.rs
@@ -0,0 +1,12 @@
+use domain::metric::SleepMinutes;
+
+#[test]
+fn a_night_longer_than_a_day_is_rejected() {
+    assert!(SleepMinutes::new(1_441).is_err());
+}
+
+#[test]
+fn the_boundaries_of_a_nights_sleep_are_valid() {
+    assert_eq!(SleepMinutes::new(0).unwrap().value(), 0);
+    assert_eq!(SleepMinutes::new(1_440).unwrap().value(), 1_440);
+}
diff --git a/crates/domain/tests/metric/steps_test.rs b/crates/domain/tests/metric/steps_test.rs
new file mode 100644
index 0000000..170545d
--- /dev/null
+++ b/crates/domain/tests/metric/steps_test.rs
@@ -0,0 +1,12 @@
+use domain::metric::Steps;
+
+#[test]
+fn a_step_count_beyond_a_days_maximum_is_rejected() {
+    assert!(Steps::new(200_001).is_err());
+}
+
+#[test]
+fn the_boundaries_of_a_days_step_count_are_valid() {
+    assert_eq!(Steps::new(0).unwrap().value(), 0);
+    assert_eq!(Steps::new(200_000).unwrap().value(), 200_000);
+}
diff --git a/crates/domain/tests/provider.rs b/crates/domain/tests/provider.rs
new file mode 100644
index 0000000..64ce974
--- /dev/null
+++ b/crates/domain/tests/provider.rs
@@ -0,0 +1,2 @@
+#[path = "provider/provider_connection_test.rs"]
+mod provider_connection_test;
diff --git a/crates/domain/tests/provider/provider_connection_test.rs b/crates/domain/tests/provider/provider_connection_test.rs
new file mode 100644
index 0000000..45b8503
--- /dev/null
+++ b/crates/domain/tests/provider/provider_connection_test.rs
@@ -0,0 +1,55 @@
+use domain::provider::{EncryptedCredential, ProviderConnection, ProviderName};
+use domain::user::UserId;
+
+fn credential() -> EncryptedCredential {
+    EncryptedCredential::from_persistence(vec![1, 2, 3, 4])
+}
+
+#[test]
+fn a_provider_name_is_a_lowercase_slug() {
+    assert_eq!(ProviderName::new("Subsonic").unwrap().value(), "subsonic");
+    assert_eq!(ProviderName::new("  spotify ").unwrap().value(), "spotify");
+}
+
+#[test]
+fn a_blank_or_malformed_provider_name_is_rejected() {
+    assert!(ProviderName::new("").is_err());
+    assert!(ProviderName::new("   ").is_err());
+    assert!(ProviderName::new("my provider").is_err());
+}
+
+#[test]
+fn a_connection_belongs_to_one_user_and_one_provider() {
+    let user_id = UserId::generate();
+    let provider = ProviderName::new("subsonic").unwrap();
+
+    let connection = ProviderConnection::new(user_id.clone(), provider.clone(), credential());
+
+    assert_eq!(*connection.user_id(), user_id);
+    assert_eq!(connection.provider().value(), "subsonic");
+}
+
+#[test]
+fn a_credential_never_reveals_itself_in_debug_output() {
+    let user_id = UserId::generate();
+    let provider = ProviderName::new("subsonic").unwrap();
+    let secret = EncryptedCredential::from_persistence(b"hunter2".to_vec());
+
+    let connection = ProviderConnection::new(user_id, provider, secret);
+
+    let rendered = format!("{connection:?}");
+    assert!(!rendered.contains("hunter2"));
+    assert!(!rendered.contains("104, 117, 110"));
+}
+
+#[test]
+fn replacing_a_credential_touches_the_connection() {
+    let user_id = UserId::generate();
+    let provider = ProviderName::new("subsonic").unwrap();
+    let mut connection = ProviderConnection::new(user_id, provider, credential());
+    let before = *connection.updated_at();
+
+    connection.replace_credential(EncryptedCredential::from_persistence(vec![9, 9]));
+
+    assert!(*connection.updated_at() >= before);
+}
diff --git a/crates/domain/tests/services/mood_analyzer_test.rs b/crates/domain/tests/services/mood_analyzer_test.rs
index ed392de..e09668c 100644
--- a/crates/domain/tests/services/mood_analyzer_test.rs
+++ b/crates/domain/tests/services/mood_analyzer_test.rs
@@ -1,8 +1,9 @@
 use chrono::{Duration, FixedOffset, TimeZone};
 
-use domain::activity::ActivityId;
+use domain::entry::Date;
 use domain::entry::{Mood, MoodEntry};
 use domain::services::MoodAnalyzerService;
+use domain::user::Timezone;
 use domain::user::UserId;
 
 fn entry_with_mood(mood: Mood, days_ago: i64) -> MoodEntry {
@@ -12,14 +13,6 @@ fn entry_with_mood(mood: Mood, days_ago: i64) -> MoodEntry {
     MoodEntry::new(UserId::generate(), mood, logged_at)
 }
 
-fn entry_with_mood_and_activity(mood: Mood, activity: &ActivityId) -> MoodEntry {
-    let offset = FixedOffset::east_opt(0).unwrap();
-    let logged_at = offset.from_utc_datetime(&chrono::Utc::now().naive_utc());
-    let mut entry = MoodEntry::new(UserId::generate(), mood, logged_at);
-    entry.set_activities(vec![activity.clone()]);
-    entry
-}
-
 #[test]
 fn average_mood_of_empty_slice_is_none() {
     assert!(MoodAnalyzerService::average_mood(&[]).is_none());
@@ -61,61 +54,43 @@ fn mood_frequency_counts_each_mood() {
 
 #[test]
 fn streak_counts_consecutive_days() {
-    let entries = vec![
-        entry_with_mood(Mood::Good, 0),
-        entry_with_mood(Mood::Good, 1),
-        entry_with_mood(Mood::Good, 2),
-    ];
+    let dates = dates_ago(&[0, 1, 2]);
 
-    assert_eq!(MoodAnalyzerService::current_streak(&entries), 3);
+    assert_eq!(MoodAnalyzerService::current_streak(&dates, today()), 3);
 }
 
 #[test]
 fn streak_breaks_on_gap() {
-    let entries = vec![
-        entry_with_mood(Mood::Good, 0),
-        entry_with_mood(Mood::Good, 1),
-        entry_with_mood(Mood::Good, 3),
-    ];
+    let dates = dates_ago(&[0, 1, 3]);
 
-    assert_eq!(MoodAnalyzerService::current_streak(&entries), 2);
+    assert_eq!(MoodAnalyzerService::current_streak(&dates, today()), 2);
 }
 
 #[test]
-fn streak_of_empty_entries_is_zero() {
-    assert_eq!(MoodAnalyzerService::current_streak(&[]), 0);
+fn streak_of_no_dates_is_zero() {
+    assert_eq!(MoodAnalyzerService::current_streak(&[], today()), 0);
 }
 
 #[test]
-fn activity_correlation_positive_when_mood_higher_with_activity() {
-    let activity = ActivityId::generate();
-    let entries = vec![
-        entry_with_mood_and_activity(Mood::Rad, &activity),
-        entry_with_mood_and_activity(Mood::Good, &activity),
-        entry_with_mood(Mood::Meh, 0),
-        entry_with_mood(Mood::Bad, 1),
-    ];
+fn streak_is_zero_when_the_last_entry_is_old() {
+    let dates = dates_ago(&[3, 4]);
 
-    let correlation = MoodAnalyzerService::activity_mood_correlation(&entries, &activity).unwrap();
-    assert!(correlation > 0.0);
+    assert_eq!(MoodAnalyzerService::current_streak(&dates, today()), 0);
 }
 
 #[test]
-fn activity_correlation_is_none_when_never_used() {
-    let activity = ActivityId::generate();
-    let entries = vec![entry_with_mood(Mood::Good, 0)];
+fn the_streak_is_measured_in_the_users_own_days_not_utc_days() {
+    // 2025-03-15T20:00Z is already the 16th in Auckland and still the 15th in UTC.
+    let evening: chrono::DateTime<FixedOffset> = "2025-03-15T20:00:00+00:00".parse().unwrap();
+    let auckland = Timezone::new("Pacific/Auckland").unwrap();
 
-    let result = MoodAnalyzerService::activity_mood_correlation(&entries, &activity);
-    assert!(result.is_none());
-}
+    let logged = Date::from_instant(&evening, &auckland);
+    let their_today = Date::from_instant(&evening, &auckland);
 
-#[test]
-fn streak_is_zero_when_last_entry_is_old() {
-    let entries = vec![
-        entry_with_mood(Mood::Good, 3),
-        entry_with_mood(Mood::Good, 4),
-    ];
-    assert_eq!(MoodAnalyzerService::current_streak(&entries), 0);
+    assert_eq!(
+        MoodAnalyzerService::current_streak(&[logged], their_today),
+        1
+    );
 }
 
 #[test]
@@ -124,14 +99,20 @@ fn mood_frequency_on_empty_is_empty() {
     assert!(freq.is_empty());
 }
 
-#[test]
-fn activity_correlation_is_none_when_all_entries_have_activity() {
-    let activity = ActivityId::generate();
-    let entries = vec![
-        entry_with_mood_and_activity(Mood::Good, &activity),
-        entry_with_mood_and_activity(Mood::Rad, &activity),
-    ];
-
-    let result = MoodAnalyzerService::activity_mood_correlation(&entries, &activity);
-    assert!(result.is_none());
+fn today() -> Date {
+    Date::from_instant(
+        &chrono::Utc::now().fixed_offset(),
+        &Timezone::new("UTC").unwrap(),
+    )
+}
+
+fn dates_ago(offsets: &[i64]) -> Vec<Date> {
+    let utc = Timezone::new("UTC").unwrap();
+    offsets
+        .iter()
+        .map(|days| {
+            let instant = chrono::Utc::now() - chrono::Duration::days(*days);
+            Date::from_instant(&instant.fixed_offset(), &utc)
+        })
+        .collect()
 }
diff --git a/crates/domain/tests/song.rs b/crates/domain/tests/song.rs
new file mode 100644
index 0000000..500f1de
--- /dev/null
+++ b/crates/domain/tests/song.rs
@@ -0,0 +1,2 @@
+#[path = "song/song_test.rs"]
+mod song_test;
diff --git a/crates/domain/tests/song/song_test.rs b/crates/domain/tests/song/song_test.rs
new file mode 100644
index 0000000..8c89859
--- /dev/null
+++ b/crates/domain/tests/song/song_test.rs
@@ -0,0 +1,44 @@
+use domain::song::{RecordingId, Song};
+
+#[test]
+fn a_song_needs_only_a_title_and_an_artist() {
+    let song = Song::new("Paranoid Android", "Radiohead", None, None).unwrap();
+
+    assert_eq!(song.title().value(), "Paranoid Android");
+    assert_eq!(song.artist().value(), "Radiohead");
+    assert!(song.album().is_none());
+    assert!(song.recording_id().is_none());
+}
+
+#[test]
+fn a_song_records_its_album_and_external_identity_when_known() {
+    let recording = RecordingId::new("f5c7e7a2-0000-4000-8000-000000000001").unwrap();
+    let song = Song::new(
+        "Paranoid Android",
+        "Radiohead",
+        Some("OK Computer".into()),
+        Some(recording),
+    )
+    .unwrap();
+
+    assert_eq!(song.album().map(|a| a.value()), Some("OK Computer"));
+    assert!(song.recording_id().is_some());
+}
+
+#[test]
+fn a_song_without_a_title_or_artist_is_rejected() {
+    assert!(Song::new("", "Radiohead", None, None).is_err());
+    assert!(Song::new("Paranoid Android", "   ", None, None).is_err());
+}
+
+#[test]
+fn a_recording_id_that_is_not_a_uuid_is_rejected() {
+    assert!(RecordingId::new("not-a-musicbrainz-id").is_err());
+}
+
+#[test]
+fn a_blank_album_is_treated_as_absent() {
+    let song = Song::new("Airbag", "Radiohead", Some("   ".into()), None).unwrap();
+
+    assert!(song.album().is_none());
+}
diff --git a/crates/domain/tests/user/timezone_test.rs b/crates/domain/tests/user/timezone_test.rs
index 52ea0ca..4f2536d 100644
--- a/crates/domain/tests/user/timezone_test.rs
+++ b/crates/domain/tests/user/timezone_test.rs
@@ -2,31 +2,52 @@ use domain::errors::DomainError;
 use domain::user::Timezone;
 
 #[test]
-fn valid_timezone_is_created() {
-    let tz = Timezone::new("Europe/Warsaw").unwrap();
-    assert_eq!(tz.value(), "Europe/Warsaw");
+fn a_zone_from_the_iana_database_is_accepted() {
+    assert_eq!(
+        Timezone::new("Europe/Warsaw").unwrap().value(),
+        "Europe/Warsaw"
+    );
+    assert_eq!(
+        Timezone::new("America/New_York").unwrap().value(),
+        "America/New_York"
+    );
 }
 
 #[test]
-fn timezone_trims_whitespace() {
-    let tz = Timezone::new("  America/New_York  ").unwrap();
-    assert_eq!(tz.value(), "America/New_York");
+fn utc_is_a_real_zone_and_is_accepted() {
+    assert_eq!(Timezone::new("UTC").unwrap().value(), "UTC");
 }
 
 #[test]
-fn empty_timezone_is_rejected() {
-    let result = Timezone::new("");
-    assert!(matches!(result, Err(DomainError::InvalidInput(_))));
+fn surrounding_whitespace_is_trimmed() {
+    assert_eq!(
+        Timezone::new("  America/New_York  ").unwrap().value(),
+        "America/New_York"
+    );
 }
 
 #[test]
-fn timezone_without_slash_is_rejected() {
-    let result = Timezone::new("UTC");
-    assert!(matches!(result, Err(DomainError::InvalidInput(_))));
+fn a_zone_that_merely_looks_like_one_is_rejected() {
+    assert!(matches!(
+        Timezone::new("Foo/Bar"),
+        Err(DomainError::InvalidInput(_))
+    ));
+    assert!(matches!(
+        Timezone::new("Europe/Atlantis"),
+        Err(DomainError::InvalidInput(_))
+    ));
 }
 
 #[test]
-fn from_persistence_bypasses_validation() {
-    let tz = Timezone::from_persistence("UTC".into());
-    assert_eq!(tz.value(), "UTC");
+fn an_empty_zone_is_rejected() {
+    assert!(matches!(
+        Timezone::new(""),
+        Err(DomainError::InvalidInput(_))
+    ));
+}
+
+#[test]
+fn a_stored_zone_that_cannot_be_resolved_is_refused_on_load() {
+    assert!(Timezone::from_persistence("Foo/Bar").is_err());
+    assert!(Timezone::from_persistence("Europe/Warsaw").is_ok());
 }
diff --git a/crates/domain/tests/weather.rs b/crates/domain/tests/weather.rs
new file mode 100644
index 0000000..9a4bb9d
--- /dev/null
+++ b/crates/domain/tests/weather.rs
@@ -0,0 +1,2 @@
+#[path = "weather/weather_test.rs"]
+mod weather_test;
diff --git a/crates/domain/tests/weather/weather_test.rs b/crates/domain/tests/weather/weather_test.rs
new file mode 100644
index 0000000..d52aaef
--- /dev/null
+++ b/crates/domain/tests/weather/weather_test.rs
@@ -0,0 +1,60 @@
+use domain::provider::ProviderName;
+use domain::weather::{Celsius, Condition, Weather};
+
+fn open_meteo() -> ProviderName {
+    ProviderName::new("open-meteo").unwrap()
+}
+
+#[test]
+fn a_temperature_nowhere_on_earth_reaches_is_rejected() {
+    assert!(Celsius::new(-95.0).is_err());
+    assert!(Celsius::new(65.0).is_err());
+}
+
+#[test]
+fn the_coldest_and_hottest_places_on_earth_are_valid() {
+    assert!(Celsius::new(-90.0).is_ok());
+    assert!(Celsius::new(60.0).is_ok());
+}
+
+#[test]
+fn a_temperature_that_is_not_a_number_is_rejected() {
+    assert!(Celsius::new(f64::NAN).is_err());
+    assert!(Celsius::new(f64::INFINITY).is_err());
+}
+
+#[test]
+fn every_condition_survives_a_round_trip_through_its_name() {
+    for condition in Condition::ALL {
+        assert_eq!(Condition::from_name(condition.name()), Some(condition));
+    }
+
+    assert_eq!(Condition::from_name("raining cats"), None);
+}
+
+#[test]
+fn the_vocabulary_is_the_one_the_domain_chose_not_the_providers() {
+    let names: Vec<&str> = Condition::ALL.iter().map(|c| c.name()).collect();
+
+    assert_eq!(
+        names,
+        [
+            "clear",
+            "cloudy",
+            "fog",
+            "drizzle",
+            "rain",
+            "snow",
+            "thunderstorm"
+        ]
+    );
+}
+
+#[test]
+fn weather_is_always_attributed_to_whoever_observed_it() {
+    let weather = Weather::new(Condition::Rain, Celsius::new(11.5).unwrap(), open_meteo());
+
+    assert_eq!(weather.condition(), Condition::Rain);
+    assert!((weather.temperature().value() - 11.5).abs() < f64::EPSILON);
+    assert_eq!(weather.observed_by().value(), "open-meteo");
+}
diff --git a/crates/server/Cargo.toml b/crates/server/Cargo.toml
index 3ca06f1..585eee7 100644
--- a/crates/server/Cargo.toml
+++ b/crates/server/Cargo.toml
@@ -8,6 +8,7 @@ name = "k-mood"
 path = "src/main.rs"
 
 [dependencies]
+bootstrap.workspace = true
 domain.workspace = true
 axum.workspace = true
 application.workspace = true
@@ -18,6 +19,9 @@ auth.workspace = true
 storage.workspace = true
 event-publisher.workspace = true
 importer.workspace = true
+crypto.workspace = true
+music.workspace = true
+reqwest.workspace = true
 exporter.workspace = true
 web-push-adapter.workspace = true
 serde.workspace = true
diff --git a/crates/server/src/config_loader.rs b/crates/server/src/config_loader.rs
deleted file mode 100644
index 8eaeb12..0000000
--- a/crates/server/src/config_loader.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use config::AppConfig;
-
-const CONFIG_FILE: &str = "config.toml";
-
-pub fn load() -> Result<AppConfig, Box<dyn std::error::Error>> {
-    let path = std::path::Path::new(CONFIG_FILE);
-
-    if path.exists() {
-        let content = std::fs::read_to_string(path)?;
-        let config: AppConfig = toml::from_str(&content)?;
-        tracing::info!(path = CONFIG_FILE, "loaded config from file");
-        Ok(config)
-    } else {
-        tracing::info!("no config file found, using defaults");
-        Ok(AppConfig::default())
-    }
-}
diff --git a/crates/server/src/factory.rs b/crates/server/src/factory.rs
deleted file mode 100644
index 0fd96cc..0000000
--- a/crates/server/src/factory.rs
+++ /dev/null
@@ -1,119 +0,0 @@
-use std::sync::Arc;
-
-use config::AppConfig;
-use domain::ports::ReminderSenderPort;
-use http_axum::state::AppState;
-
-pub struct AppContext {
-    pub state: AppState,
-    pub reminder_sender: Option<Arc<dyn ReminderSenderPort>>,
-}
-
-pub async fn build(config: AppConfig) -> Result<AppContext, Box<dyn std::error::Error>> {
-    let db_url = config
-        .storage
-        .database_url
-        .clone()
-        .unwrap_or_else(|| format!("sqlite://{}/k-mood.db", config.storage.data_dir));
-
-    let pool = sqlite::create_pool(&db_url).await?;
-    sqlite::run_migrations(&pool).await?;
-
-    let user_command = Arc::new(sqlite::repositories::SqliteUserCommandRepository::new(
-        pool.clone(),
-    ));
-    let user_query = Arc::new(sqlite::repositories::SqliteUserQueryRepository::new(
-        pool.clone(),
-    ));
-    let activity_command = Arc::new(sqlite::repositories::SqliteActivityCommandRepository::new(
-        pool.clone(),
-    ));
-    let activity_query = Arc::new(sqlite::repositories::SqliteActivityQueryRepository::new(
-        pool.clone(),
-    ));
-    let entry_command = Arc::new(sqlite::repositories::SqliteEntryCommandRepository::new(
-        pool.clone(),
-    ));
-    let entry_query = Arc::new(sqlite::repositories::SqliteEntryQueryRepository::new(
-        pool.clone(),
-    ));
-    let reminder_command = Arc::new(sqlite::repositories::SqliteReminderCommandRepository::new(
-        pool.clone(),
-    ));
-    let reminder_query = Arc::new(sqlite::repositories::SqliteReminderQueryRepository::new(
-        pool.clone(),
-    ));
-    let refresh_session_command =
-        Arc::new(sqlite::repositories::SqliteRefreshSessionCommandRepository::new(pool.clone()));
-    let refresh_session_query =
-        Arc::new(sqlite::repositories::SqliteRefreshSessionQueryRepository::new(pool.clone()));
-    let cascade = Arc::new(sqlite::repositories::SqliteCascadeDeleteRepository::new(
-        pool.clone(),
-    ));
-    let push_subscription_command =
-        Arc::new(sqlite::repositories::SqlitePushSubscriptionCommandRepository::new(pool.clone()));
-    let push_subscription_query =
-        Arc::new(sqlite::repositories::SqlitePushSubscriptionQueryRepository::new(pool));
-
-    let jwt_service = auth::JwtAuthService::new(&config.auth)?;
-    let password_hasher = auth::Argon2PasswordHasher;
-
-    let media_storage = storage::create_media_storage(&config.storage)?;
-
-    let reminder_sender: Option<Arc<dyn ReminderSenderPort>> = if config.push.enabled {
-        let sender =
-            web_push_adapter::WebPushSender::new(&config.push, push_subscription_query.clone())?;
-        Some(Arc::new(sender))
-    } else {
-        None
-    };
-
-    let (event_publisher, event_receiver) = event_publisher::create_event_channel();
-    spawn_event_drain(event_receiver);
-
-    let state = AppState {
-        entry_command,
-        entry_query,
-        activity_command,
-        activity_query,
-        user_command,
-        user_query,
-        reminder_command,
-        reminder_query,
-        refresh_session_command,
-        refresh_session_query,
-        cascade,
-        auth_service: Arc::new(jwt_service),
-        password_hasher: Arc::new(password_hasher),
-        event_publisher: Arc::new(event_publisher),
-        media_storage: Arc::new(media_storage),
-        export_port: Arc::new(exporter::JsonExportAdapter),
-        import_source: Arc::new(importer::DaylioImportAdapter),
-        push_subscription_command,
-        push_subscription_query,
-        reminder_sender: reminder_sender.clone(),
-        server_config: config.server,
-        entry_config: config.entry,
-        auth_config: config.auth,
-        push_config: config.push,
-        preset_config: config.preset,
-    };
-
-    Ok(AppContext {
-        state,
-        reminder_sender,
-    })
-}
-
-fn spawn_event_drain(mut receiver: event_publisher::EventReceiver) {
-    tokio::spawn(async move {
-        while let Some(envelope) = receiver.recv().await {
-            tracing::debug!(
-                event_id = %envelope.id(),
-                event = ?envelope.event(),
-                "domain event published"
-            );
-        }
-        tracing::info!("event drain stopped");
-    });
-}
diff --git a/crates/server/src/main.rs b/crates/server/src/main.rs
index f611a45..2d19f96 100644
--- a/crates/server/src/main.rs
+++ b/crates/server/src/main.rs
@@ -1,18 +1,15 @@
-mod config_loader;
-mod factory;
-
 #[tokio::main]
 async fn main() {
-    setup_tracing();
+    bootstrap::setup_tracing();
 
-    if let Err(e) = run().await {
-        tracing::error!(error = %e, "application failed");
+    if let Err(error) = run().await {
+        tracing::error!(%error, "the server could not start");
         std::process::exit(1);
     }
 }
 
 async fn run() -> Result<(), Box<dyn std::error::Error>> {
-    let config = config_loader::load()?;
+    let config = bootstrap::load()?;
 
     tracing::info!(
         host = %config.server.host,
@@ -20,112 +17,22 @@ async fn run() -> Result<(), Box<dyn std::error::Error>> {
         "starting k-mood server"
     );
 
-    let context = factory::build(config.clone()).await?;
-
-    if let Some(sender) = context.reminder_sender {
-        spawn_reminder_scheduler(
-            context.state.reminder_query.clone(),
-            context.state.user_query.clone(),
-            sender,
-        );
-        tracing::info!("push notifications enabled, reminder scheduler started");
-    }
-
-    spawn_session_cleanup(context.state.refresh_session_command.clone());
-
+    let context = bootstrap::build(config.clone()).await?;
     let router = http_axum::router::build_router(context.state);
 
-    let addr = format!("{}:{}", config.server.host, config.server.port);
-    let listener = tokio::net::TcpListener::bind(&addr).await?;
+    let address = format!("{}:{}", config.server.host, config.server.port);
+    let listener = tokio::net::TcpListener::bind(&address).await?;
 
-    tracing::info!(addr = %addr, "listening");
+    tracing::info!(
+        address = %address,
+        "listening; background work runs in the k-mood-worker process"
+    );
 
     axum::serve(listener, router)
-        .with_graceful_shutdown(shutdown_signal())
+        .with_graceful_shutdown(bootstrap::shutdown::on_signal())
         .await?;
 
-    tracing::info!("server shut down gracefully");
+    tracing::info!("k-mood server shut down gracefully");
+
     Ok(())
 }
-
-fn spawn_reminder_scheduler(
-    reminder_query: std::sync::Arc<dyn domain::ports::ReminderQueryPort>,
-    user_query: std::sync::Arc<dyn domain::ports::UserQueryPort>,
-    sender: std::sync::Arc<dyn domain::ports::ReminderSenderPort>,
-) {
-    use application::reminder::use_cases::process_due_reminders;
-
-    tokio::spawn(async move {
-        let deps = process_due_reminders::Deps {
-            reminder_query,
-            user_query,
-            sender,
-        };
-
-        let mut interval = tokio::time::interval(std::time::Duration::from_secs(60));
-        loop {
-            interval.tick().await;
-            match process_due_reminders::execute(&deps).await {
-                Ok(sent) => {
-                    if sent > 0 {
-                        tracing::info!(sent, "reminders sent");
-                    }
-                }
-                Err(e) => tracing::error!(error = %e, "reminder processing failed"),
-            }
-        }
-    });
-}
-
-fn spawn_session_cleanup(
-    refresh_session_command: std::sync::Arc<dyn domain::ports::RefreshSessionCommandPort>,
-) {
-    tokio::spawn(async move {
-        let mut interval = tokio::time::interval(std::time::Duration::from_secs(3600));
-        loop {
-            interval.tick().await;
-            match refresh_session_command.delete_expired().await {
-                Ok(deleted) => {
-                    if deleted > 0 {
-                        tracing::info!(deleted, "expired refresh sessions cleaned up");
-                    }
-                }
-                Err(e) => tracing::error!(error = %e, "refresh session cleanup failed"),
-            }
-        }
-    });
-}
-
-async fn shutdown_signal() {
-    let ctrl_c = async {
-        tokio::signal::ctrl_c()
-            .await
-            .expect("failed to install Ctrl+C handler");
-    };
-
-    #[cfg(unix)]
-    let terminate = async {
-        tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
-            .expect("failed to install SIGTERM handler")
-            .recv()
-            .await;
-    };
-
-    #[cfg(not(unix))]
-    let terminate = std::future::pending::<()>();
-
-    tokio::select! {
-        _ = ctrl_c => tracing::info!("received Ctrl+C"),
-        _ = terminate => tracing::info!("received SIGTERM"),
-    }
-}
-
-fn setup_tracing() {
-    use tracing_subscriber::EnvFilter;
-
-    tracing_subscriber::fmt()
-        .with_env_filter(
-            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info,sqlx=warn")),
-        )
-        .init();
-}
diff --git a/crates/worker/Cargo.toml b/crates/worker/Cargo.toml
new file mode 100644
index 0000000..b23d0e5
--- /dev/null
+++ b/crates/worker/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "worker"
+edition.workspace = true
+version.workspace = true
+
+[[bin]]
+name = "k-mood-worker"
+path = "src/main.rs"
+
+[dependencies]
+bootstrap.workspace = true
+domain.workspace = true
+application.workspace = true
+config.workspace = true
+tokio.workspace = true
+tracing.workspace = true
diff --git a/crates/worker/src/loops.rs b/crates/worker/src/loops.rs
new file mode 100644
index 0000000..718f120
--- /dev/null
+++ b/crates/worker/src/loops.rs
@@ -0,0 +1,147 @@
+use std::sync::Arc;
+use std::time::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,
+};
+
+pub fn every(seconds: u64) -> tokio::time::Interval {
+    let mut interval = tokio::time::interval(Duration::from_secs(seconds.max(1)));
+    interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
+
+    interval
+}
+
+pub struct QueueDependencies {
+    pub queue: Arc<dyn JobQueueCommandPort>,
+    pub backfill: Arc<dyn RecordingBackfillQueryPort>,
+    pub recordings: Arc<dyn RecordingLookupPort>,
+    pub places: Arc<dyn WeatherBacklogQueryPort>,
+    pub weather: Option<Arc<dyn WeatherLookupPort>>,
+    pub weather_store: Arc<dyn EntryDimensionPort>,
+}
+
+pub async fn work_the_queue(held: QueueDependencies, worker: WorkerConfig) {
+    let queue = held.queue.clone();
+    let deps = run_due_jobs::Deps {
+        queue: held.queue,
+        backfill: held.backfill,
+        recordings: held.recordings,
+        places: held.places,
+        weather: held.weather,
+        weather_store: held.weather_store,
+    };
+
+    let mut ticks = every(worker.poll_seconds);
+
+    loop {
+        ticks.tick().await;
+
+        match queue.reclaim_stalled(worker.stalled_after_seconds).await {
+            Ok(reclaimed) if reclaimed > 0 => {
+                tracing::info!(reclaimed, "reclaimed jobs left running by a stopped worker")
+            }
+            Ok(_) => {}
+            Err(error) => tracing::error!(%error, "could not reclaim stalled jobs"),
+        }
+
+        match run_due_jobs::execute(worker.jobs_per_poll, worker.most_attempts, &deps).await {
+            Ok(worked) if worked.finished + worked.failed > 0 => {
+                tracing::info!(
+                    finished = worked.finished,
+                    failed = worked.failed,
+                    "worked the queue"
+                )
+            }
+            Ok(_) => {}
+            Err(error) => tracing::error!(%error, "could not work the queue"),
+        }
+    }
+}
+
+pub async fn sweep_for_work(
+    recordings: Arc<dyn RecordingBackfillQueryPort>,
+    places: Option<Arc<dyn WeatherBacklogQueryPort>>,
+    queue: Arc<dyn JobQueueCommandPort>,
+    worker: WorkerConfig,
+) {
+    let for_recordings = sweep_recording_backlog::Deps {
+        backlog: recordings,
+        queue: queue.clone(),
+    };
+
+    let for_weather = places.map(|backlog| sweep_weather_backlog::Deps { backlog, queue });
+
+    if for_weather.is_none() {
+        tracing::info!("not sweeping for weather, because weather cannot be looked up");
+    }
+
+    let mut ticks = every(worker.sweep_seconds);
+
+    loop {
+        ticks.tick().await;
+
+        if let Err(error) =
+            sweep_recording_backlog::execute(worker.enqueued_per_sweep, &for_recordings).await
+        {
+            tracing::error!(%error, "could not sweep for songs with no recording identity");
+        }
+
+        let Some(for_weather) = &for_weather else {
+            continue;
+        };
+
+        if let Err(error) =
+            sweep_weather_backlog::execute(worker.enqueued_per_sweep, for_weather).await
+        {
+            tracing::error!(%error, "could not sweep for places with no weather");
+        }
+    }
+}
+
+pub async fn send_due_reminders(
+    reminder_query: Arc<dyn ReminderQueryPort>,
+    user_query: Arc<dyn UserQueryPort>,
+    sender: Arc<dyn ReminderSenderPort>,
+    worker: WorkerConfig,
+) {
+    let deps = process_due_reminders::Deps {
+        reminder_query,
+        user_query,
+        sender,
+    };
+
+    let mut ticks = every(worker.reminder_seconds);
+
+    loop {
+        ticks.tick().await;
+
+        match process_due_reminders::execute(&deps).await {
+            Ok(sent) if sent > 0 => tracing::info!(sent, "reminders sent"),
+            Ok(_) => {}
+            Err(error) => tracing::error!(%error, "could not process due reminders"),
+        }
+    }
+}
+
+pub async fn clear_expired_sessions(
+    sessions: Arc<dyn RefreshSessionCommandPort>,
+    worker: WorkerConfig,
+) {
+    let mut ticks = every(worker.session_cleanup_seconds);
+
+    loop {
+        ticks.tick().await;
+
+        match sessions.delete_expired().await {
+            Ok(deleted) if deleted > 0 => tracing::info!(deleted, "expired sessions cleared"),
+            Ok(_) => {}
+            Err(error) => tracing::error!(%error, "could not clear expired sessions"),
+        }
+    }
+}
diff --git a/crates/worker/src/main.rs b/crates/worker/src/main.rs
new file mode 100644
index 0000000..ae1f33a
--- /dev/null
+++ b/crates/worker/src/main.rs
@@ -0,0 +1,102 @@
+mod loops;
+
+#[tokio::main]
+async fn main() {
+    bootstrap::setup_tracing();
+
+    if let Err(error) = run().await {
+        tracing::error!(%error, "the worker could not start");
+        std::process::exit(1);
+    }
+}
+
+async fn run() -> Result<(), Box<dyn std::error::Error>> {
+    let config = bootstrap::load()?;
+    let context = bootstrap::build(config).await?;
+    let worker = context.worker_config.clone();
+
+    tracing::info!(
+        poll_seconds = worker.poll_seconds,
+        sweep_seconds = worker.sweep_seconds,
+        most_attempts = worker.most_attempts,
+        "k-mood worker started"
+    );
+
+    report_abandoned_work(&context).await;
+
+    let queue = tokio::spawn(loops::work_the_queue(
+        loops::QueueDependencies {
+            queue: context.job_queue.clone(),
+            backfill: context.recording_backlog.clone(),
+            recordings: context.recordings.clone(),
+            places: context.weather_backlog.clone(),
+            weather: context.weather.clone(),
+            weather_store: context.weather_store.clone(),
+        },
+        worker.clone(),
+    ));
+
+    let sweeper = tokio::spawn(loops::sweep_for_work(
+        context.recording_backlog.clone(),
+        context
+            .weather
+            .as_ref()
+            .map(|_| context.weather_backlog.clone()),
+        context.job_queue.clone(),
+        worker.clone(),
+    ));
+
+    let sessions = tokio::spawn(loops::clear_expired_sessions(
+        context.state.refresh_session_command.clone(),
+        worker.clone(),
+    ));
+
+    let reminders = context.reminder_sender.clone().map(|sender| {
+        tokio::spawn(loops::send_due_reminders(
+            context.state.reminder_query.clone(),
+            context.state.user_query.clone(),
+            sender,
+            worker,
+        ))
+    });
+
+    if reminders.is_none() {
+        tracing::info!("push notifications are not configured, so no reminders will be sent");
+    }
+
+    bootstrap::shutdown::on_signal().await;
+
+    queue.abort();
+    sweeper.abort();
+    sessions.abort();
+    if let Some(reminders) = reminders {
+        reminders.abort();
+    }
+
+    tracing::info!("k-mood worker shut down");
+
+    Ok(())
+}
+
+async fn report_abandoned_work(context: &bootstrap::Context) {
+    match context.job_view.find_exhausted(50).await {
+        Ok(abandoned) if !abandoned.is_empty() => {
+            tracing::warn!(
+                count = abandoned.len(),
+                "jobs were given up on and are waiting to be looked at"
+            );
+
+            for job in abandoned {
+                tracing::warn!(
+                    job_id = %job.id(),
+                    kind = job.kind().name(),
+                    attempts = job.attempts(),
+                    reason = job.last_error().unwrap_or("unknown"),
+                    "abandoned job"
+                );
+            }
+        }
+        Ok(_) => {}
+        Err(error) => tracing::error!(%error, "could not read abandoned jobs"),
+    }
+}
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
index 5f759a8..b471ae3 100644
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -10,5 +10,17 @@ services:
       - RUST_LOG=debug
     restart: unless-stopped
 
+  worker:
+    build: .
+    entrypoint: ["k-mood-worker"]
+    volumes:
+      - k-mood-data:/data
+      - ./config.dev.toml:/data/config.toml:ro
+    environment:
+      - RUST_LOG=debug
+    depends_on:
+      - backend
+    restart: unless-stopped
+
 volumes:
   k-mood-data:
diff --git a/docs/adr/0001-day-boundary-from-user-timezone.md b/docs/adr/0001-day-boundary-from-user-timezone.md
new file mode 100644
index 0000000..adf820b
--- /dev/null
+++ b/docs/adr/0001-day-boundary-from-user-timezone.md
@@ -0,0 +1,31 @@
+# The day boundary is resolved from the User's timezone
+
+Day-scoped data (DailyMetric) needs a single, unambiguous notion of "which day". We resolve it by converting an instant into the User's IANA timezone and taking the local date, rather than using the offset carried on `logged_at` or a UTC date.
+
+## Considered Options
+
+- **Bare local date from `logged_at`** — what `get_calendar` did originally. No server-side authority: two clients in different offsets disagree about the same instant's date.
+- **UTC date** — unambiguous but wrong for most humans; evening entries in eastern offsets land on the following day and fail to line up with the health data describing them.
+
+## Consequences
+
+`User.timezone` stops being optional in practice. Clients must set it from the platform at register/login, and requests that need a day boundary are rejected when it is unset rather than silently defaulting — silently misfiled data produces analytics that look correct and are not. `Timezone` must therefore validate against the real IANA database, not just check for a `/`.
+
+All day grouping in the system flows through this one rule, including `get_calendar` and streak calculation, which previously used two different and mutually inconsistent definitions.
+
+## An imported wall clock time is the User's own wall clock
+
+Daylio's export records `2026-08-25` and `8:00 PM` and says nothing about which zone that was. The importer originally read it as UTC, so an entry logged at 8 PM in Warsaw was stored as `20:00Z` and displayed at 10 PM — every imported entry off by the User's offset, silently, and worse the further from UTC they live.
+
+A wall clock time with no zone is the User's own wall clock. It is now placed in their Timezone using the offset in force **on that entry's own date**, not a single offset taken from today, so a year of history spanning a clock change gets both offsets. A Warsaw import shows `+01:00` in winter and `+02:00` in summer, and every entry reads as the 8 PM it was.
+
+This makes the Timezone a precondition for importing, exactly as it already is for the calendar and for DailyMetrics: an account with none is refused rather than filed an hour or ten out of place. That is worth an error in the one place a User can act on it.
+
+Two edge cases the clocks create:
+
+- **An hour that never happened.** In Warsaw the clocks jump from 02:00 to 03:00 on the last Sunday in March, so a Daylio row reading 2:30 AM that day names a time that did not exist. The entry lands an hour later rather than being dropped, with a warning — a mood that was logged is not made up, and losing it to arithmetic is worse than moving it sixty minutes.
+- **An hour that happened twice.** In autumn 02:30 occurs twice; the earlier of the two is used. Either is defensible and the difference is an hour once a year, so the choice is recorded rather than agonised over.
+
+## A second bug the same file exposed
+
+The Daylio adapter read its columns by position, and index 7 is `note_title`, not `note`. Every imported note was silently dropped and the always-empty title kept in its place. Columns are now looked up by header name, so a column added, removed or reordered upstream cannot quietly shift the meaning of the data — and an export missing `full_date`, `time` or `mood` is refused by name rather than parsed into nonsense. Where a row has both a title and a note, both are kept.
diff --git a/docs/adr/0002-thin-mood-entry-root.md b/docs/adr/0002-thin-mood-entry-root.md
new file mode 100644
index 0000000..355f1b5
--- /dev/null
+++ b/docs/adr/0002-thin-mood-entry-root.md
@@ -0,0 +1,18 @@
+# MoodEntry is a thin root; everything optional is an independent EntryDimension
+
+`MoodEntry` carries only its identity, one Mood, and the instant it was logged. Every optional aspect — Content, Activities, photos, voice memos, weather, location, song — is an EntryDimension owning its own type, table, port, and validation, and is composed onto the entry at read time.
+
+A dimension is a new self-contained module owning its own storage and validation. Adding one does not change any existing dimension, repository, or use case.
+
+It does, however, add a variant to a closed `DimensionValue` enum, mirroring `MetricValue` in ADR 0008. This is deliberate: the compiler then walks you through every site that must handle the new dimension — composer, wire dispatch, export — rather than letting it silently fail to appear. Openness was traded for exhaustiveness, on the same reasoning and for the same reason as ADR 0008.
+
+## Considered Options
+
+- **Adding nullable fields to `MoodEntry`** — what the codebase did. The aggregate was already at 10 fields against a stated 5-6 guideline, and the proposed data points would have taken it past 30.
+- **A closed facet enum on the root** — keeps the root small but forces heterogeneous payloads into one table as JSON or sparse columns, and turns "at most one weather per entry" from structure into a runtime check.
+
+## Consequences
+
+The existing four dimensions were retrofitted rather than left as a parallel path, so there is exactly one answer to "what is attached to this entry". Reads batch-load per dimension across a whole page of entries rather than per entry.
+
+Enumeration does not disappear — it concentrates in the read composer and the wire format's kind dispatch, instead of being spread across the domain.
diff --git a/docs/adr/0003-api-tokens-for-headless-importers.md b/docs/adr/0003-api-tokens-for-headless-importers.md
new file mode 100644
index 0000000..a3ac0e0
--- /dev/null
+++ b/docs/adr/0003-api-tokens-for-headless-importers.md
@@ -0,0 +1,26 @@
+# Headless importers authenticate with long-lived scoped API tokens
+
+Health data arrives from automations — iOS Shortcuts, Tasker, cron — that cannot participate in the session flow. Users mint named, revocable, non-expiring API tokens scoped to writing DailyMetrics only.
+
+## Considered Options
+
+- **Reusing the refresh token flow** — rejected because refresh tokens rotate and revoke the old token on use, so a single interrupted run locks the importer out permanently and silently, and iOS Shortcuts has no durable place to keep a rotating secret.
+- **Raising the access token TTL** — rejected because it would lengthen the compromise window for every browser session to solve an automation problem.
+
+## Consequences
+
+The system now has two credential types with different lifetimes and different powers. An API token cannot read entries or change account settings, so a leaked one exposes less than a session token — but it does not expire, so listing and revoking tokens is a required part of the settings surface, not a nice-to-have.
+
+## What a token is, in practice
+
+The value is `kmood_` followed by 32 random bytes in url-safe base64 — the prefix so a secret scanner can recognise one in a repository, the bytes because 256 bits needs no stretching. Only its SHA-256 digest is stored, in a unique indexed column, so authentication is one indexed lookup and one fast hash. Argon2 would be the wrong tool twice over: it exists to slow down guessing at low-entropy human passwords, and because its output is salted per row it cannot be looked up, which would mean verifying a presented secret against every stored token on every request.
+
+Scope is enforced by which extractor a route asks for, not by a check inside one. `AuthenticatedUser` accepts sessions only; `MetricWriter` accepts either a session or a token. A new endpoint therefore refuses tokens by default, and making one token-accessible is a visible, deliberate edit. The inverse — one extractor consulting a scope table — would make omission the permissive case.
+
+## The name is the Provider
+
+A token's name is a ProviderName, and its writes are attributed to it. This keeps ADR 0009's manual-wins rule intact once automations exist: an import genuinely is a Provider write, so it cannot overwrite what the User stated by hand, and a User correcting an imported day supersedes the importer. The constraint it imposes is that token names live in ProviderName's alphabet — lowercase letters, digits and hyphens — which is surfaced as a validation error rather than silently normalised.
+
+One asymmetry follows from the same rule and is enforced separately: a Provider-attributed request may not clear a metric. Clearing is how a User says a reading should not be there, and an importer that could clear would be able to delete hand-entered data it is not allowed to overwrite.
+
+Tokens survive clearing account data, as ProviderConnections do — a credential is not data about days. Deleting the account removes them through the foreign key.
diff --git a/docs/adr/0004-lossy-job-queue-with-state-derived-sweeps.md b/docs/adr/0004-lossy-job-queue-with-state-derived-sweeps.md
new file mode 100644
index 0000000..c67e7e8
--- /dev/null
+++ b/docs/adr/0004-lossy-job-queue-with-state-derived-sweeps.md
@@ -0,0 +1,60 @@
+# Background work runs in a separate binary against a deliberately lossy queue
+
+Background jobs (weather enrichment, metadata lookup, reminders) run in a dedicated worker binary, not in `tokio::spawn` calls inside the server. Correctness comes from sweeping domain state; the queue exists only for promptness and observability.
+
+The rule that makes this safe: **no job may be enqueued unless a query over domain state can independently rediscover the same work.** "Entries with a Location and no Weather" is a valid job; anything with no trace in the data is not.
+
+## Considered Options
+
+- **Transactional outbox** — events written atomically with the change that caused them. Correct, but `MoodEntryCommandPort::save` and `EventPublisherPort::publish` are separate ports with no shared transaction, so this required either an aggregate-recorded event collection or a unit-of-work threaded through every command. Both are real cost for a guarantee that sweeps already provide.
+- **Polling only, no queue** — matches how reminders already work, but gives no record of a failed enrichment, so nothing can be retried deliberately or inspected.
+
+## Consequences
+
+Saving a MoodEntry stays a single small transaction that must simply succeed. Everything downstream is best-effort with a visible trace — status, attempt count, last error — so a failure can be retried rather than disappearing.
+
+Losing a queued job costs latency, never data. This means the queue needs no transactional guarantees, and restarts, crashes, and imports that predate the queue are all handled by the same sweep rather than by three separate mechanisms.
+
+The cost is that every job type owes a sweeper query alongside its enqueue, and jobs that cannot be expressed as a query over state must be refused rather than accommodated.
+
+The in-process `mpsc` event channel cannot cross a process boundary, so it is not the transport. The queue's backing store is an adapter choice behind the port — SQLite is the store of record; NATS, where available, is a relay for fan-out, never the source of truth.
+
+`create_pool` must set a `busy_timeout`: two processes writing one SQLite file without it produces intermittent `SQLITE_BUSY` failures. Shared wiring must move out of `crates/server` so both binaries build the same object graph.
+
+## Bounds
+
+Sweeps are rate-bounded from configuration, not from constants. The realistic backlog is small — the Daylio importer carries no location data, so imported history never triggers weather lookups; the sweeper exists for entries stranded by an upstream outage or an offline client. The bound is a safety limit rather than a throughput design.
+
+Where an upstream accepts a date range for one location, a backlog grouped by rounded coordinates collapses into a handful of requests rather than one per entry.
+
+Now-playing lookup is not a job. It resolves synchronously while an entry is being composed, and a MoodEntry never acquires a Song afterwards — so there is nothing for a sweep to rediscover, and nothing belongs on the queue.
+
+## Correcting this document on SQLITE_BUSY
+
+This ADR said `create_pool` sets no `busy_timeout` and that two processes writing one file would therefore fail intermittently. Both halves were wrong for the sqlx version in use.
+
+sqlx 0.9 already applies a five-second `busy_timeout` by default, so the setting was never absent. It is now set explicitly at ten seconds, because a value this operationally significant should be visible in the code rather than inherited from a dependency's default — but raising it fixed nothing, and removing it entirely breaks no test.
+
+The real failure was different and `busy_timeout` cannot help with it. Claiming jobs was written as a SELECT followed by UPDATEs inside a deferred transaction. In WAL mode, upgrading a transaction from reading to writing fails with `SQLITE_BUSY_SNAPSHOT` (code 517) **immediately**, not after the timeout: the reader is holding a snapshot that a concurrent commit has already superseded, and no amount of waiting can reconcile it. Two writers on one file failed within milliseconds.
+
+The fix is to claim in one statement — `UPDATE ... WHERE id IN (SELECT ...) RETURNING ...` — which takes the write lock up front and never upgrades. That is also simpler than the transaction it replaced. Any future queue operation that reads and then writes must either be a single statement or open its transaction as `BEGIN IMMEDIATE`.
+
+## A job stored in a shape this build cannot read
+
+Rows are hydrated defensively, as metrics are. A row whose kind, status or timestamps cannot be read is marked exhausted rather than skipped: skipping leaves it claimable, so the claim would flip it to running, fail to read it, and the stall reclaim would hand it back — a silent loop with no progress and no trace. Marking it exhausted stops the churn and leaves it visible, which is what the queue is for.
+
+## What the worker owns
+
+Reminder scheduling and expired-session cleanup moved out of `tokio::spawn` calls in the server and into the worker, alongside the queue loop and the sweep. The server logs that background work lives elsewhere, because a deployment that runs only the server now silently does no background work at all — `docker-compose` gains a second service, and the image carries both binaries.
+
+Shared wiring moved to `crates/bootstrap`, which both binaries depend on, so there is one object graph rather than two that can drift.
+
+## Two processes starting at the same moment
+
+Both binaries run migrations on startup through the shared factory, so `docker compose up` — or a dev target that launches both — starts two processes racing to migrate one file. Each saw a migration as unapplied, each applied it, and the second `INSERT INTO schema_migrations` failed with `UNIQUE constraint failed`, killing whichever process lost. `depends_on` does not help: it waits for a container to start, not to finish migrating.
+
+The whole migration run now happens inside one `BEGIN IMMEDIATE` transaction, so the second process waits on `busy_timeout` and then finds everything already applied. `BEGIN IMMEDIATE` rather than a plain `BEGIN` because the run reads `schema_migrations` before writing to it, and this document already records what a deferred read-to-write upgrade does in WAL mode.
+
+Making the run safe was preferred to electing one process as the migrator. Coordination would need a startup order the compose file cannot guarantee, and a worker that must not touch the schema is a rule nothing enforces.
+
+A test starts two pools on one file and migrates concurrently. It reliably fails with no transaction at all; it does **not** distinguish `IMMEDIATE` from deferred, because the timing in practice has one run complete before the other upgrades. The choice of `IMMEDIATE` rests on the failure mode proven elsewhere in this document rather than on that test.
diff --git a/docs/adr/0005-provider-connections.md b/docs/adr/0005-provider-connections.md
new file mode 100644
index 0000000..e7bc52b
--- /dev/null
+++ b/docs/adr/0005-provider-connections.md
@@ -0,0 +1,17 @@
+# Provider credentials are stored server-side, encrypted, behind one generic concept
+
+Auto-filling what a User was listening to requires calling their music server. We store a per-User ProviderConnection — a Provider name plus a credential encrypted under a key from the environment — and the server makes the call.
+
+## Considered Options
+
+- **Client-side resolution, no credentials on the server** — the safer default, and preferred on security grounds: a leaked database would expose nothing new. Rejected because the SPA is a browser PWA and would hit CORS and mixed-content restrictions against a self-hosted music server, and each client would have to implement auto-fill separately.
+
+## Consequences
+
+Credentials are sealed with XChaCha20-Poly1305. Authenticated encryption means a tampered ciphertext is rejected rather than decrypting to rubbish, and a random 24-byte nonce stored alongside each ciphertext means the same credential never encrypts to the same bytes twice — so equal ciphertexts cannot reveal that two users share a password.
+
+`EncryptedCredential` renders as `<redacted>` in `Debug`, so a credential cannot reach a log through a derived `Debug` on any type that holds one. The same redaction is applied to the command and request types that carry a plaintext credential in transit.
+
+The database now holds a recoverable credential for another system. The classic Subsonic scheme computes a per-request token from the plaintext password, so the stored secret is password-equivalent. Encryption raises the bar against a stolen database file alone, but a self-hosted single-container deployment usually backs up environment and data together, in which case it buys little — this is accepted knowingly.
+
+The domain does not know what a Provider is or how it is reached. It holds an opaque credential and a name; parsing, authenticating, and calling are entirely adapter concerns, which is what lets a second Provider with a different credential shape (OAuth, API key) be added without touching the domain.
diff --git a/docs/adr/0006-correlation-shows-agreement-not-rankings.md b/docs/adr/0006-correlation-shows-agreement-not-rankings.md
new file mode 100644
index 0000000..b2be6e4
--- /dev/null
+++ b/docs/adr/0006-correlation-shows-agreement-not-rankings.md
@@ -0,0 +1,60 @@
+# Correlations are shown as agreement across strategies, never as ranked findings
+
+Several CorrelationStrategies (Pearson, Spearman, Kendall, mean difference) are computed over the same data and presented side by side. Agreement among them is the headline; no single coefficient is authoritative.
+
+Results are deliberately **not** ranked, not badged with significance, and not surfaced as an "insights" feed.
+
+## Considered Options
+
+- **A ranked insights list with p-values** — by far the most engaging presentation, and rejected for that reason. With roughly 25 MetricKinds tested at conventional thresholds, more than one spurious result is expected per user per run; ranking by strength selects precisely for whichever metric got lucky, and a p-value badge converts that coincidence into a claim someone may act on.
+- **Strict multiple-comparison correction as the only view** — statistically the most defensible, but with this many metrics and a few months of data essentially nothing survives, so the feature reads as broken rather than rigorous and users conclude the tracking was pointless.
+
+## Consequences
+
+Showing several strategies is a robustness check, not a menu. A correlation that holds under all of them is worth attention; one that appears under a single strategy is reporting an outlier or a non-linearity. Presenting them as choices would let a user shop for the flattering number, which is worse than showing one.
+
+Strategies use rank-based methods where possible because Mood is ordinal — the domain asserts that Rad is better than Good, but never that the gap from Awful to Bad equals the gap from Good to Rad, which is what Pearson assumes.
+
+A minimum sample size gates output entirely: below it, no coefficient is returned rather than one computed from a handful of days.
+
+Adjustment is a distinct layer over a set of results, not a strategy. Anything that cannot compute a coefficient for a single metric-mood pair on its own does not belong in the strategy set.
+
+Adjustment is Benjamini-Hochberg, controlling false discovery rate, and it marks results rather than hiding them. Nothing is gated on surviving it. A surviving result is presented as a second axis of robustness beside cross-strategy agreement — it held up once the number of things tested was accounted for — never as a verdict or a significance claim.
+
+FDR is the right family here rather than family-wise error control. A false positive costs a user a behaviour change that achieves nothing; a false negative costs them a real and actionable effect they never discover. In a personal exploratory tool the second is worse, and strict family-wise control needs roughly |r| >= 0.34 over ninety days, which would leave the page empty for months.
+
+Correction applies within a CorrelationStrategy, never across strategies. Several strategies are not several hypotheses — they are several measurements of one, so correcting across them would penalise measuring carefully.
+
+MetricKinds and Activities are corrected as separate Families. A Family is a question, and how many Activities a User chooses to keep has no bearing on whether their sleep tracks their mood — a single Family would let a large Activity catalog quietly suppress metric findings, making the guardrail's strictness depend on a number the User controls for unrelated reasons.
+
+The q threshold and the minimum sample size are configuration, not constants.
+
+MoonPhase is correlated like anything else and is expected to show nothing. It is included because people enjoy it, and it doubles as a control: a strategy set that reports a strong lunar effect is reporting its own false-positive rate.
+
+## What the numbers are
+
+Spearman is computed as Pearson over average ranks, not with the textbook `1 - 6*d^2/(n(n^2-1))` shortcut. That shortcut is only valid when no ranks are tied, and Mood has five levels, so a hundred days of entries are almost entirely ties. On a small worked example the two disagree in the third decimal, and the disagreement grows with the number of ties — it would be a quietly wrong number rather than a visibly broken one.
+
+MoonPhase is correlated as illuminated fraction, from 0 at new to 1 at full, not as position through the cycle. A cycle position is circular: 0.99 and 0.01 are a day apart in the sky and at opposite ends of the number line, so any linear or rank correlation over it measures an artefact of where the cycle was cut. Illumination is monotonic in what a lunar-effect claim is actually about, which is how bright the night is.
+
+A strategy returns nothing rather than a number when either series never varies. A user who logs the same mood every day has no correlation to report, and zero would assert that the metric was tested and found unrelated.
+
+## Comparing across the strategy set
+
+Mean difference is reported as a share of the mood scale rather than in mood points: the difference of the two means is divided by the span from Awful to Rad, so a full mood step reads as 0.25 and the number sits in the same -1..1 range as the three coefficients. Every strategy therefore returns one type with one range, which is what makes a row of them readable side by side. The cost is that "+0.25" no longer says "a quarter of a mood point"; the display has to say what a quarter of the scale means.
+
+Agreement is the size of the largest group of returned coefficients sharing a sign, out of the number of strategies that could score the input at all. Reporting the denominator matters: an Activity can only be scored by mean difference, so it is always one of one, and presenting that as unanimity would imply corroboration that does not exist. The display says "one measure only" instead.
+
+An Activity with no logged day inside the span is not returned. A row with a day count and no coefficient reads as "measured, nothing found"; for an activity the User never tagged, nothing was measured. Preset catalogs make this the common case rather than an edge one — a new account carries two dozen activities it has never used.
+
+## How the adjustment gets its p-values
+
+Benjamini-Hochberg needs a p-value per result, and this document forbids p-values reaching the response or the UI. They are therefore computed, used to decide the mark, and discarded inside the use case; the public result type has no field for one.
+
+They come from normal approximations rather than exact distributions: Fisher's z transform for Pearson and Spearman — with the 1.06 variance inflation for the rank version — the usual large-sample z for Kendall's tau, and Welch's z for mean difference, all through one hand-rolled error function. The domain crate takes no dependencies, so the alternative was an incomplete beta function and a log-gamma, roughly triple the numerical code in exactly the class that is subtly wrong in ways mid-range tests miss. These approximations are sound from around twenty-five paired days and the minimum sample size is thirty, so the error is orders of magnitude below anything that changes a mark. Lowering that floor is the change that would make the approximation the wrong choice.
+
+## Correcting within a group
+
+The grouping rule lives with the Adjustment rather than at the call site: it takes results tagged with their Family and their CorrelationStrategy and corrects within each pair. Grouping by Family and Strategy is today indistinguishable from grouping by Strategy alone, because every Activity is scored by mean difference and no measurement is — the two partitions coincide. It is written and tested as both because the coincidence is an accident of the current strategy set, and a point-biserial correlation over Activity presence would end it without touching this code.
+
+Note the direction of BH's step-up: adding results with small p-values raises the threshold every other result is judged against, so a larger set does not simply make each result work harder. That is why correcting across strategies is not merely conservative — measuring one relationship three ways would let the strongest of the three pull the other two through.
diff --git a/docs/adr/0007-curated-metric-set.md b/docs/adr/0007-curated-metric-set.md
new file mode 100644
index 0000000..b77f675
--- /dev/null
+++ b/docs/adr/0007-curated-metric-set.md
@@ -0,0 +1,22 @@
+# The metric set is deliberately small
+
+Only metrics that can carry signal are stored: steps, sleep minutes, awake minutes, resting heart rate, HRV, exercise minutes, screen time, and alcoholic drinks — plus CycleStart, Weather, and MoonPhase. The originally proposed set was roughly twice this size.
+
+Every MetricKind added costs an expected false positive across the correlation set, so a shorter list is what makes the surviving results credible.
+
+## Rejected, and why
+
+- **Blood oxygen, respiratory rate** — near-constant in healthy people at sea level. Most of their day-to-day movement is measurement error, and nothing can correlate against a constant.
+- **Sleep stage splits (deep, REM, light)** — wrist-based sleep *staging* is weakly validated against polysomnography, unlike sleep/wake detection which is reasonable. Three low-validity metrics inflating the comparison count in the one area already covered well by sleep minutes. Awake minutes is kept because fragmentation is detected far more reliably than stage.
+- **Active energy** — a device estimate derived largely from steps and exercise minutes, both already present.
+- **Average heart rate** — confounded by activity; high precisely on days exercise minutes already explains.
+- **Mindful minutes** — zero for most people on most days. No variance, no correlation.
+- **Water intake** — self-reported, remembered badly, logged inconsistently.
+- **Weight** — day-to-day movement is water, not signal. Meaningful over months, noise over days.
+- **Caffeine** — dropped for a simpler reason: it carries a unit conflict with no clean answer. Providers report milligrams; the manual input is "a coffee". Converting between them is fiction, since drip, espresso, and energy drinks span roughly threefold per serving. Alcohol has no such problem — providers already report a count of standard drinks, so a tap and an import agree natively.
+
+## Consequences
+
+Storing and analysing are the same set; nothing is collected "just in case". Adding a MetricKind later is one enum variant, and HealthKit retains history on-device indefinitely, so a future importer can backfill years for a newly-added kind — the capability is not lost, only the convenience.
+
+MoonPhase is kept despite having no plausible mechanism. It is a control: a strategy set reporting a strong lunar effect is reporting its own false-positive rate.
diff --git a/docs/adr/0008-metric-values-are-an-enum-of-newtypes.md b/docs/adr/0008-metric-values-are-an-enum-of-newtypes.md
new file mode 100644
index 0000000..b0b8723
--- /dev/null
+++ b/docs/adr/0008-metric-values-are-an-enum-of-newtypes.md
@@ -0,0 +1,24 @@
+# A metric's kind and value are one type, not two fields
+
+`MetricValue` is an enum whose every variant wraps its own validated newtype — `Steps(Steps)`, `SleepMinutes(SleepMinutes)`, and so on. `MetricKind` remains as a payload-free discriminant for naming a kind without a value, but it is derived from the value and never stored alongside it.
+
+The obvious shape — a struct holding a kind and a loose numeric value — makes invalid states constructible: a step count tagged as HRV compiles cleanly, because the kind is data and the value is untyped. Collapsing them removes that state from the language rather than from code review.
+
+## Considered Options
+
+- **Trait objects (`Box<dyn Metric>`)** — the more open shape, and consistent with this codebase's use of `dyn` for ports. Rejected because it gives up exhaustiveness: a new metric would compile while correlation and serialization silently failed to handle it, which is precisely the class of error the type system was brought in to catch. Persistence would need a parse-by-kind registry regardless, so the enumeration reappears at the boundary anyway.
+- **`DailyMetric<M: Metric>`** — strictest typing, but mixed metrics cannot share a collection, which defeats iterating every kind to correlate it.
+
+## Consequences
+
+Each newtype validates its own range in `new()`, following the established value-object pattern, and units live in the type rather than in a field name — `Hrv` *is* milliseconds. Eleven near-identical bounded-integer newtypes justify a macro, as `uuid_id!` already does for identity types.
+
+Hydration is fallible in a way entry loading is not: a row can carry a kind this build does not know, or a value a later-tightened range now rejects. Such rows are skipped and recorded in the same rejection trace that receives invalid imports, rather than failing the query.
+
+Correlation needs a numeric projection that necessarily discards the type again. That is confined to one place.
+
+One MetricKind carries exactly one unit. This is what forced caffeine out of the set: providers report milligrams and users report cups, and nothing converts between them honestly.
+
+## The rejection trace, once it existed
+
+The hydration failure this document describes now writes to the same trace that receives invalid imports, as promised. The metric query repository holds a `RejectionCommandPort` and records what it skipped: a read with a side effect, which is unusual enough to name. The alternative was returning the unreadable rows alongside the readable ones and letting a caller decide, which pushes a decision no caller has an opinion about into every one of them. A failure to write the trace is logged and swallowed — a reading that cannot be recorded as unusable must still not fail the query that found it.
diff --git a/docs/adr/0009-manual-metric-writes-win-by-a-domain-rule.md b/docs/adr/0009-manual-metric-writes-win-by-a-domain-rule.md
new file mode 100644
index 0000000..2b66fdc
--- /dev/null
+++ b/docs/adr/0009-manual-metric-writes-win-by-a-domain-rule.md
@@ -0,0 +1,36 @@
+# A manual DailyMetric write wins by a domain rule the store obeys
+
+`DailyMetric::supersedes` decides whether an incoming metric replaces the one already stored for a `(User, Date, MetricKind)`. A metric sourced `Manual` always supersedes; a metric sourced from a Provider supersedes anything except a `Manual` one. The SQLite store reads the existing row inside a transaction, asks the domain, and writes only on a true answer.
+
+The precedence rule is domain knowledge, so it is stated once, in the domain, where it can be tested without a database.
+
+## Considered Options
+
+- **A conditional upsert in SQL** — `ON CONFLICT (user_id, date, kind) DO UPDATE ... WHERE excluded.source = 'manual' OR daily_metrics.source != 'manual'`. One atomic statement and no read. Rejected because the rule then lives in a string the domain tests cannot reach, and the in-memory store used by every application test has to reimplement it by hand — two expressions of one piece of knowledge, free to disagree. The transaction the chosen option needs is a smaller cost than that.
+- **The use case compares before writing** — testable without a database, but the check spans two port calls with no transaction around them, and every future write path is free to forget it. Import (#13) is a second write path, which makes that a matter of when rather than whether.
+
+## Consequences
+
+`DailyMetricCommandPort::save` takes a batch and is the only way a metric reaches storage. Both the SQLite store and `InMemoryDailyMetricStore` call `supersedes`, so a fake that has drifted from the real store fails its own tests.
+
+A refused write is not an error. A Provider importing a day the User has already stated by hand succeeds and changes nothing, because the alternative — failing the import — makes one hand-entered day poison a year of backfill.
+
+## Hydration rejections
+
+A stored row can carry a kind this build does not know, or a value a range tightened since it was written now rejects. Such a row is skipped and logged with its user, date and kind; the surrounding rows are returned. ADR 0008 places these in the same rejection trace that receives invalid imports, and that trace arrives with the import endpoint (#13), which is the consumer that gives it its shape. Until then the record is a log line, and the call site that emits it is the one #13 redirects.
+
+## On the wire
+
+A DailyMetric is read as `{ date, kind, value, provider }`, where an absent `provider` means the User stated the value. One nullable field carries the whole of Source, which keeps the wire in step with the column and leaves no way to describe a metric that is manual and from a Provider at once. A tagged `source` object was the alternative; it spends a nested shape on a distinction one field already makes, and a Provider may legitimately be named `manual`, which rules out flattening the two into a single string.
+
+Writes never carry a source. Every metric arriving over HTTP is `Manual` by construction, because a Provider does not use this endpoint — the import path (#13) builds its own metrics and is the only thing that can produce a Provider source.
+
+## Clearing
+
+A metric is cleared by stating no value for its kind — `{"kind": "steps", "value": null}` on the same `PUT`. There is no delete endpoint: one write path into `daily_metrics` means clearing cannot disagree with writing about what a day holds, and the day sheet gets it for nothing, since emptying a field is already how a person says a reading should not be there.
+
+Clearing removes the row, and a later import for that day is then free to report the kind again. The manual-wins rule therefore covers stated values but not absence: the only way to keep a Provider's reading out for good is to state one you believe.
+
+A tombstone — a cleared kind that stays cleared until the User states a value — was the alternative, and it would close that gap. It was rejected because it needs a DailyMetric that exists with no value, which the domain deliberately cannot express: `MetricValue` is not optional, and making it optional to record an absence would put `None` into every match over every kind, for one case. The gap it leaves is small in practice, because a Provider re-reporting what it already reported is the store telling the truth about what that Provider says.
+
+A request naming the same kind twice is refused rather than resolved by order, because "state 8412 steps and also clear steps" has no reading that is obviously right.
diff --git a/docs/adr/0010-cycle-progress-is-correlated-not-cycle-day.md b/docs/adr/0010-cycle-progress-is-correlated-not-cycle-day.md
new file mode 100644
index 0000000..b00d63f
--- /dev/null
+++ b/docs/adr/0010-cycle-progress-is-correlated-not-cycle-day.md
@@ -0,0 +1,24 @@
+# The cycle is correlated as progress, not as a cycle day
+
+Cycle day is derived from the most recent preceding CycleStart and never stored, exactly as MoonPhase is derived from the calendar. What gets correlated against DayMood is progress through the cycle — 0 on its first day, 1 on its last — not the day number.
+
+A cycle day is cyclical, so correlating it directly measures where the cycle happens to have been cut rather than anything about the person: day 1 and day 28 are neighbours in life and at opposite ends of the number line. This is the same defect that rules out correlating the moon's position through its cycle, and it is why MoonPhase is correlated as illuminated fraction instead.
+
+## Considered Options
+
+- **The folded transform used for MoonPhase**, `(1 - cos 2*pi*p) / 2`. Rejected here even though it is right there: it maps day 7 and day 21 to the same value, conflating the follicular and luteal halves — which is precisely the distinction anyone asking this question cares about. For the moon the fold is not a transform at all, it is the physical quantity; for a cycle it destroys the signal.
+- **A sin/cos pair, correlated as two inputs.** The standard treatment of a circular variable, and it can see a symmetric effect at both ends of the cycle. Rejected for now because it doubles the comparison count in the Measurements Family for one input, and neither component means anything a User could read.
+
+## Consequences
+
+Progress answers "does mood drift across the cycle" and cannot answer "is mood worse at both ends". That limit is real and worth stating: a symmetric premenstrual-and-menstrual dip would show as no correlation at all. Whoever wants that question answered needs the sin/cos pair, and should know that is what it costs.
+
+Progress needs a cycle length. A closed cycle has its own: the days until the next CycleStart. The cycle still running has none, so the median of the observed lengths is used, falling back to twenty-eight when nothing has been observed. The median rather than the mean because one missed CycleStart produces a double-length cycle, which would drag a mean and barely move a median.
+
+Progress is clamped to 1. A cycle running late would otherwise report progress above 1, which is not a place in a cycle.
+
+## Being off by default
+
+The whole feature is invisible until the User turns it on, so the tracking flag gates recording, the derived cycle day on the calendar, and whether CycleProgress is a correlation input at all. Turning it off hides everything and forgets nothing — a preference is not a delete.
+
+The flag lives on a UserPreferences record rather than as a column on User. User already carries nine fields of identity and credentials, and a display preference sitting beside the password hash is the wrong neighbourhood; the next optional feature now has somewhere to go.
diff --git a/docs/adr/0011-backing-up-and-sharing-are-different-artifacts.md b/docs/adr/0011-backing-up-and-sharing-are-different-artifacts.md
new file mode 100644
index 0000000..37dc508
--- /dev/null
+++ b/docs/adr/0011-backing-up-and-sharing-are-different-artifacts.md
@@ -0,0 +1,32 @@
+# Backing up and sharing are two artifacts, not one with options
+
+A CompleteBackup carries everything an account knows. A ShareableExtract carries mood, Content and Activities as a readable markdown document, and nothing else. They are separate endpoints with separate names and separate file extensions.
+
+A single export with checkboxes was rejected. It produces files that look like backups and are not, and the failure mode — someone sharing the wrong file — surfaces only after the disclosure has happened.
+
+## Considered Options
+
+- **A zip of JSON for the extract too**, matching the backup. Rejected because the extract exists to be read by a person: a therapist handed a zip of JSON has been handed nothing. Markdown also makes the distinction visible at the moment of download, where it matters.
+- **Restoring through the existing importer.** Rejected for the same reason the split exists. That importer reads foreign formats — Daylio, generic CSV — and its `ImportedRow` knows only mood, date, activities and a note. Teaching it about metrics, cycle starts, reminders and preferences would make every foreign format carry empty fields for them, and would put a Daylio file and a complete backup through one path with very different expectations. Restore is its own endpoint.
+
+## One place to register a dimension
+
+Entry dimensions are written to and read from the backup through `DimensionPayload`, the enum in `api-types` that already maps every `DimensionValue` variant to a wire shape for the HTTP API. Adding a `DimensionValue` variant fails to compile until it is mapped there, and the backup picks it up with no further change. Registration is therefore enforced by the compiler rather than remembered from a document.
+
+This makes an adapter depend on `api-types`, which is unusual here. It is deliberate: a backup file is a wire format, and the alternative was a second exhaustive match over every dimension that could silently fall behind the first.
+
+## Identity across a restore
+
+A backup stores Activity ids alongside their names, and media under their original ids, because entries reference all three by id. A restore mints new ids — media storage assigns them, and an Activity that already exists in the target account keeps the id it has — so the restore builds a translation from old id to new and rewrites each entry's Activities, Photos and VoiceMemos dimensions through it. Without that, every restored entry would reference identifiers that no longer exist and the tags would silently vanish.
+
+An id that cannot be translated is dropped from its dimension rather than restored as a dangling reference.
+
+## What a backup deliberately omits
+
+ApiTokens are absent. They are credentials, not data about days, and restoring one would resurrect a secret the User may have revoked deliberately.
+
+RejectedMetrics are absent. The trace records readings that were never stored; carrying a record of absence into a restore has nothing to restore.
+
+## Restore adds, it never replaces
+
+A restore writes into the account as it stands. This is the honest behaviour for the merge the code performs, and it means restoring twice duplicates entries — the importer's `(logged_at, mood)` dedup does not apply on this path. The alternative, clearing the account first, is a destructive act hidden inside an action a User reaches for when something has already gone wrong.
diff --git a/docs/adr/0012-weather-is-observed-after-the-fact.md b/docs/adr/0012-weather-is-observed-after-the-fact.md
new file mode 100644
index 0000000..b4a4ee2
--- /dev/null
+++ b/docs/adr/0012-weather-is-observed-after-the-fact.md
@@ -0,0 +1,29 @@
+# Weather is observed after the entry is saved, in the domain's own vocabulary
+
+Weather is resolved server-side from an entry's Location, after the entry is written, and stored as a Condition drawn from a closed vocabulary plus a temperature in celsius. It is always attributed to the Provider that observed it.
+
+Logging a mood is the most latency-sensitive thing the app does, so it cannot wait on a third party. The lookup is an `ObserveWeather` job, swept from "entries with a Location and no Weather" — which satisfies ADR 0004's rule, so losing a queued job costs promptness and never data.
+
+## Considered Options
+
+- **Client-supplied weather.** Three clients would each pick a provider, a vocabulary and a unit, and correlating across inconsistent labels is meaningless. Resolving on the server gives one implementation and one vocabulary.
+- **OpenWeatherMap.** Better known, but historical data is a paid tier, so the sweeper could only enrich recent entries — and every self-hoster would need to register a key before weather worked at all. Open-Meteo needs no key, serves history by coordinate and date, and publishes WMO condition codes as a documented integer scale, so the mapping to our vocabulary is a table rather than a guess.
+- **Storing the provider's own description.** Rejected: "light intensity shower rain" is not comparable with anything.
+
+## What the vocabulary carries
+
+Condition and temperature. Both plausibly move mood, both are comparable across any two entries, and both correlate — condition as a category, temperature as a continuous input in the Measurements Family. Daylight was considered and left out: it is derivable from coordinates and time with no provider at all, and it is a fact about the calendar and latitude rather than about weather, so it belongs beside MoonPhase if it is wanted.
+
+The vocabulary is deliberately coarse. Open-Meteo distinguishes slight, moderate and dense drizzle; all three are `drizzle` here. A finer vocabulary would multiply the categories without adding signal, and every Provider draws those lines differently.
+
+## Weather cannot be edited away
+
+Every other dimension repository deletes its row when a save arrives without that dimension — that is how a User clears a note or removes a photo. Weather does not. The worker writes it after the fact, and no client ever sends it back, so honouring absence as deletion would mean any edit silently erased it. Absence from a user-supplied dimension list means "not mentioned", and for an observed dimension that is not a request to delete.
+
+## The switch is a switch, not a filter
+
+`worker.look_up_weather = false` means no coordinates leave the machine. It is enforced by not constructing the lookup at all, so there is nothing that could make a request. It also stops the weather sweep entirely: an early version left the sweep running, which enqueued jobs that failed on every attempt until they exhausted — churn and noise for someone who deliberately turned the feature off. If weather cannot be observed there is no weather backlog. Turning it back on catches up the whole backlog on the next sweep.
+
+## What is not built
+
+The issue asks for backlogged lookups to be grouped by rounded coordinates and date range so a backlog collapses into few requests. It is not implemented: each job resolves one entry with one request. Open-Meteo accepts a date range for one coordinate, so the grouping is possible, but it needs a batch shape the job queue does not have — one job would have to stand for many entries, which breaks the one-job-one-subject rule the queue and its sweep are built on. The realistic backlog is small, as this ADR's own reasoning notes: imported history carries no coordinates, so nothing but an outage or an offline client produces one. The sweep's configured bound is the guard until that stops being true.
diff --git a/docs/adr/0013-configuration-layers-defaults-file-environment.md b/docs/adr/0013-configuration-layers-defaults-file-environment.md
new file mode 100644
index 0000000..fa53e3a
--- /dev/null
+++ b/docs/adr/0013-configuration-layers-defaults-file-environment.md
@@ -0,0 +1,37 @@
+# Configuration arrives in three layers: defaults, then the file, then the environment
+
+Every setting has a compiled-in default. `config.toml` overrides the defaults it names. Environment variables prefixed `KMOOD_` override both. The layering is one expression in `crates/config/src/loader.rs`, so a new setting is a new struct field and nothing else.
+
+A single underscore stays inside a field name, a double underscore descends a section: `KMOOD_AUTH__JWT_SECRET` reaches `auth.jwt_secret`, and `KMOOD_SERVER__CORS__ALLOW_ANY_ORIGIN` reaches two levels down. Splitting on a single underscore would have been ambiguous the moment a field was called `data_dir`.
+
+## Why the environment had to reach everything
+
+CODE_STYLE has always said secrets live in environment variables and tunables live in the file. Until this change nothing in the workspace read an environment variable at all, so `auth.jwt_secret`, `push.vapid_private_key`, `provider.encryption_key` and the S3 keys were only settable by writing them into a file next to the binary — the arrangement the rule exists to prevent.
+
+Stopping at secrets would have honoured the letter of that rule and left the useful half undone. A container that cannot be told its own port or data directory needs a bind-mounted file to differ from any other container running the same image, which puts deployment shape back into a committed artifact. The rule is a floor: secrets *must* be settable from the environment. It is not a ceiling.
+
+## Considered Options
+
+- **A hand-rolled overlay.** Read each variable in `bootstrap` and assign the field. No new dependency and completely transparent, but roughly a hundred and fifty lines that must be edited every time a setting is added — a second place to update for one logical change, which is the thing "single call, cascading changes" exists to forbid. Rejected: the cost is paid forever, by whoever adds the next field.
+- **`config-rs`.** Does the same layering, but the crate is named `config` and so is ours. Every import in the crate would need renaming to stay readable. Rejected on the name alone.
+- **`figment`.** Layering is its whole purpose, it reads the `serde` derives already on these structs, and it needed no change to any of the ten config types — not even a `Serialize` derive, because container-level `#[serde(default)]` already supplies the base layer. Chosen.
+
+## Why loading moved out of bootstrap
+
+The loader used to live in `bootstrap`, which the testing table in CODE_STYLE marks as untested by design. Precedence between three layers is exactly the logic that needs pinning, and it cannot be pinned where tests are not written. So `load()` now sits in `crates/config` beside the types it populates, and `bootstrap` re-exports it so the binaries are unchanged.
+
+This also puts the defaults and the means of overriding them in one crate. `AppConfig::default()` and the layering that overrides it were previously two crates apart, and only one of them was reachable from a test.
+
+## Refusal is better than a silent default
+
+A malformed `config.toml`, or a variable that cannot be parsed as its field's type, fails startup. figment names the offending key — `invalid type: found string "not-a-port", expected u16 for key "SERVER.PORT"` — which is worth more than a server that comes up on a port nobody chose.
+
+A missing `config.toml` is not an error: the defaults are a complete configuration and running with no file is a supported way to run. But a file *named* by `KMOOD_CONFIG_FILE` and not found is an error, because naming it is a statement that it exists, and silently ignoring the typo would start the server with settings the operator did not choose.
+
+## What is logged
+
+The file that was read, and the *names* of the `KMOOD_` variables that took effect. Never their values: four of the settings reachable this way are secrets, and a log line is the wrong place to learn one.
+
+## Lists are arrays, not delimited strings
+
+`KMOOD_SERVER__CORS__ALLOWED_ORIGINS=["https://a.example","https://b.example"]`. A comma-separated form would read more naturally in a shell, but it would be a second syntax for the same data, parsed differently from the file. One syntax, one parser.
diff --git a/spa/.prettierignore b/spa/.prettierignore
index 5322d7f..aeffbfd 100644
--- a/spa/.prettierignore
+++ b/spa/.prettierignore
@@ -1,3 +1,9 @@
 package-lock.json
 pnpm-lock.yaml
-yarn.lock
\ No newline at end of file
+yarn.lock
+bun.lock
+dist
+
+# Regenerated by TanStack Router on every build, and its own header asks to be
+# excluded from linters and formatters.
+src/routeTree.gen.ts
diff --git a/spa/eslint.config.js b/spa/eslint.config.js
index ebffd33..2a878eb 100644
--- a/spa/eslint.config.js
+++ b/spa/eslint.config.js
@@ -15,6 +15,20 @@ export default [
     },
   },
   {
-    ignores: ["eslint.config.js", ".prettierrc"],
+    ignores: [
+      "eslint.config.js",
+      ".prettierrc",
+      // Plain JS outside the TypeScript project, so the type-aware rules
+      // cannot parse it at all.
+      "public/**",
+      // Regenerated by TanStack Router on every build; its own header asks to
+      // be excluded from linters.
+      "src/routeTree.gen.ts",
+      // Vendored from the shadcn registry and re-fetched by `shadcn add`, so a
+      // fix here does not survive. Its optional chains guard against runtime
+      // shapes that are looser than the types third-party libraries declare,
+      // which is exactly what no-unnecessary-condition cannot see.
+      "src/components/ui/**",
+    ],
   },
 ]
diff --git a/spa/src/api/client.ts b/spa/src/api/client.ts
index 238025e..4ca5d75 100644
--- a/spa/src/api/client.ts
+++ b/spa/src/api/client.ts
@@ -6,7 +6,6 @@ import {
   AuthTokenResponse,
   BulkActionResponse,
   CalendarDayResponse,
-  CorrelationResponse,
   EntryResponse,
   ImportResultResponse,
   MediaIdResponse,
@@ -14,20 +13,35 @@ import {
   ReminderResponse,
   UserResponse,
   VapidKeyResponse,
-  type ChangePasswordRequest,
-  type CreateActivityRequest,
-  type CreateEntryRequest,
-  type CreateReminderRequest,
-  type DateRangeParams,
-  type ListEntriesParams,
-  type LoginRequest,
-  type RegisterRequest,
-  type RenameActivityRequest,
-  type ReplaceActivityRequest,
-  type SetCategoryRequest,
-  type UpdateEntryRequest,
-  type UpdateProfileRequest,
-  type UpdateReminderRequest,
+  ProviderConnectionResponse,
+  DailyMetricResponse,
+  RejectionResponse,
+  RestoreOutcomeResponse,
+  CycleViewResponse,
+  PreferencesResponse,
+  ApiTokenResponse,
+  MintedApiTokenResponse,
+  CorrelationRowResponse,
+  DimensionPayload,
+} from "./schema"
+import type {
+  ChangePasswordRequest,
+  CreateActivityRequest,
+  CreateEntryRequest,
+  DateSpanParams,
+  MetricPayload,
+  SubsonicCredential,
+  CreateReminderRequest,
+  DateRangeParams,
+  ListEntriesParams,
+  LoginRequest,
+  RegisterRequest,
+  RenameActivityRequest,
+  ReplaceActivityRequest,
+  SetCategoryRequest,
+  UpdateEntryRequest,
+  UpdateProfileRequest,
+  UpdateReminderRequest,
 } from "./schema"
 
 const api = axios.create({
@@ -124,7 +138,7 @@ async function request<T>(
 }
 
 async function requestVoid(
-  method: "post" | "patch" | "delete",
+  method: "post" | "put" | "patch" | "delete",
   path: string,
   data?: unknown
 ): Promise<void> {
@@ -168,6 +182,87 @@ export const auth = {
     requestVoid("post", "/api/v1/auth/logout", { refreshToken }),
 }
 
+// ── Providers ───────────────────────────────────────────────────
+
+export const providers = {
+  list: () =>
+    request("get", "/api/v1/providers", ProviderConnectionResponse.array()),
+
+  connect: (provider: string, credential: SubsonicCredential) =>
+    requestVoid("put", `/api/v1/providers/${provider}`, { credential }),
+
+  disconnect: (provider: string) =>
+    requestVoid("delete", `/api/v1/providers/${provider}`),
+
+  nowPlaying: () =>
+    request(
+      "get",
+      "/api/v1/providers/now-playing",
+      DimensionPayload.nullable()
+    ),
+}
+
+// ── Cycle ───────────────────────────────────────────────────────
+
+export const cycle = {
+  read: () => request("get", "/api/v1/cycle", CycleViewResponse),
+
+  record: (date: string) => requestVoid("put", `/api/v1/cycle/${date}`),
+
+  forget: (date: string) => requestVoid("delete", `/api/v1/cycle/${date}`),
+
+  preferences: () =>
+    request("get", "/api/v1/users/me/preferences", PreferencesResponse),
+
+  setTracking: (tracksCycle: boolean) =>
+    request("patch", "/api/v1/users/me/preferences", PreferencesResponse, {
+      tracksCycle,
+    }),
+}
+
+// ── API tokens ──────────────────────────────────────────────────
+
+export const tokens = {
+  list: () => request("get", "/api/v1/tokens", ApiTokenResponse.array()),
+
+  mint: (name: string) =>
+    request("post", "/api/v1/tokens", MintedApiTokenResponse, { name }),
+
+  revoke: (id: string) => requestVoid("delete", `/api/v1/tokens/${id}`),
+}
+
+// ── Correlations ────────────────────────────────────────────────
+
+export const correlations = {
+  list: (params: DateSpanParams) =>
+    request(
+      "get",
+      "/api/v1/correlations",
+      CorrelationRowResponse.array(),
+      undefined,
+      params
+    ),
+}
+
+// ── Daily metrics ───────────────────────────────────────────────
+
+export const metrics = {
+  list: (params: DateSpanParams) =>
+    request(
+      "get",
+      "/api/v1/metrics",
+      DailyMetricResponse.array(),
+      undefined,
+      params
+    ),
+
+  set: (date: string, values: MetricPayload[]) =>
+    requestVoid("put", `/api/v1/metrics/${date}`, { metrics: values }),
+
+  rejections: () =>
+    request("get", "/api/v1/metrics/rejections", RejectionResponse.array()),
+}
+
 // ── Entries ─────────────────────────────────────────────────────
 
 export const entries = {
@@ -232,15 +327,6 @@ export const entries = {
       `/api/v1/entries/filter/activity/${activityId}`,
       EntryResponse.array()
     ),
-
-  correlation: (activityId: string, params?: { from?: string; to?: string }) =>
-    request(
-      "get",
-      `/api/v1/entries/correlation/${activityId}`,
-      CorrelationResponse,
-      undefined,
-      params
-    ),
 }
 
 // ── Activities ──────────────────────────────────────────────────
@@ -325,19 +411,26 @@ export const media = {
 // ── Data ────────────────────────────────────────────────────────
 
 export const data = {
-  export: async (): Promise<Blob> => {
-    try {
-      const res = await api.get("/api/v1/data/export", { responseType: "blob" })
-      return res.data as Blob
-    } catch (err) {
-      return handleError(err)
-    }
-  },
+  completeBackup: () => download("/api/v1/data/backup"),
+
+  shareableExtract: () => download("/api/v1/data/extract"),
+
+  restore: (file: File) =>
+    uploadForm("/api/v1/data/restore", file, RestoreOutcomeResponse),
 
   import: (file: File) =>
     uploadForm("/api/v1/data/import", file, ImportResultResponse),
 }
 
+async function download(path: string): Promise<Blob> {
+  try {
+    const res = await api.get(path, { responseType: "blob" })
+    return res.data as Blob
+  } catch (err) {
+    return handleError(err)
+  }
+}
+
 // ── Push ───────────────────────────────────────────────────────
 
 export const push = {
diff --git a/spa/src/api/schema.ts b/spa/src/api/schema.ts
index 824b4a2..80ffc13 100644
--- a/spa/src/api/schema.ts
+++ b/spa/src/api/schema.ts
@@ -23,17 +23,48 @@ export const ActivityResponse = z.object({
 })
 export type ActivityResponse = z.infer<typeof ActivityResponse>
 
+export const DimensionPayload = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("content"), text: z.string() }),
+  z.object({ kind: z.literal("activities"), ids: z.array(uuid) }),
+  z.object({ kind: z.literal("photos"), ids: z.array(uuid) }),
+  z.object({ kind: z.literal("voiceMemos"), ids: z.array(uuid) }),
+  z.object({
+    kind: z.literal("location"),
+    latitude: z.number().min(-90).max(90),
+    longitude: z.number().min(-180).max(180),
+  }),
+  z.object({
+    kind: z.literal("song"),
+    title: z.string(),
+    artist: z.string(),
+    album: z.string().optional(),
+    recordingId: uuid.optional(),
+  }),
+  z.object({
+    kind: z.literal("weather"),
+    condition: z.enum([
+      "clear",
+      "cloudy",
+      "fog",
+      "drizzle",
+      "rain",
+      "snow",
+      "thunderstorm",
+    ]),
+    temperature: z.number(),
+    observedBy: z.string(),
+  }),
+])
+export type DimensionPayload = z.infer<typeof DimensionPayload>
+
 export const EntryResponse = z.object({
   id: uuid,
   userId: uuid,
   mood: Mood,
   moodLabel: z.string(),
   loggedAt: datetime,
-  activities: z.array(uuid),
-  content: z.string().nullable(),
-  photos: z.array(uuid),
+  dimensions: z.array(DimensionPayload),
   photoUrls: z.array(z.string()),
-  voiceMemos: z.array(uuid),
   voiceMemoUrls: z.array(z.string()),
   createdAt: datetime,
   updatedAt: datetime,
@@ -43,8 +74,10 @@ export type EntryResponse = z.infer<typeof EntryResponse>
 export const CalendarDayResponse = z.object({
   date: date,
   entries: z.array(EntryResponse),
-  dominantMood: Mood.nullable(),
-  dominantMoodLabel: z.string().nullable(),
+  dayMood: z.number().nullable(),
+  mood: Mood.nullable(),
+  moodLabel: z.string().nullable(),
+  cycleDay: z.int().nullable(),
 })
 export type CalendarDayResponse = z.infer<typeof CalendarDayResponse>
 
@@ -98,12 +131,6 @@ export const BulkActionResponse = z.object({
 })
 export type BulkActionResponse = z.infer<typeof BulkActionResponse>
 
-export const CorrelationResponse = z.object({
-  activityId: uuid,
-  correlation: z.number().nullable(),
-})
-export type CorrelationResponse = z.infer<typeof CorrelationResponse>
-
 export const ImportResultResponse = z.object({
   imported: z.number(),
   skipped: z.number(),
@@ -155,20 +182,14 @@ export type RegisterRequest = z.infer<typeof RegisterRequest>
 export const CreateEntryRequest = z.object({
   mood: Mood,
   loggedAt: z.string().optional(),
-  activityIds: z.array(z.string()).optional(),
-  content: z.string().optional(),
-  photoIds: z.array(z.string()).optional(),
-  voiceMemoIds: z.array(z.string()).optional(),
+  dimensions: z.array(DimensionPayload).optional(),
 })
 export type CreateEntryRequest = z.infer<typeof CreateEntryRequest>
 
 export const UpdateEntryRequest = z.object({
   mood: Mood,
   loggedAt: z.string().optional(),
-  activityIds: z.array(z.string()).optional(),
-  content: z.string().optional(),
-  photoIds: z.array(z.string()).optional(),
-  voiceMemoIds: z.array(z.string()).optional(),
+  dimensions: z.array(DimensionPayload).optional(),
 })
 export type UpdateEntryRequest = z.infer<typeof UpdateEntryRequest>
 
@@ -238,3 +259,149 @@ export const DateRangeParams = z.object({
   to: z.string(),
 })
 export type DateRangeParams = z.infer<typeof DateRangeParams>
+
+export const ProviderConnectionResponse = z.object({
+  provider: z.string(),
+  connectedAt: datetime,
+})
+export type ProviderConnectionResponse = z.infer<
+  typeof ProviderConnectionResponse
+>
+
+export const MetricKind = z.enum([
+  "steps",
+  "sleepMinutes",
+  "awakeMinutes",
+  "restingHeartRate",
+  "hrv",
+  "exerciseMinutes",
+  "screenTimeMinutes",
+  "alcoholicDrinks",
+])
+export type MetricKind = z.infer<typeof MetricKind>
+
+export const DailyMetricResponse = z.object({
+  date: date,
+  kind: MetricKind,
+  value: z.int(),
+  provider: z.string().optional(),
+})
+export type DailyMetricResponse = z.infer<typeof DailyMetricResponse>
+
+export const MetricPayload = z.object({
+  kind: MetricKind,
+  value: z.int().nullable(),
+})
+export type MetricPayload = z.infer<typeof MetricPayload>
+
+export const SetDailyMetricsRequest = z.object({
+  metrics: z.array(MetricPayload),
+})
+export type SetDailyMetricsRequest = z.infer<typeof SetDailyMetricsRequest>
+
+export const DateSpanParams = z.object({
+  from: date,
+  to: date,
+})
+export type DateSpanParams = z.infer<typeof DateSpanParams>
+
+export const CorrelationInputPayload = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("metric"), metric: MetricKind }),
+  z.object({ kind: z.literal("moonPhase") }),
+  z.object({
+    kind: z.literal("activity"),
+    activityId: uuid,
+    name: z.string(),
+  }),
+])
+export type CorrelationInputPayload = z.infer<typeof CorrelationInputPayload>
+
+export const StrategyScoreResponse = z.object({
+  strategy: z.string(),
+  coefficient: z.number(),
+  heldUp: z.boolean(),
+})
+export type StrategyScoreResponse = z.infer<typeof StrategyScoreResponse>
+
+export const AgreementResponse = z.object({
+  agreeing: z.int(),
+  applicable: z.int(),
+})
+export type AgreementResponse = z.infer<typeof AgreementResponse>
+
+export const CorrelationRowResponse = z.object({
+  input: CorrelationInputPayload,
+  sampleSize: z.int(),
+  agreement: AgreementResponse,
+  scores: z.array(StrategyScoreResponse),
+})
+export type CorrelationRowResponse = z.infer<typeof CorrelationRowResponse>
+
+export const ApiTokenResponse = z.object({
+  id: uuid,
+  name: z.string(),
+  scope: z.string(),
+  createdAt: datetime,
+  lastUsedAt: datetime.nullable(),
+})
+export type ApiTokenResponse = z.infer<typeof ApiTokenResponse>
+
+export const MintedApiTokenResponse = z.object({
+  token: ApiTokenResponse,
+  secret: z.string(),
+})
+export type MintedApiTokenResponse = z.infer<typeof MintedApiTokenResponse>
+
+export const MintApiTokenRequest = z.object({
+  name: z.string(),
+})
+export type MintApiTokenRequest = z.infer<typeof MintApiTokenRequest>
+
+export const RejectionResponse = z.object({
+  id: uuid,
+  origin: z.enum(["import", "storedRow"]),
+  provider: z.string().nullable(),
+  date: date.nullable(),
+  kind: z.string(),
+  value: z.int().nullable(),
+  reason: z.string(),
+  recordedAt: datetime,
+})
+export type RejectionResponse = z.infer<typeof RejectionResponse>
+
+export const PreferencesResponse = z.object({
+  tracksCycle: z.boolean(),
+})
+export type PreferencesResponse = z.infer<typeof PreferencesResponse>
+
+export const CyclePositionResponse = z.object({
+  day: z.int(),
+  progress: z.number(),
+})
+export type CyclePositionResponse = z.infer<typeof CyclePositionResponse>
+
+export const CycleViewResponse = z.object({
+  tracking: z.boolean(),
+  starts: z.array(date),
+  today: CyclePositionResponse.nullable(),
+  usualLength: z.int(),
+})
+export type CycleViewResponse = z.infer<typeof CycleViewResponse>
+
+export const RestoreOutcomeResponse = z.object({
+  entries: z.int(),
+  metrics: z.int(),
+  cycleStarts: z.int(),
+  activities: z.int(),
+  reminders: z.int(),
+  media: z.int(),
+  unreadable: z.array(z.string()),
+})
+export type RestoreOutcomeResponse = z.infer<typeof RestoreOutcomeResponse>
+
+export const SubsonicCredential = z.object({
+  url: z.string(),
+  username: z.string(),
+  password: z.string(),
+})
+export type SubsonicCredential = z.infer<typeof SubsonicCredential>
diff --git a/spa/src/components/entry/entry-card.tsx b/spa/src/components/entry/entry-card.tsx
index 9327b5c..fba17c4 100644
--- a/spa/src/components/entry/entry-card.tsx
+++ b/spa/src/components/entry/entry-card.tsx
@@ -1,3 +1,4 @@
+import { contentOf } from "@/lib/dimensions"
 import { format } from "date-fns"
 import { Link } from "@tanstack/react-router"
 import { Card, CardContent } from "@/components/ui/card"
@@ -23,9 +24,9 @@ export function EntryCard({ entry }: EntryCardProps) {
                 {format(date, "h:mm a")}
               </span>
             </div>
-            {entry.content && (
+            {contentOf(entry) && (
               <p className="mt-1 line-clamp-2 text-sm text-muted-foreground">
-                {entry.content}
+                {contentOf(entry)}
               </p>
             )}
           </div>
diff --git a/spa/src/components/entry/entry-form.tsx b/spa/src/components/entry/entry-form.tsx
index 67e0de5..fb97f73 100644
--- a/spa/src/components/entry/entry-form.tsx
+++ b/spa/src/components/entry/entry-form.tsx
@@ -2,23 +2,27 @@ import { useState } from "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 { 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 { 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 { fromLoggedAt, toLoggedAt } from "@/lib/logged-at"
+import type { DimensionPayload } from "@/api/schema"
 
 export interface EntryFormData {
   mood: number
-  content?: string
-  activityIds?: string[]
-  photoIds?: string[]
-  voiceMemoIds?: string[]
+  loggedAt: string
+  dimensions?: DimensionPayload[]
 }
 
 interface EntryFormProps {
@@ -28,10 +32,13 @@ interface EntryFormProps {
   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
   }
 }
 
@@ -45,6 +52,9 @@ export function EntryForm({
   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 ?? []
@@ -55,7 +65,57 @@ export function EntryForm({
   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 { data: activities } = useActivities()
 
   const toggleActivity = (id: string) => {
@@ -83,10 +143,15 @@ export function EntryForm({
 
       onSubmit({
         mood,
-        content: content.trim() || undefined,
-        activityIds: selectedActivities.length ? selectedActivities : undefined,
-        photoIds: photoIds.length ? photoIds : undefined,
-        voiceMemoIds: voiceMemoIds.length ? voiceMemoIds : undefined,
+        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" })
@@ -103,6 +168,15 @@ export function EntryForm({
 
       <MoodPicker value={mood} onChange={setMood} size="lg" />
 
+      <Card>
+        <CardHeader className="pb-2">
+          <CardTitle className="text-sm">Logged</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <LoggedAtPicker value={loggedAt} onChange={setLoggedAt} />
+        </CardContent>
+      </Card>
+
       {activities?.length ? (
         <Card>
           <CardHeader className="pb-2">
@@ -132,6 +206,69 @@ export function EntryForm({
         </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>
+          )}
+        </CardContent>
+      </Card>
+
       <Card>
         <CardHeader className="pb-2">
           <CardTitle className="text-sm">Photos</CardTitle>
diff --git a/spa/src/components/entry/entry-list.tsx b/spa/src/components/entry/entry-list.tsx
index babffae..983ef05 100644
--- a/spa/src/components/entry/entry-list.tsx
+++ b/spa/src/components/entry/entry-list.tsx
@@ -13,12 +13,12 @@ export function EntryList({ entries, limit }: EntryListProps) {
 
   return (
     <div className="flex flex-col gap-4">
-      {grouped.map(({ label, entries }) => (
+      {grouped.map(({ label, entries: onThatDay }) => (
         <div key={label} className="flex flex-col gap-2">
           <h3 className="text-xs font-medium tracking-wide text-muted-foreground uppercase">
             {label}
           </h3>
-          {entries.map((entry) => (
+          {onThatDay.map((entry) => (
             <EntryCard key={entry.id} entry={entry} />
           ))}
         </div>
@@ -42,9 +42,9 @@ function groupByDay(
     groups.get(key)!.push(entry)
   }
 
-  return Array.from(groups.entries()).map(([key, entries]) => ({
+  return Array.from(groups.entries()).map(([key, onThatDay]) => ({
     label: formatDayLabel(new Date(key)),
-    entries,
+    entries: onThatDay,
   }))
 }
 
diff --git a/spa/src/components/entry/entry-weather.tsx b/spa/src/components/entry/entry-weather.tsx
new file mode 100644
index 0000000..d7074f7
--- /dev/null
+++ b/spa/src/components/entry/entry-weather.tsx
@@ -0,0 +1,41 @@
+import {
+  Cloud,
+  CloudDrizzle,
+  CloudFog,
+  CloudLightning,
+  CloudRain,
+  Snowflake,
+  Sun,
+} from "lucide-react"
+import type { LucideIcon } from "lucide-react"
+import { weatherOf } from "@/lib/dimensions"
+import type { EntryResponse } from "@/api/schema"
+
+type Condition = NonNullable<ReturnType<typeof weatherOf>>["condition"]
+
+const LOOKS_LIKE: Record<Condition, { icon: LucideIcon; label: string }> = {
+  clear: { icon: Sun, label: "Clear" },
+  cloudy: { icon: Cloud, label: "Cloudy" },
+  fog: { icon: CloudFog, label: "Fog" },
+  drizzle: { icon: CloudDrizzle, label: "Drizzle" },
+  rain: { icon: CloudRain, label: "Rain" },
+  snow: { icon: Snowflake, label: "Snow" },
+  thunderstorm: { icon: CloudLightning, label: "Thunderstorm" },
+}
+
+export function EntryWeather({ entry }: { entry: EntryResponse }) {
+  const weather = weatherOf(entry)
+  if (!weather) return null
+
+  const { icon: Icon, label } = LOOKS_LIKE[weather.condition]
+
+  return (
+    <span
+      className="flex items-center gap-1.5 text-xs text-muted-foreground"
+      title={`Observed by ${weather.observedBy}`}
+    >
+      <Icon className="h-3.5 w-3.5" />
+      {label}, {Math.round(weather.temperature)}°C
+    </span>
+  )
+}
diff --git a/spa/src/components/entry/logged-at-picker.tsx b/spa/src/components/entry/logged-at-picker.tsx
new file mode 100644
index 0000000..58fbb1b
--- /dev/null
+++ b/spa/src/components/entry/logged-at-picker.tsx
@@ -0,0 +1,63 @@
+import { useState } from "react"
+import { format } from "date-fns"
+import { CalendarIcon } from "lucide-react"
+
+import { buttonVariants } from "@/components/ui/button"
+import { Calendar } from "@/components/ui/calendar"
+import { Input } from "@/components/ui/input"
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@/components/ui/popover"
+import { cn } from "@/lib/utils"
+import { timeOfDayOf, withDayOf, withTimeOfDay } from "@/lib/logged-at"
+
+const DAY_LABEL = "d MMM yyyy"
+
+interface LoggedAtPickerProps {
+  value: Date
+  onChange: (next: Date) => void
+}
+
+export function LoggedAtPicker({ value, onChange }: LoggedAtPickerProps) {
+  const [calendarOpen, setCalendarOpen] = useState(false)
+
+  const pickDay = (day: Date | undefined) => {
+    if (!day) return
+    onChange(withDayOf(value, day))
+    setCalendarOpen(false)
+  }
+
+  return (
+    <div className="flex items-center gap-2">
+      <Popover open={calendarOpen} onOpenChange={setCalendarOpen}>
+        <PopoverTrigger
+          className={cn(
+            buttonVariants({ variant: "outline", size: "sm" }),
+            "font-normal"
+          )}
+        >
+          <CalendarIcon />
+          {format(value, DAY_LABEL)}
+        </PopoverTrigger>
+        <PopoverContent align="start" className="w-auto p-0">
+          <Calendar
+            mode="single"
+            selected={value}
+            defaultMonth={value}
+            onSelect={pickDay}
+            autoFocus
+          />
+        </PopoverContent>
+      </Popover>
+
+      <Input
+        type="time"
+        className="w-28"
+        value={timeOfDayOf(value)}
+        onChange={(event) => onChange(withTimeOfDay(value, event.target.value))}
+      />
+    </div>
+  )
+}
diff --git a/spa/src/components/import/wizard-upload.tsx b/spa/src/components/import/wizard-upload.tsx
index c1280ff..7d51a57 100644
--- a/spa/src/components/import/wizard-upload.tsx
+++ b/spa/src/components/import/wizard-upload.tsx
@@ -22,7 +22,7 @@ export function WizardUpload({ onParsed }: WizardUploadProps) {
 
   const handleDrop = (e: React.DragEvent) => {
     e.preventDefault()
-    const file = e.dataTransfer.files[0]
+    const file = Array.from(e.dataTransfer.files).at(0)
     if (file) handleFile(file)
   }
 
diff --git a/spa/src/components/metric/metric-fields.ts b/spa/src/components/metric/metric-fields.ts
new file mode 100644
index 0000000..b4250ef
--- /dev/null
+++ b/spa/src/components/metric/metric-fields.ts
@@ -0,0 +1,88 @@
+import {
+  Activity,
+  BedDouble,
+  EyeOff,
+  Footprints,
+  HeartPulse,
+  Smartphone,
+  Timer,
+  Wine,
+} from "lucide-react"
+import type { LucideIcon } from "lucide-react"
+import type { MetricKind } from "@/api/schema"
+
+export type MetricField = {
+  kind: MetricKind
+  label: string
+  unit: string
+  min: number
+  max: number
+  icon: LucideIcon
+}
+
+export const METRIC_FIELDS: MetricField[] = [
+  {
+    kind: "steps",
+    label: "Steps",
+    unit: "steps",
+    min: 0,
+    max: 200000,
+    icon: Footprints,
+  },
+  {
+    kind: "sleepMinutes",
+    label: "Sleep",
+    unit: "minutes",
+    min: 0,
+    max: 1440,
+    icon: BedDouble,
+  },
+  {
+    kind: "awakeMinutes",
+    label: "Awake in bed",
+    unit: "minutes",
+    min: 0,
+    max: 1440,
+    icon: EyeOff,
+  },
+  {
+    kind: "restingHeartRate",
+    label: "Resting heart rate",
+    unit: "bpm",
+    min: 25,
+    max: 120,
+    icon: HeartPulse,
+  },
+  {
+    kind: "hrv",
+    label: "HRV",
+    unit: "ms",
+    min: 1,
+    max: 300,
+    icon: Activity,
+  },
+  {
+    kind: "exerciseMinutes",
+    label: "Exercise",
+    unit: "minutes",
+    min: 0,
+    max: 1440,
+    icon: Timer,
+  },
+  {
+    kind: "screenTimeMinutes",
+    label: "Screen time",
+    unit: "minutes",
+    min: 0,
+    max: 1440,
+    icon: Smartphone,
+  },
+  {
+    kind: "alcoholicDrinks",
+    label: "Alcoholic drinks",
+    unit: "standard drinks",
+    min: 0,
+    max: 60,
+    icon: Wine,
+  },
+]
diff --git a/spa/src/components/metric/metric-row.tsx b/spa/src/components/metric/metric-row.tsx
new file mode 100644
index 0000000..7a8c6db
--- /dev/null
+++ b/spa/src/components/metric/metric-row.tsx
@@ -0,0 +1,46 @@
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import type { DailyMetricResponse } from "@/api/schema"
+import type { MetricField } from "./metric-fields"
+
+type MetricRowProps = {
+  field: MetricField
+  stored: DailyMetricResponse | undefined
+  draft: string
+  onChange: (draft: string) => void
+}
+
+export function MetricRow({ field, stored, draft, onChange }: MetricRowProps) {
+  const Icon = field.icon
+
+  return (
+    <div className="flex flex-col gap-1.5">
+      <Label className="flex items-center gap-2 text-xs">
+        <Icon className="h-3.5 w-3.5 text-muted-foreground" />
+        {field.label}
+        <span className="text-muted-foreground">({field.unit})</span>
+      </Label>
+      <Input
+        type="number"
+        inputMode="numeric"
+        min={field.min}
+        max={field.max}
+        placeholder="Not recorded"
+        value={draft}
+        onChange={(event) => onChange(event.target.value)}
+      />
+      {stored?.provider ? (
+        <p className="text-xs text-muted-foreground">
+          Reported by {stored.provider}. Saving replaces it with your own; empty
+          the field to clear it, and a later import may report it again.
+        </p>
+      ) : (
+        stored && (
+          <p className="text-xs text-muted-foreground">
+            Entered by you. Empty the field to clear it.
+          </p>
+        )
+      )}
+    </div>
+  )
+}
diff --git a/spa/src/components/mood/mood-picker.tsx b/spa/src/components/mood/mood-picker.tsx
index 773453f..4416807 100644
--- a/spa/src/components/mood/mood-picker.tsx
+++ b/spa/src/components/mood/mood-picker.tsx
@@ -1,4 +1,5 @@
-import { MOODS, type MoodValue } from "@/lib/mood"
+import { MOODS } from "@/lib/mood"
+import type { MoodValue } from "@/lib/mood"
 import { cn } from "@/lib/utils"
 
 interface MoodPickerProps {
diff --git a/spa/src/components/settings/api-tokens-card.tsx b/spa/src/components/settings/api-tokens-card.tsx
new file mode 100644
index 0000000..57dc715
--- /dev/null
+++ b/spa/src/components/settings/api-tokens-card.tsx
@@ -0,0 +1,137 @@
+import { useState } from "react"
+import { formatDistanceToNow } from "date-fns"
+import { Trash2 } 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 { 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"
+
+const NAME_RULE = /^[a-z0-9-]+$/
+
+export function ApiTokensCard() {
+  const { data: existing } = useApiTokens()
+  const mint = useMintApiToken()
+  const revoke = useRevokeApiToken()
+
+  const [name, setName] = useState("")
+  const [justMinted, setJustMinted] = useState<string | null>(null)
+
+  const normalised = name.trim().toLowerCase()
+  const canMint = normalised.length > 0 && NAME_RULE.test(normalised)
+
+  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",
+        }),
+    })
+  }
+
+  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>
+
+        {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>
+        )}
+
+        <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>
+          )}
+        </div>
+
+        {existing?.length ? (
+          <div className="flex flex-col gap-2">
+            {existing.map((token) => (
+              <TokenRow
+                key={token.id}
+                token={token}
+                onRevoke={() => revoke.mutate(token.id)}
+              />
+            ))}
+          </div>
+        ) : (
+          <span className="text-xs text-muted-foreground">No tokens yet.</span>
+        )}
+      </CardContent>
+    </Card>
+  )
+}
+
+function TokenRow({
+  token,
+  onRevoke,
+}: {
+  token: ApiTokenResponse
+  onRevoke: () => void
+}) {
+  const lastUsed = token.lastUsedAt
+    ? `used ${formatDistanceToNow(new Date(token.lastUsedAt), { addSuffix: true })}`
+    : "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>
+      <Button variant="ghost" size="icon" onClick={onRevoke}>
+        <Trash2 className="h-4 w-4 text-destructive" />
+      </Button>
+    </div>
+  )
+}
diff --git a/spa/src/components/settings/cycle-card.tsx b/spa/src/components/settings/cycle-card.tsx
new file mode 100644
index 0000000..3c114f0
--- /dev/null
+++ b/spa/src/components/settings/cycle-card.tsx
@@ -0,0 +1,101 @@
+import { useState } from "react"
+import { format } from "date-fns"
+import { Trash2 } 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 { Label } from "@/components/ui/label"
+import { Switch } from "@/components/ui/switch"
+import {
+  useCycle,
+  useForgetCycleStart,
+  usePreferences,
+  useRecordCycleStart,
+  useSetCycleTracking,
+} from "@/hooks/use-cycle"
+
+export function CycleCard() {
+  const { data: preferences } = usePreferences()
+  const setTracking = useSetCycleTracking()
+
+  const tracking = preferences?.tracksCycle ?? false
+  const { data: view } = useCycle(tracking)
+
+  const today = format(new Date(), "yyyy-MM-dd")
+  const [start, setStart] = useState(today)
+  const record = useRecordCycleStart()
+  const forget = useForgetCycleStart()
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-center justify-between pb-2">
+        <CardTitle className="text-sm">Cycle</CardTitle>
+        <Switch
+          checked={tracking}
+          onCheckedChange={(next) => setTracking.mutate(next)}
+        />
+      </CardHeader>
+
+      {tracking && (
+        <CardContent className="flex flex-col gap-3">
+          <p className="text-xs text-muted-foreground">
+            Record the day a period begins — once a cycle, not once a day. The
+            cycle day for every other date is worked out from it, so correcting
+            a start fixes everything that followed.
+          </p>
+
+          {view?.today ? (
+            <p className="text-xs">
+              Today is <span className="font-medium">day {view.today.day}</span>{" "}
+              of a cycle that usually runs {view.usualLength} days.
+            </p>
+          ) : (
+            <p className="text-xs text-muted-foreground">
+              No cycle day for today yet — record a start below.
+            </p>
+          )}
+
+          <div className="flex flex-col gap-1.5">
+            <Label className="text-xs">A period began on</Label>
+            <div className="flex gap-2">
+              <Input
+                type="date"
+                value={start}
+                max={today}
+                onChange={(event) => setStart(event.target.value)}
+              />
+              <Button
+                size="sm"
+                disabled={record.isPending}
+                onClick={() => record.mutate(start)}
+              >
+                Record
+              </Button>
+            </div>
+          </div>
+
+          {view?.starts.length ? (
+            <div className="flex flex-col gap-1">
+              {[...view.starts].reverse().map((day) => (
+                <div key={day} className="flex items-center justify-between">
+                  <span className="text-xs">{day}</span>
+                  <Button
+                    variant="ghost"
+                    size="icon"
+                    onClick={() => forget.mutate(day)}
+                  >
+                    <Trash2 className="h-3.5 w-3.5 text-destructive" />
+                  </Button>
+                </div>
+              ))}
+            </div>
+          ) : (
+            <span className="text-xs text-muted-foreground">
+              Nothing recorded yet.
+            </span>
+          )}
+        </CardContent>
+      )}
+    </Card>
+  )
+}
diff --git a/spa/src/components/settings/rejections-card.tsx b/spa/src/components/settings/rejections-card.tsx
new file mode 100644
index 0000000..7c5fca9
--- /dev/null
+++ b/spa/src/components/settings/rejections-card.tsx
@@ -0,0 +1,68 @@
+import { formatDistanceToNow } from "date-fns"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Skeleton } from "@/components/ui/skeleton"
+import { useRejections } from "@/hooks/use-rejections"
+import type { RejectionResponse } from "@/api/schema"
+
+export function RejectionsCard() {
+  const { data: rejections, isLoading } = useRejections()
+
+  if (isLoading) return <Skeleton className="h-24" />
+  if (!rejections?.length) return null
+
+  return (
+    <Card>
+      <CardHeader className="pb-2">
+        <CardTitle className="text-sm">
+          Readings that could not be used
+        </CardTitle>
+      </CardHeader>
+      <CardContent className="flex flex-col gap-3">
+        <p className="text-xs text-muted-foreground">
+          Nothing here was stored. An automation cannot show you an error, so
+          whatever it sent that could not be read is listed here instead. Only
+          the most recent are kept.
+        </p>
+
+        {rejections.map((rejection) => (
+          <RejectionRow key={rejection.id} rejection={rejection} />
+        ))}
+      </CardContent>
+    </Card>
+  )
+}
+
+function RejectionRow({ rejection }: { rejection: RejectionResponse }) {
+  const source =
+    rejection.origin === "storedRow"
+      ? "stored by an older build"
+      : (rejection.provider ?? "an importer")
+
+  return (
+    <div className="flex flex-col gap-0.5 border-l-2 border-destructive/40 pl-2">
+      <div className="flex items-baseline justify-between gap-2">
+        <span className="text-xs font-medium">
+          {rejection.kind}
+          {rejection.value !== null && (
+            <span className="font-normal text-muted-foreground">
+              {" "}
+              = {rejection.value}
+            </span>
+          )}
+        </span>
+        <span className="shrink-0 text-[10px] text-muted-foreground">
+          {rejection.date ?? "no date"}
+        </span>
+      </div>
+      <span className="text-[10px] text-muted-foreground">
+        {rejection.reason}
+      </span>
+      <span className="text-[10px] text-muted-foreground">
+        from {source},{" "}
+        {formatDistanceToNow(new Date(rejection.recordedAt), {
+          addSuffix: true,
+        })}
+      </span>
+    </div>
+  )
+}
diff --git a/spa/src/components/settings/subsonic-card.tsx b/spa/src/components/settings/subsonic-card.tsx
new file mode 100644
index 0000000..d4cc579
--- /dev/null
+++ b/spa/src/components/settings/subsonic-card.tsx
@@ -0,0 +1,94 @@
+import { useState } from "react"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Input } from "@/components/ui/input"
+import { toast } from "@/components/ui/toast"
+import {
+  useConnectProvider,
+  useDisconnectProvider,
+  useProviderConnections,
+} from "@/hooks/use-providers"
+
+const PROVIDER = "subsonic"
+
+export function SubsonicCard() {
+  const connections = useProviderConnections()
+  const connect = useConnectProvider(PROVIDER)
+  const disconnect = useDisconnectProvider(PROVIDER)
+
+  const [url, setUrl] = useState("")
+  const [username, setUsername] = useState("")
+  const [password, setPassword] = useState("")
+
+  const connected =
+    connections.data?.some((c) => c.provider === PROVIDER) ?? false
+
+  const submit = () => {
+    connect.mutate(
+      { url, username, password },
+      {
+        onSuccess: () => {
+          setPassword("")
+          toast.add({ title: "Subsonic connected", type: "success" })
+        },
+        onError: () => toast.add({ title: "Could not connect", type: "error" }),
+      }
+    )
+  }
+
+  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">
+              Subsonic is connected. Your password is stored encrypted and is
+              never shown again.
+            </p>
+            <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>
+            <Input
+              placeholder="https://music.example.com"
+              value={url}
+              onChange={(e) => setUrl(e.target.value)}
+            />
+            <Input
+              placeholder="Username"
+              value={username}
+              onChange={(e) => setUsername(e.target.value)}
+            />
+            <Input
+              type="password"
+              placeholder="Password"
+              value={password}
+              onChange={(e) => setPassword(e.target.value)}
+            />
+            <Button
+              size="sm"
+              onClick={submit}
+              disabled={connect.isPending || !url || !username || !password}
+            >
+              {connect.isPending ? "Connecting…" : "Connect"}
+            </Button>
+          </>
+        )}
+      </CardContent>
+    </Card>
+  )
+}
diff --git a/spa/src/components/stats/activity-correlations.tsx b/spa/src/components/stats/activity-correlations.tsx
deleted file mode 100644
index ce8099d..0000000
--- a/spa/src/components/stats/activity-correlations.tsx
+++ /dev/null
@@ -1,67 +0,0 @@
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
-import { Skeleton } from "@/components/ui/skeleton"
-import { useActivities } from "@/hooks/use-activities"
-import { useAllCorrelations } from "@/hooks/use-correlation"
-
-export function ActivityCorrelations() {
-  const { data: activities } = useActivities()
-  const activeIds = (activities ?? [])
-    .filter((a) => !a.archived)
-    .map((a) => a.id)
-
-  const { data: correlations, isLoading } = useAllCorrelations(activeIds)
-
-  const activityMap = new Map((activities ?? []).map((a) => [a.id, a.name]))
-
-  const sorted = [...(correlations ?? [])].sort(
-    (a, b) => Math.abs(b.correlation!) - Math.abs(a.correlation!)
-  )
-
-  if (isLoading) return <Skeleton className="h-32" />
-  if (!sorted.length) return null
-
-  return (
-    <Card>
-      <CardHeader className="pb-2">
-        <CardTitle className="text-sm">Activity impact on mood</CardTitle>
-      </CardHeader>
-      <CardContent className="flex flex-col gap-2">
-        {sorted.slice(0, 8).map((c) => (
-          <CorrelationBar
-            key={c.activityId}
-            name={activityMap.get(c.activityId) ?? c.activityId}
-            value={c.correlation!}
-          />
-        ))}
-      </CardContent>
-    </Card>
-  )
-}
-
-function CorrelationBar({ name, value }: { name: string; value: number }) {
-  const pct = Math.abs(value) * 100
-  const positive = value > 0
-
-  return (
-    <div className="flex items-center gap-3">
-      <span className="w-24 shrink-0 truncate text-xs">{name}</span>
-      <div className="relative h-4 flex-1 rounded-full bg-muted/50">
-        <div
-          className={`absolute top-0 h-full rounded-full ${
-            positive ? "left-1/2 bg-green-500/60" : "right-1/2 bg-red-500/60"
-          }`}
-          style={{ width: `${pct / 2}%` }}
-        />
-        <div className="absolute top-0 left-1/2 h-full w-px bg-muted-foreground/30" />
-      </div>
-      <span
-        className={`w-12 shrink-0 text-right text-xs font-medium ${
-          positive ? "text-green-400" : "text-red-400"
-        }`}
-      >
-        {positive ? "+" : ""}
-        {value.toFixed(2)}
-      </span>
-    </div>
-  )
-}
diff --git a/spa/src/components/stats/mood-correlations.tsx b/spa/src/components/stats/mood-correlations.tsx
new file mode 100644
index 0000000..b4d981a
--- /dev/null
+++ b/spa/src/components/stats/mood-correlations.tsx
@@ -0,0 +1,148 @@
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Skeleton } from "@/components/ui/skeleton"
+import { METRIC_FIELDS } from "@/components/metric/metric-fields"
+import { useMoodCorrelations } from "@/hooks/use-mood-correlations"
+import type { CorrelationRowResponse } from "@/api/schema"
+
+const STRATEGY_LABELS: Record<string, string> = {
+  pearson: "linear",
+  spearman: "rank",
+  kendall: "pairwise",
+  meanDifference: "mean difference",
+}
+
+function labelOf(row: CorrelationRowResponse): string {
+  const input = row.input
+
+  switch (input.kind) {
+    case "metric": {
+      const field = METRIC_FIELDS.find((f) => f.kind === input.metric)
+      return field ? field.label : input.metric
+    }
+    case "moonPhase":
+      return "Moon phase"
+    case "activity":
+      return input.name
+  }
+}
+
+function orderOf(row: CorrelationRowResponse): number {
+  const input = row.input
+
+  switch (input.kind) {
+    case "metric":
+      return METRIC_FIELDS.findIndex((f) => f.kind === input.metric)
+    case "moonPhase":
+      return METRIC_FIELDS.length
+    case "activity":
+      return METRIC_FIELDS.length + 1
+  }
+}
+
+export function MoodCorrelations() {
+  const { data: rows, isLoading } = useMoodCorrelations()
+
+  if (isLoading) return <Skeleton className="h-40" />
+  if (!rows) return null
+
+  const withData = rows
+    .filter((row) => row.sampleSize > 0)
+    .sort((left, right) => orderOf(left) - orderOf(right))
+
+  if (!withData.length) return null
+
+  return (
+    <Card>
+      <CardHeader className="pb-2">
+        <CardTitle className="text-sm">What moves with your mood</CardTitle>
+      </CardHeader>
+      <CardContent className="flex flex-col gap-4">
+        <p className="text-xs text-muted-foreground">
+          Over the last year. Several methods are run on each row and all of
+          them are shown — how many point the same way matters more than any one
+          number. Nothing here is ranked, and none of it is evidence on its own.
+        </p>
+        <p className="text-xs text-muted-foreground">
+          A dot marks a reading that still stood once the number of things
+          compared was accounted for. It is a second thing to look at, not a
+          verdict.
+        </p>
+
+        {withData.map((row) => (
+          <CorrelationRow key={rowKey(row)} row={row} />
+        ))}
+      </CardContent>
+    </Card>
+  )
+}
+
+function rowKey(row: CorrelationRowResponse): string {
+  const input = row.input
+
+  switch (input.kind) {
+    case "metric":
+      return `metric:${input.metric}`
+    case "moonPhase":
+      return "moonPhase"
+    case "activity":
+      return `activity:${input.activityId}`
+  }
+}
+
+function CorrelationRow({ row }: { row: CorrelationRowResponse }) {
+  const scored = row.scores.length > 0
+  const isControl = row.input.kind === "moonPhase"
+
+  return (
+    <div className="flex flex-col gap-1">
+      <div className="flex items-baseline justify-between gap-3">
+        <span className="truncate text-xs font-medium">{labelOf(row)}</span>
+        <span className="shrink-0 text-xs text-muted-foreground">
+          {agreementLine(row)}
+        </span>
+      </div>
+
+      {scored ? (
+        <div className="flex flex-wrap gap-x-3 gap-y-0.5">
+          {row.scores.map((score) => (
+            <span
+              key={score.strategy}
+              className="text-[10px] text-muted-foreground tabular-nums"
+            >
+              {STRATEGY_LABELS[score.strategy] ?? score.strategy}{" "}
+              <span className="font-medium text-foreground">
+                {score.coefficient.toFixed(2)}
+              </span>
+              {score.heldUp && (
+                <span
+                  className="ml-0.5 text-foreground"
+                  title="still stood once the number of comparisons was accounted for"
+                >
+                  •
+                </span>
+              )}
+            </span>
+          ))}
+        </div>
+      ) : (
+        <span className="text-[10px] text-muted-foreground">
+          {row.sampleSize} days so far — not enough to say anything
+        </span>
+      )}
+
+      {isControl && (
+        <span className="text-[10px] text-muted-foreground">
+          a control: the moon should show nothing, so a strong reading here
+          means the rows above are noisier than they look
+        </span>
+      )}
+    </div>
+  )
+}
+
+function agreementLine(row: CorrelationRowResponse): string {
+  if (row.agreement.applicable === 1) return "one measure only"
+  if (row.scores.length === 0) return `${row.sampleSize} days`
+
+  return `${row.agreement.agreeing} of ${row.agreement.applicable} agree`
+}
diff --git a/spa/src/components/stats/mood-heatmap.tsx b/spa/src/components/stats/mood-heatmap.tsx
index d34a25e..8ad7137 100644
--- a/spa/src/components/stats/mood-heatmap.tsx
+++ b/spa/src/components/stats/mood-heatmap.tsx
@@ -46,8 +46,8 @@ export function MoodHeatmap({ year, days }: MoodHeatmapProps) {
 
   const moodMap = new Map<string, number>()
   for (const day of days) {
-    if (day.dominantMood) {
-      moodMap.set(day.date, day.dominantMood)
+    if (day.mood) {
+      moodMap.set(day.date, day.mood)
     }
   }
 
@@ -92,7 +92,7 @@ export function MoodHeatmap({ year, days }: MoodHeatmapProps) {
                     key={weekIdx}
                     className="w-[11px] text-center text-[8px] leading-[11px] text-muted-foreground"
                   >
-                    {showLabel ? MONTH_LABELS[firstDayInWeek!.getMonth()] : ""}
+                    {showLabel ? MONTH_LABELS[firstDayInWeek.getMonth()] : ""}
                   </div>
                 )
               })}
diff --git a/spa/src/components/stats/mood-trend-chart.tsx b/spa/src/components/stats/mood-trend-chart.tsx
index 289e1f9..0f1af6b 100644
--- a/spa/src/components/stats/mood-trend-chart.tsx
+++ b/spa/src/components/stats/mood-trend-chart.tsx
@@ -69,8 +69,14 @@ export function MoodTrendChart({
               width={32}
             />
             <Tooltip
-              content={({ active, payload }) => {
+              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 (
diff --git a/spa/src/components/ui/alert.tsx b/spa/src/components/ui/alert.tsx
index 1fe3176..31d42d6 100644
--- a/spa/src/components/ui/alert.tsx
+++ b/spa/src/components/ui/alert.tsx
@@ -1,5 +1,6 @@
 import * as React from "react"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 
diff --git a/spa/src/components/ui/attachment.tsx b/spa/src/components/ui/attachment.tsx
index 20609f0..730e7b5 100644
--- a/spa/src/components/ui/attachment.tsx
+++ b/spa/src/components/ui/attachment.tsx
@@ -1,7 +1,8 @@
 import * as React from "react"
 import { mergeProps } from "@base-ui/react/merge-props"
 import { useRender } from "@base-ui/react/use-render"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 import { Button } from "@/components/ui/button"
diff --git a/spa/src/components/ui/badge.tsx b/spa/src/components/ui/badge.tsx
index b20959d..b956e99 100644
--- a/spa/src/components/ui/badge.tsx
+++ b/spa/src/components/ui/badge.tsx
@@ -1,6 +1,7 @@
 import { mergeProps } from "@base-ui/react/merge-props"
 import { useRender } from "@base-ui/react/use-render"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 
diff --git a/spa/src/components/ui/bubble.tsx b/spa/src/components/ui/bubble.tsx
index 0b4bfe2..e3fb647 100644
--- a/spa/src/components/ui/bubble.tsx
+++ b/spa/src/components/ui/bubble.tsx
@@ -1,7 +1,8 @@
 import * as React from "react"
 import { mergeProps } from "@base-ui/react/merge-props"
 import { useRender } from "@base-ui/react/use-render"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 
diff --git a/spa/src/components/ui/button-group.tsx b/spa/src/components/ui/button-group.tsx
index 3c97c26..c113298 100644
--- a/spa/src/components/ui/button-group.tsx
+++ b/spa/src/components/ui/button-group.tsx
@@ -1,6 +1,7 @@
 import { mergeProps } from "@base-ui/react/merge-props"
 import { useRender } from "@base-ui/react/use-render"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 import { Separator } from "@/components/ui/separator"
diff --git a/spa/src/components/ui/button.tsx b/spa/src/components/ui/button.tsx
index b033601..f62230c 100644
--- a/spa/src/components/ui/button.tsx
+++ b/spa/src/components/ui/button.tsx
@@ -1,5 +1,6 @@
 import { Button as ButtonPrimitive } from "@base-ui/react/button"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 
diff --git a/spa/src/components/ui/calendar.tsx b/spa/src/components/ui/calendar.tsx
index c502190..b426f58 100644
--- a/spa/src/components/ui/calendar.tsx
+++ b/spa/src/components/ui/calendar.tsx
@@ -1,12 +1,8 @@
 "use client"
 
 import * as React from "react"
-import {
-  DayPicker,
-  getDefaultClassNames,
-  type DayButton,
-  type Locale,
-} from "react-day-picker"
+import { DayPicker, getDefaultClassNames } from "react-day-picker"
+import type { DayButton, Locale } from "react-day-picker"
 
 import { cn } from "@/lib/utils"
 import { Button, buttonVariants } from "@/components/ui/button"
diff --git a/spa/src/components/ui/carousel.tsx b/spa/src/components/ui/carousel.tsx
index 5d10f15..bede571 100644
--- a/spa/src/components/ui/carousel.tsx
+++ b/spa/src/components/ui/carousel.tsx
@@ -1,7 +1,6 @@
 import * as React from "react"
-import useEmblaCarousel, {
-  type UseEmblaCarouselType,
-} from "embla-carousel-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"
diff --git a/spa/src/components/ui/chart.tsx b/spa/src/components/ui/chart.tsx
index c5abfdb..852481a 100644
--- a/spa/src/components/ui/chart.tsx
+++ b/spa/src/components/ui/chart.tsx
@@ -347,15 +347,13 @@ function getPayloadConfigFromPayload(
     key in payload &&
     typeof payload[key as keyof typeof payload] === "string"
   ) {
-    configLabelKey = payload[key as keyof typeof payload] as 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
-    ] as string
+    configLabelKey = payloadPayload[key as keyof typeof payloadPayload]
   }
 
   return configLabelKey in config ? config[configLabelKey] : config[key]
diff --git a/spa/src/components/ui/empty.tsx b/spa/src/components/ui/empty.tsx
index b23187b..631da22 100644
--- a/spa/src/components/ui/empty.tsx
+++ b/spa/src/components/ui/empty.tsx
@@ -1,4 +1,5 @@
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 
diff --git a/spa/src/components/ui/field.tsx b/spa/src/components/ui/field.tsx
index b0e549c..555d184 100644
--- a/spa/src/components/ui/field.tsx
+++ b/spa/src/components/ui/field.tsx
@@ -1,5 +1,6 @@
 import { useMemo } from "react"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 import { Label } from "@/components/ui/label"
diff --git a/spa/src/components/ui/input-group.tsx b/spa/src/components/ui/input-group.tsx
index da8f1dd..44ba816 100644
--- a/spa/src/components/ui/input-group.tsx
+++ b/spa/src/components/ui/input-group.tsx
@@ -1,7 +1,8 @@
 "use client"
 
 import * as React from "react"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 import { Button } from "@/components/ui/button"
diff --git a/spa/src/components/ui/item.tsx b/spa/src/components/ui/item.tsx
index 0f872ee..1dd8863 100644
--- a/spa/src/components/ui/item.tsx
+++ b/spa/src/components/ui/item.tsx
@@ -1,7 +1,8 @@
 import * as React from "react"
 import { mergeProps } from "@base-ui/react/merge-props"
 import { useRender } from "@base-ui/react/use-render"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 import { Separator } from "@/components/ui/separator"
diff --git a/spa/src/components/ui/marker.tsx b/spa/src/components/ui/marker.tsx
index f59cca4..5fb0af3 100644
--- a/spa/src/components/ui/marker.tsx
+++ b/spa/src/components/ui/marker.tsx
@@ -1,7 +1,8 @@
 import * as React from "react"
 import { mergeProps } from "@base-ui/react/merge-props"
 import { useRender } from "@base-ui/react/use-render"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 
diff --git a/spa/src/components/ui/questionnaire.tsx b/spa/src/components/ui/questionnaire.tsx
index 2d9ce8a..9c5f518 100644
--- a/spa/src/components/ui/questionnaire.tsx
+++ b/spa/src/components/ui/questionnaire.tsx
@@ -4,7 +4,8 @@ import * as React from "react"
 import { Questionnaire as QuestionnairePrimitive } from "@shadcn/react/questionnaire"
 
 import { cn } from "@/lib/utils"
-import { buttonVariants, type Button } from "@/components/ui/button"
+import { buttonVariants } from "@/components/ui/button"
+import type { Button } from "@/components/ui/button"
 import { CheckIcon } from "lucide-react"
 
 function Questionnaire({
diff --git a/spa/src/components/ui/sidebar.tsx b/spa/src/components/ui/sidebar.tsx
index aca53fc..39b4c1b 100644
--- a/spa/src/components/ui/sidebar.tsx
+++ b/spa/src/components/ui/sidebar.tsx
@@ -3,7 +3,8 @@
 import * as React from "react"
 import { mergeProps } from "@base-ui/react/merge-props"
 import { useRender } from "@base-ui/react/use-render"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { useIsMobile } from "@/hooks/use-mobile"
 import { cn } from "@/lib/utils"
diff --git a/spa/src/components/ui/tabs.tsx b/spa/src/components/ui/tabs.tsx
index 8ee8054..5efb51f 100644
--- a/spa/src/components/ui/tabs.tsx
+++ b/spa/src/components/ui/tabs.tsx
@@ -1,7 +1,8 @@
 "use client"
 
 import { Tabs as TabsPrimitive } from "@base-ui/react/tabs"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 
diff --git a/spa/src/components/ui/toggle-group.tsx b/spa/src/components/ui/toggle-group.tsx
index 6fee54b..8494a41 100644
--- a/spa/src/components/ui/toggle-group.tsx
+++ b/spa/src/components/ui/toggle-group.tsx
@@ -1,7 +1,7 @@
 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 type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 import { toggleVariants } from "@/components/ui/toggle"
diff --git a/spa/src/components/ui/toggle.tsx b/spa/src/components/ui/toggle.tsx
index 2b626f6..e6912bc 100644
--- a/spa/src/components/ui/toggle.tsx
+++ b/spa/src/components/ui/toggle.tsx
@@ -1,5 +1,6 @@
 import { Toggle as TogglePrimitive } from "@base-ui/react/toggle"
-import { cva, type VariantProps } from "class-variance-authority"
+import { cva } from "class-variance-authority"
+import type { VariantProps } from "class-variance-authority"
 
 import { cn } from "@/lib/utils"
 
diff --git a/spa/src/hooks/use-api-tokens.ts b/spa/src/hooks/use-api-tokens.ts
new file mode 100644
index 0000000..51225e0
--- /dev/null
+++ b/spa/src/hooks/use-api-tokens.ts
@@ -0,0 +1,29 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { tokens } from "@/api/client"
+
+const TOKENS = ["api-tokens"]
+
+export function useApiTokens() {
+  return useQuery({
+    queryKey: TOKENS,
+    queryFn: () => tokens.list(),
+  })
+}
+
+export function useMintApiToken() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: (name: string) => tokens.mint(name),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: TOKENS }),
+  })
+}
+
+export function useRevokeApiToken() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: (id: string) => tokens.revoke(id),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: TOKENS }),
+  })
+}
diff --git a/spa/src/hooks/use-correlation.ts b/spa/src/hooks/use-correlation.ts
deleted file mode 100644
index 332fafc..0000000
--- a/spa/src/hooks/use-correlation.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import { entries } from "@/api/client"
-
-export function useCorrelation(activityId: string | null) {
-  return useQuery({
-    queryKey: ["correlation", activityId],
-    queryFn: () => entries.correlation(activityId!),
-    enabled: !!activityId,
-  })
-}
-
-export function useAllCorrelations(activityIds: string[]) {
-  return useQuery({
-    queryKey: ["correlations", activityIds],
-    queryFn: async () => {
-      const results = await Promise.all(
-        activityIds.map((id) => entries.correlation(id))
-      )
-      return results.filter((r) => r.correlation !== null)
-    },
-    enabled: activityIds.length > 0,
-  })
-}
diff --git a/spa/src/hooks/use-cycle.ts b/spa/src/hooks/use-cycle.ts
new file mode 100644
index 0000000..7744e5a
--- /dev/null
+++ b/spa/src/hooks/use-cycle.ts
@@ -0,0 +1,57 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { cycle } from "@/api/client"
+
+const CYCLE = ["cycle"]
+const PREFERENCES = ["preferences"]
+
+export function usePreferences() {
+  return useQuery({
+    queryKey: PREFERENCES,
+    queryFn: () => cycle.preferences(),
+  })
+}
+
+export function useSetCycleTracking() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: (tracksCycle: boolean) => cycle.setTracking(tracksCycle),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: PREFERENCES })
+      queryClient.invalidateQueries({ queryKey: CYCLE })
+      queryClient.invalidateQueries({ queryKey: ["calendar"] })
+    },
+  })
+}
+
+export function useCycle(enabled: boolean) {
+  return useQuery({
+    queryKey: CYCLE,
+    queryFn: () => cycle.read(),
+    enabled,
+  })
+}
+
+export function useRecordCycleStart() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: (date: string) => cycle.record(date),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: CYCLE })
+      queryClient.invalidateQueries({ queryKey: ["calendar"] })
+    },
+  })
+}
+
+export function useForgetCycleStart() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: (date: string) => cycle.forget(date),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: CYCLE })
+      queryClient.invalidateQueries({ queryKey: ["calendar"] })
+    },
+  })
+}
diff --git a/spa/src/hooks/use-import-export.ts b/spa/src/hooks/use-import-export.ts
index 15ac314..dbdd582 100644
--- a/spa/src/hooks/use-import-export.ts
+++ b/spa/src/hooks/use-import-export.ts
@@ -1,17 +1,53 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query"
 import { data } from "@/api/client"
 
-export function useExport() {
+function today(): string {
+  return new Date().toISOString().slice(0, 10)
+}
+
+function save(blob: Blob, filename: string) {
+  const url = URL.createObjectURL(blob)
+  const link = document.createElement("a")
+  link.href = url
+  link.download = filename
+  link.click()
+  URL.revokeObjectURL(url)
+}
+
+export function useCompleteBackup() {
   return useMutation({
-    meta: { success: "Export downloaded" },
-    mutationFn: () => data.export(),
-    onSuccess: (blob) => {
-      const url = URL.createObjectURL(blob)
-      const a = document.createElement("a")
-      a.href = url
-      a.download = `k-mood-export-${new Date().toISOString().slice(0, 10)}.zip`
-      a.click()
-      URL.revokeObjectURL(url)
+    meta: { success: "Complete backup downloaded" },
+    mutationFn: () => data.completeBackup(),
+    onSuccess: (blob) => save(blob, `k-mood-complete-backup-${today()}.zip`),
+  })
+}
+
+export function useShareableExtract() {
+  return useMutation({
+    meta: { success: "Shareable journal downloaded" },
+    mutationFn: () => data.shareableExtract(),
+    onSuccess: (blob) => save(blob, `k-mood-shareable-journal-${today()}.md`),
+  })
+}
+
+export function useRestore() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    meta: { success: "Backup restored" },
+    mutationFn: (file: File) => data.restore(file),
+    onSuccess: () => {
+      for (const key of [
+        "entries",
+        "activities",
+        "stats",
+        "calendar",
+        "daily-metrics",
+        "cycle",
+        "preferences",
+      ]) {
+        queryClient.invalidateQueries({ queryKey: [key] })
+      }
     },
   })
 }
diff --git a/spa/src/hooks/use-metrics.ts b/spa/src/hooks/use-metrics.ts
new file mode 100644
index 0000000..b7d0b7a
--- /dev/null
+++ b/spa/src/hooks/use-metrics.ts
@@ -0,0 +1,32 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { metrics } from "@/api/client"
+import type {
+  DailyMetricResponse,
+  MetricKind,
+  MetricPayload,
+} from "@/api/schema"
+
+const METRICS = ["daily-metrics"]
+
+export function useDailyMetrics(from: string, to: string) {
+  return useQuery({
+    queryKey: [...METRICS, from, to],
+    queryFn: () => metrics.list({ from, to }),
+  })
+}
+
+export function useSetDailyMetrics() {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: ({ date, values }: { date: string; values: MetricPayload[] }) =>
+      metrics.set(date, values),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: METRICS }),
+  })
+}
+
+export function byKind(
+  stored: DailyMetricResponse[] | undefined
+): Map<MetricKind, DailyMetricResponse> {
+  return new Map(stored?.map((metric) => [metric.kind, metric]) ?? [])
+}
diff --git a/spa/src/hooks/use-mood-correlations.ts b/spa/src/hooks/use-mood-correlations.ts
new file mode 100644
index 0000000..d507a3b
--- /dev/null
+++ b/spa/src/hooks/use-mood-correlations.ts
@@ -0,0 +1,15 @@
+import { useQuery } from "@tanstack/react-query"
+import { format, subDays } from "date-fns"
+import { correlations } from "@/api/client"
+
+const A_YEAR = 365
+
+export function useMoodCorrelations() {
+  const to = format(new Date(), "yyyy-MM-dd")
+  const from = format(subDays(new Date(), A_YEAR), "yyyy-MM-dd")
+
+  return useQuery({
+    queryKey: ["mood-correlations", from, to],
+    queryFn: () => correlations.list({ from, to }),
+  })
+}
diff --git a/spa/src/hooks/use-providers.ts b/spa/src/hooks/use-providers.ts
new file mode 100644
index 0000000..2cc77bd
--- /dev/null
+++ b/spa/src/hooks/use-providers.ts
@@ -0,0 +1,37 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { providers } from "@/api/client"
+import type { SubsonicCredential } from "@/api/schema"
+
+const CONNECTIONS = ["provider-connections"]
+
+export function useProviderConnections() {
+  return useQuery({
+    queryKey: CONNECTIONS,
+    queryFn: () => providers.list(),
+  })
+}
+
+export function useConnectProvider(provider: string) {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: (credential: SubsonicCredential) =>
+      providers.connect(provider, credential),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: CONNECTIONS }),
+  })
+}
+
+export function useDisconnectProvider(provider: string) {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    mutationFn: () => providers.disconnect(provider),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: CONNECTIONS }),
+  })
+}
+
+export function useNowPlaying() {
+  return useMutation({
+    mutationFn: () => providers.nowPlaying(),
+  })
+}
diff --git a/spa/src/hooks/use-push.ts b/spa/src/hooks/use-push.ts
index 29002bf..e63cda6 100644
--- a/spa/src/hooks/use-push.ts
+++ b/spa/src/hooks/use-push.ts
@@ -20,6 +20,26 @@ function arrayBufferToBase64Url(buffer: ArrayBuffer): string {
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
 }
 
+function sameKey(a: ArrayBuffer | null, b: Uint8Array): boolean {
+  if (!a) return false
+  const bytes = new Uint8Array(a)
+  return bytes.length === b.length && bytes.every((v, i) => v === b[i])
+}
+
+// A subscription created with an older VAPID key makes subscribe() throw
+// InvalidStateError, so drop it before asking for a new one.
+async function dropStaleSubscription(
+  reg: ServiceWorkerRegistration,
+  keyBytes: Uint8Array
+): Promise<void> {
+  const existing = await reg.pushManager.getSubscription()
+  if (!existing) return
+  if (sameKey(existing.options.applicationServerKey, keyBytes)) return
+
+  await push.unsubscribe(existing.endpoint).catch(() => {})
+  await existing.unsubscribe()
+}
+
 export function usePushNotifications() {
   const [isSubscribed, setIsSubscribed] = useState(false)
   const [isSupported, setIsSupported] = useState(false)
@@ -55,6 +75,8 @@ export function usePushNotifications() {
 
       const reg = await navigator.serviceWorker.ready
       const keyBytes = urlBase64ToUint8Array(vapidKey.data.publicKey)
+      await dropStaleSubscription(reg, keyBytes)
+
       const sub = await reg.pushManager.subscribe({
         userVisibleOnly: true,
         applicationServerKey: keyBytes.buffer as ArrayBuffer,
diff --git a/spa/src/hooks/use-rejections.ts b/spa/src/hooks/use-rejections.ts
new file mode 100644
index 0000000..f8fba57
--- /dev/null
+++ b/spa/src/hooks/use-rejections.ts
@@ -0,0 +1,9 @@
+import { useQuery } from "@tanstack/react-query"
+import { metrics } from "@/api/client"
+
+export function useRejections() {
+  return useQuery({
+    queryKey: ["metric-rejections"],
+    queryFn: () => metrics.rejections(),
+  })
+}
diff --git a/spa/src/hooks/use-stats.ts b/spa/src/hooks/use-stats.ts
index 35cb27e..8de2a1f 100644
--- a/spa/src/hooks/use-stats.ts
+++ b/spa/src/hooks/use-stats.ts
@@ -49,7 +49,7 @@ export function usePeriodEntries(period: "week" | "month" | "year" | "all") {
         const days = await entries.calendar(range)
         return days.map((day) => ({
           loggedAt: day.date + "T12:00:00+00:00",
-          mood: day.dominantMood ?? 3,
+          mood: day.dayMood ?? 3,
         }))
       }
 
diff --git a/spa/src/hooks/use-timezone.ts b/spa/src/hooks/use-timezone.ts
new file mode 100644
index 0000000..08423f2
--- /dev/null
+++ b/spa/src/hooks/use-timezone.ts
@@ -0,0 +1,33 @@
+import { useEffect } from "react"
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { users } from "@/api/client"
+
+function platformTimezone(): string | null {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || null
+  } catch {
+    return null
+  }
+}
+
+export function useEnsureTimezone() {
+  const queryClient = useQueryClient()
+
+  const profile = useQuery({
+    queryKey: ["me"],
+    queryFn: () => users.me(),
+  })
+
+  const adopt = useMutation({
+    mutationFn: (timezone: string) => users.updateProfile({ timezone }),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["me"] }),
+  })
+
+  const missing = profile.data !== undefined && profile.data.timezone === null
+  const detected = platformTimezone()
+
+  useEffect(() => {
+    if (!missing || !detected || adopt.isPending || adopt.isSuccess) return
+    adopt.mutate(detected)
+  }, [missing, detected, adopt])
+}
diff --git a/spa/src/lib/dimensions.ts b/spa/src/lib/dimensions.ts
new file mode 100644
index 0000000..ddae6b6
--- /dev/null
+++ b/spa/src/lib/dimensions.ts
@@ -0,0 +1,72 @@
+import type { DimensionPayload, EntryResponse } from "@/api/schema"
+
+function find<TKind extends DimensionPayload["kind"]>(
+  entry: EntryResponse,
+  kind: TKind
+): Extract<DimensionPayload, { kind: TKind }> | undefined {
+  return entry.dimensions.find((d) => d.kind === kind) as
+    Extract<DimensionPayload, { kind: TKind }> | undefined
+}
+
+export function contentOf(entry: EntryResponse): string | null {
+  return find(entry, "content")?.text ?? null
+}
+
+export function activitiesOf(entry: EntryResponse): string[] {
+  return find(entry, "activities")?.ids ?? []
+}
+
+export function photosOf(entry: EntryResponse): string[] {
+  return find(entry, "photos")?.ids ?? []
+}
+
+export function voiceMemosOf(entry: EntryResponse): string[] {
+  return find(entry, "voiceMemos")?.ids ?? []
+}
+
+export function locationOf(entry: EntryResponse) {
+  const location = find(entry, "location")
+  return location
+    ? { latitude: location.latitude, longitude: location.longitude }
+    : null
+}
+
+export function songOf(entry: EntryResponse) {
+  return find(entry, "song") ?? null
+}
+
+export function weatherOf(entry: EntryResponse) {
+  return find(entry, "weather") ?? null
+}
+
+export function buildDimensions(input: {
+  content: string
+  activityIds: string[]
+  photoIds: string[]
+  voiceMemoIds: string[]
+  location: { latitude: number; longitude: number } | null
+  song: { title: string; artist: string } | null
+}): DimensionPayload[] {
+  const dimensions: DimensionPayload[] = []
+  const text = input.content.trim()
+
+  if (text) dimensions.push({ kind: "content", text })
+  if (input.activityIds.length)
+    dimensions.push({ kind: "activities", ids: input.activityIds })
+  if (input.photoIds.length)
+    dimensions.push({ kind: "photos", ids: input.photoIds })
+  if (input.voiceMemoIds.length)
+    dimensions.push({ kind: "voiceMemos", ids: input.voiceMemoIds })
+  if (input.location)
+    dimensions.push({
+      kind: "location",
+      latitude: input.location.latitude,
+      longitude: input.location.longitude,
+    })
+
+  const title = input.song?.title.trim()
+  const artist = input.song?.artist.trim()
+  if (title && artist) dimensions.push({ kind: "song", title, artist })
+
+  return dimensions
+}
diff --git a/spa/src/lib/logged-at.ts b/spa/src/lib/logged-at.ts
new file mode 100644
index 0000000..0506cb3
--- /dev/null
+++ b/spa/src/lib/logged-at.ts
@@ -0,0 +1,31 @@
+import { format } from "date-fns"
+
+const RFC3339_WITH_LOCAL_OFFSET = "yyyy-MM-dd'T'HH:mm:ssXXX"
+const TIME_OF_DAY = "HH:mm"
+
+export function toLoggedAt(moment: Date): string {
+  return format(moment, RFC3339_WITH_LOCAL_OFFSET)
+}
+
+export function fromLoggedAt(value: string): Date {
+  return new Date(value)
+}
+
+export function timeOfDayOf(moment: Date): string {
+  return format(moment, TIME_OF_DAY)
+}
+
+export function withDayOf(moment: Date, day: Date): Date {
+  const moved = new Date(moment)
+  moved.setFullYear(day.getFullYear(), day.getMonth(), day.getDate())
+  return moved
+}
+
+export function withTimeOfDay(moment: Date, timeOfDay: string): Date {
+  const [hours, minutes] = timeOfDay.split(":").map(Number)
+  if (!Number.isFinite(hours) || !Number.isFinite(minutes)) return moment
+
+  const moved = new Date(moment)
+  moved.setHours(hours, minutes, 0, 0)
+  return moved
+}
diff --git a/spa/src/lib/utils.ts b/spa/src/lib/utils.ts
index bd0c391..806b88a 100644
--- a/spa/src/lib/utils.ts
+++ b/spa/src/lib/utils.ts
@@ -1,4 +1,5 @@
-import { clsx, type ClassValue } from "clsx"
+import { clsx } from "clsx"
+import type { ClassValue } from "clsx"
 import { twMerge } from "tailwind-merge"
 
 export function cn(...inputs: ClassValue[]) {
diff --git a/spa/src/main.tsx b/spa/src/main.tsx
index 3ad65a1..6448d74 100644
--- a/spa/src/main.tsx
+++ b/spa/src/main.tsx
@@ -6,8 +6,7 @@ import {
   QueryClientProvider,
 } from "@tanstack/react-query"
 import { getRouter } from "./router"
-import { toast } from "@/components/ui/toast"
-import { Toaster } from "@/components/ui/toast"
+import { toast, Toaster } from "@/components/ui/toast"
 import { ApiError } from "@/api/client"
 import "./styles.css"
 
diff --git a/spa/src/routeTree.gen.ts b/spa/src/routeTree.gen.ts
index 73edc37..61ce1f8 100644
--- a/spa/src/routeTree.gen.ts
+++ b/spa/src/routeTree.gen.ts
@@ -8,198 +8,210 @@
 // You should NOT make any changes in this file as it will be overwritten.
 // Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
 
-import { Route as rootRouteImport } from "./routes/__root"
-import { Route as AuthRouteImport } from "./routes/_auth"
-import { Route as LoginRouteImport } from "./routes/login"
-import { Route as RegisterRouteImport } from "./routes/register"
-import { Route as AuthIndexRouteImport } from "./routes/_auth/index"
-import { Route as AuthActivitiesRouteImport } from "./routes/_auth/activities"
-import { Route as AuthAddRouteImport } from "./routes/_auth/add"
-import { Route as AuthCalendarRouteImport } from "./routes/_auth/calendar"
-import { Route as AuthDiaryRouteImport } from "./routes/_auth/diary"
-import { Route as AuthExportRouteImport } from "./routes/_auth/export"
-import { Route as AuthImportRouteImport } from "./routes/_auth/import"
-import { Route as AuthRemindersRouteImport } from "./routes/_auth/reminders"
-import { Route as AuthSettingsRouteImport } from "./routes/_auth/settings"
-import { Route as AuthStatsRouteImport } from "./routes/_auth/stats"
-import { Route as AuthEditIdRouteImport } from "./routes/_auth/edit.$id"
-import { Route as AuthEntryIdRouteImport } from "./routes/_auth/entry.$id"
+import { Route as rootRouteImport } from './routes/__root'
+import { Route as AuthRouteImport } from './routes/_auth'
+import { Route as LoginRouteImport } from './routes/login'
+import { Route as RegisterRouteImport } from './routes/register'
+import { Route as AuthIndexRouteImport } from './routes/_auth/index'
+import { Route as AuthActivitiesRouteImport } from './routes/_auth/activities'
+import { Route as AuthAddRouteImport } from './routes/_auth/add'
+import { Route as AuthCalendarRouteImport } from './routes/_auth/calendar'
+import { Route as AuthDiaryRouteImport } from './routes/_auth/diary'
+import { Route as AuthExportRouteImport } from './routes/_auth/export'
+import { Route as AuthImportRouteImport } from './routes/_auth/import'
+import { Route as AuthMetricsRouteImport } from './routes/_auth/metrics'
+import { Route as AuthRemindersRouteImport } from './routes/_auth/reminders'
+import { Route as AuthSettingsRouteImport } from './routes/_auth/settings'
+import { Route as AuthStatsRouteImport } from './routes/_auth/stats'
+import { Route as AuthEditIdRouteImport } from './routes/_auth/edit.$id'
+import { Route as AuthEntryIdRouteImport } from './routes/_auth/entry.$id'
 
 const AuthRoute = AuthRouteImport.update({
-  id: "/_auth",
+  id: '/_auth',
   getParentRoute: () => rootRouteImport,
 } as any)
 const LoginRoute = LoginRouteImport.update({
-  id: "/login",
-  path: "/login",
+  id: '/login',
+  path: '/login',
   getParentRoute: () => rootRouteImport,
 } as any)
 const RegisterRoute = RegisterRouteImport.update({
-  id: "/register",
-  path: "/register",
+  id: '/register',
+  path: '/register',
   getParentRoute: () => rootRouteImport,
 } as any)
 const AuthIndexRoute = AuthIndexRouteImport.update({
-  id: "/",
-  path: "/",
+  id: '/',
+  path: '/',
   getParentRoute: () => AuthRoute,
 } as any)
 const AuthActivitiesRoute = AuthActivitiesRouteImport.update({
-  id: "/activities",
-  path: "/activities",
+  id: '/activities',
+  path: '/activities',
   getParentRoute: () => AuthRoute,
 } as any)
 const AuthAddRoute = AuthAddRouteImport.update({
-  id: "/add",
-  path: "/add",
+  id: '/add',
+  path: '/add',
   getParentRoute: () => AuthRoute,
 } as any)
 const AuthCalendarRoute = AuthCalendarRouteImport.update({
-  id: "/calendar",
-  path: "/calendar",
+  id: '/calendar',
+  path: '/calendar',
   getParentRoute: () => AuthRoute,
 } as any)
 const AuthDiaryRoute = AuthDiaryRouteImport.update({
-  id: "/diary",
-  path: "/diary",
+  id: '/diary',
+  path: '/diary',
   getParentRoute: () => AuthRoute,
 } as any)
 const AuthExportRoute = AuthExportRouteImport.update({
-  id: "/export",
-  path: "/export",
+  id: '/export',
+  path: '/export',
   getParentRoute: () => AuthRoute,
 } as any)
 const AuthImportRoute = AuthImportRouteImport.update({
-  id: "/import",
-  path: "/import",
+  id: '/import',
+  path: '/import',
+  getParentRoute: () => AuthRoute,
+} as any)
+const AuthMetricsRoute = AuthMetricsRouteImport.update({
+  id: '/metrics',
+  path: '/metrics',
   getParentRoute: () => AuthRoute,
 } as any)
 const AuthRemindersRoute = AuthRemindersRouteImport.update({
-  id: "/reminders",
-  path: "/reminders",
+  id: '/reminders',
+  path: '/reminders',
   getParentRoute: () => AuthRoute,
 } as any)
 const AuthSettingsRoute = AuthSettingsRouteImport.update({
-  id: "/settings",
-  path: "/settings",
+  id: '/settings',
+  path: '/settings',
   getParentRoute: () => AuthRoute,
 } as any)
 const AuthStatsRoute = AuthStatsRouteImport.update({
-  id: "/stats",
-  path: "/stats",
+  id: '/stats',
+  path: '/stats',
   getParentRoute: () => AuthRoute,
-} as any).lazy(() => import("./routes/_auth/stats.lazy").then((d) => d.Route))
+} as any).lazy(() => import('./routes/_auth/stats.lazy').then((d) => d.Route))
 const AuthEditIdRoute = AuthEditIdRouteImport.update({
-  id: "/edit/$id",
-  path: "/edit/$id",
+  id: '/edit/$id',
+  path: '/edit/$id',
   getParentRoute: () => AuthRoute,
 } as any)
 const AuthEntryIdRoute = AuthEntryIdRouteImport.update({
-  id: "/entry/$id",
-  path: "/entry/$id",
+  id: '/entry/$id',
+  path: '/entry/$id',
   getParentRoute: () => AuthRoute,
 } as any)
 
 export interface FileRoutesByFullPath {
-  "/": typeof AuthIndexRoute
-  "/login": typeof LoginRoute
-  "/register": typeof RegisterRoute
-  "/activities": typeof AuthActivitiesRoute
-  "/add": typeof AuthAddRoute
-  "/calendar": typeof AuthCalendarRoute
-  "/diary": typeof AuthDiaryRoute
-  "/export": typeof AuthExportRoute
-  "/import": typeof AuthImportRoute
-  "/reminders": typeof AuthRemindersRoute
-  "/settings": typeof AuthSettingsRoute
-  "/stats": typeof AuthStatsRoute
-  "/edit/$id": typeof AuthEditIdRoute
-  "/entry/$id": typeof AuthEntryIdRoute
+  '/': typeof AuthIndexRoute
+  '/login': typeof LoginRoute
+  '/register': typeof RegisterRoute
+  '/activities': typeof AuthActivitiesRoute
+  '/add': typeof AuthAddRoute
+  '/calendar': typeof AuthCalendarRoute
+  '/diary': typeof AuthDiaryRoute
+  '/export': typeof AuthExportRoute
+  '/import': typeof AuthImportRoute
+  '/metrics': typeof AuthMetricsRoute
+  '/reminders': typeof AuthRemindersRoute
+  '/settings': typeof AuthSettingsRoute
+  '/stats': typeof AuthStatsRoute
+  '/edit/$id': typeof AuthEditIdRoute
+  '/entry/$id': typeof AuthEntryIdRoute
 }
 export interface FileRoutesByTo {
-  "/login": typeof LoginRoute
-  "/register": typeof RegisterRoute
-  "/activities": typeof AuthActivitiesRoute
-  "/add": typeof AuthAddRoute
-  "/calendar": typeof AuthCalendarRoute
-  "/diary": typeof AuthDiaryRoute
-  "/export": typeof AuthExportRoute
-  "/import": typeof AuthImportRoute
-  "/reminders": typeof AuthRemindersRoute
-  "/settings": typeof AuthSettingsRoute
-  "/stats": typeof AuthStatsRoute
-  "/": typeof AuthIndexRoute
-  "/edit/$id": typeof AuthEditIdRoute
-  "/entry/$id": typeof AuthEntryIdRoute
+  '/login': typeof LoginRoute
+  '/register': typeof RegisterRoute
+  '/activities': typeof AuthActivitiesRoute
+  '/add': typeof AuthAddRoute
+  '/calendar': typeof AuthCalendarRoute
+  '/diary': typeof AuthDiaryRoute
+  '/export': typeof AuthExportRoute
+  '/import': typeof AuthImportRoute
+  '/metrics': typeof AuthMetricsRoute
+  '/reminders': typeof AuthRemindersRoute
+  '/settings': typeof AuthSettingsRoute
+  '/stats': typeof AuthStatsRoute
+  '/': typeof AuthIndexRoute
+  '/edit/$id': typeof AuthEditIdRoute
+  '/entry/$id': typeof AuthEntryIdRoute
 }
 export interface FileRoutesById {
   __root__: typeof rootRouteImport
-  "/_auth": typeof AuthRouteWithChildren
-  "/login": typeof LoginRoute
-  "/register": typeof RegisterRoute
-  "/_auth/activities": typeof AuthActivitiesRoute
-  "/_auth/add": typeof AuthAddRoute
-  "/_auth/calendar": typeof AuthCalendarRoute
-  "/_auth/diary": typeof AuthDiaryRoute
-  "/_auth/export": typeof AuthExportRoute
-  "/_auth/import": typeof AuthImportRoute
-  "/_auth/reminders": typeof AuthRemindersRoute
-  "/_auth/settings": typeof AuthSettingsRoute
-  "/_auth/stats": typeof AuthStatsRoute
-  "/_auth/": typeof AuthIndexRoute
-  "/_auth/edit/$id": typeof AuthEditIdRoute
-  "/_auth/entry/$id": typeof AuthEntryIdRoute
+  '/_auth': typeof AuthRouteWithChildren
+  '/login': typeof LoginRoute
+  '/register': typeof RegisterRoute
+  '/_auth/activities': typeof AuthActivitiesRoute
+  '/_auth/add': typeof AuthAddRoute
+  '/_auth/calendar': typeof AuthCalendarRoute
+  '/_auth/diary': typeof AuthDiaryRoute
+  '/_auth/export': typeof AuthExportRoute
+  '/_auth/import': typeof AuthImportRoute
+  '/_auth/metrics': typeof AuthMetricsRoute
+  '/_auth/reminders': typeof AuthRemindersRoute
+  '/_auth/settings': typeof AuthSettingsRoute
+  '/_auth/stats': typeof AuthStatsRoute
+  '/_auth/': typeof AuthIndexRoute
+  '/_auth/edit/$id': typeof AuthEditIdRoute
+  '/_auth/entry/$id': typeof AuthEntryIdRoute
 }
 export interface FileRouteTypes {
   fileRoutesByFullPath: FileRoutesByFullPath
   fullPaths:
-    | "/"
-    | "/login"
-    | "/register"
-    | "/activities"
-    | "/add"
-    | "/calendar"
-    | "/diary"
-    | "/export"
-    | "/import"
-    | "/reminders"
-    | "/settings"
-    | "/stats"
-    | "/edit/$id"
-    | "/entry/$id"
+    | '/'
+    | '/login'
+    | '/register'
+    | '/activities'
+    | '/add'
+    | '/calendar'
+    | '/diary'
+    | '/export'
+    | '/import'
+    | '/metrics'
+    | '/reminders'
+    | '/settings'
+    | '/stats'
+    | '/edit/$id'
+    | '/entry/$id'
   fileRoutesByTo: FileRoutesByTo
   to:
-    | "/login"
-    | "/register"
-    | "/activities"
-    | "/add"
-    | "/calendar"
-    | "/diary"
-    | "/export"
-    | "/import"
-    | "/reminders"
-    | "/settings"
-    | "/stats"
-    | "/"
-    | "/edit/$id"
-    | "/entry/$id"
+    | '/login'
+    | '/register'
+    | '/activities'
+    | '/add'
+    | '/calendar'
+    | '/diary'
+    | '/export'
+    | '/import'
+    | '/metrics'
+    | '/reminders'
+    | '/settings'
+    | '/stats'
+    | '/'
+    | '/edit/$id'
+    | '/entry/$id'
   id:
-    | "__root__"
-    | "/_auth"
-    | "/login"
-    | "/register"
-    | "/_auth/activities"
-    | "/_auth/add"
-    | "/_auth/calendar"
-    | "/_auth/diary"
-    | "/_auth/export"
-    | "/_auth/import"
-    | "/_auth/reminders"
-    | "/_auth/settings"
-    | "/_auth/stats"
-    | "/_auth/"
-    | "/_auth/edit/$id"
-    | "/_auth/entry/$id"
+    | '__root__'
+    | '/_auth'
+    | '/login'
+    | '/register'
+    | '/_auth/activities'
+    | '/_auth/add'
+    | '/_auth/calendar'
+    | '/_auth/diary'
+    | '/_auth/export'
+    | '/_auth/import'
+    | '/_auth/metrics'
+    | '/_auth/reminders'
+    | '/_auth/settings'
+    | '/_auth/stats'
+    | '/_auth/'
+    | '/_auth/edit/$id'
+    | '/_auth/entry/$id'
   fileRoutesById: FileRoutesById
 }
 export interface RootRouteChildren {
@@ -208,110 +220,117 @@ export interface RootRouteChildren {
   RegisterRoute: typeof RegisterRoute
 }
 
-declare module "@tanstack/react-router" {
+declare module '@tanstack/react-router' {
   interface FileRoutesByPath {
-    "/_auth": {
-      id: "/_auth"
-      path: ""
-      fullPath: "/"
+    '/_auth': {
+      id: '/_auth'
+      path: ''
+      fullPath: '/'
       preLoaderRoute: typeof AuthRouteImport
       parentRoute: typeof rootRouteImport
     }
-    "/login": {
-      id: "/login"
-      path: "/login"
-      fullPath: "/login"
+    '/login': {
+      id: '/login'
+      path: '/login'
+      fullPath: '/login'
       preLoaderRoute: typeof LoginRouteImport
       parentRoute: typeof rootRouteImport
     }
-    "/register": {
-      id: "/register"
-      path: "/register"
-      fullPath: "/register"
+    '/register': {
+      id: '/register'
+      path: '/register'
+      fullPath: '/register'
       preLoaderRoute: typeof RegisterRouteImport
       parentRoute: typeof rootRouteImport
     }
-    "/_auth/": {
-      id: "/_auth/"
-      path: "/"
-      fullPath: "/"
+    '/_auth/': {
+      id: '/_auth/'
+      path: '/'
+      fullPath: '/'
       preLoaderRoute: typeof AuthIndexRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/activities": {
-      id: "/_auth/activities"
-      path: "/activities"
-      fullPath: "/activities"
+    '/_auth/activities': {
+      id: '/_auth/activities'
+      path: '/activities'
+      fullPath: '/activities'
       preLoaderRoute: typeof AuthActivitiesRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/add": {
-      id: "/_auth/add"
-      path: "/add"
-      fullPath: "/add"
+    '/_auth/add': {
+      id: '/_auth/add'
+      path: '/add'
+      fullPath: '/add'
       preLoaderRoute: typeof AuthAddRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/calendar": {
-      id: "/_auth/calendar"
-      path: "/calendar"
-      fullPath: "/calendar"
+    '/_auth/calendar': {
+      id: '/_auth/calendar'
+      path: '/calendar'
+      fullPath: '/calendar'
       preLoaderRoute: typeof AuthCalendarRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/diary": {
-      id: "/_auth/diary"
-      path: "/diary"
-      fullPath: "/diary"
+    '/_auth/diary': {
+      id: '/_auth/diary'
+      path: '/diary'
+      fullPath: '/diary'
       preLoaderRoute: typeof AuthDiaryRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/export": {
-      id: "/_auth/export"
-      path: "/export"
-      fullPath: "/export"
+    '/_auth/export': {
+      id: '/_auth/export'
+      path: '/export'
+      fullPath: '/export'
       preLoaderRoute: typeof AuthExportRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/import": {
-      id: "/_auth/import"
-      path: "/import"
-      fullPath: "/import"
+    '/_auth/import': {
+      id: '/_auth/import'
+      path: '/import'
+      fullPath: '/import'
       preLoaderRoute: typeof AuthImportRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/reminders": {
-      id: "/_auth/reminders"
-      path: "/reminders"
-      fullPath: "/reminders"
+    '/_auth/metrics': {
+      id: '/_auth/metrics'
+      path: '/metrics'
+      fullPath: '/metrics'
+      preLoaderRoute: typeof AuthMetricsRouteImport
+      parentRoute: typeof AuthRoute
+    }
+    '/_auth/reminders': {
+      id: '/_auth/reminders'
+      path: '/reminders'
+      fullPath: '/reminders'
       preLoaderRoute: typeof AuthRemindersRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/settings": {
-      id: "/_auth/settings"
-      path: "/settings"
-      fullPath: "/settings"
+    '/_auth/settings': {
+      id: '/_auth/settings'
+      path: '/settings'
+      fullPath: '/settings'
       preLoaderRoute: typeof AuthSettingsRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/stats": {
-      id: "/_auth/stats"
-      path: "/stats"
-      fullPath: "/stats"
+    '/_auth/stats': {
+      id: '/_auth/stats'
+      path: '/stats'
+      fullPath: '/stats'
       preLoaderRoute: typeof AuthStatsRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/edit/$id": {
-      id: "/_auth/edit/$id"
-      path: "/edit/$id"
-      fullPath: "/edit/$id"
+    '/_auth/edit/$id': {
+      id: '/_auth/edit/$id'
+      path: '/edit/$id'
+      fullPath: '/edit/$id'
       preLoaderRoute: typeof AuthEditIdRouteImport
       parentRoute: typeof AuthRoute
     }
-    "/_auth/entry/$id": {
-      id: "/_auth/entry/$id"
-      path: "/entry/$id"
-      fullPath: "/entry/$id"
+    '/_auth/entry/$id': {
+      id: '/_auth/entry/$id'
+      path: '/entry/$id'
+      fullPath: '/entry/$id'
       preLoaderRoute: typeof AuthEntryIdRouteImport
       parentRoute: typeof AuthRoute
     }
@@ -325,6 +344,7 @@ interface AuthRouteChildren {
   AuthDiaryRoute: typeof AuthDiaryRoute
   AuthExportRoute: typeof AuthExportRoute
   AuthImportRoute: typeof AuthImportRoute
+  AuthMetricsRoute: typeof AuthMetricsRoute
   AuthRemindersRoute: typeof AuthRemindersRoute
   AuthSettingsRoute: typeof AuthSettingsRoute
   AuthStatsRoute: typeof AuthStatsRoute
@@ -340,6 +360,7 @@ const AuthRouteChildren: AuthRouteChildren = {
   AuthDiaryRoute: AuthDiaryRoute,
   AuthExportRoute: AuthExportRoute,
   AuthImportRoute: AuthImportRoute,
+  AuthMetricsRoute: AuthMetricsRoute,
   AuthRemindersRoute: AuthRemindersRoute,
   AuthSettingsRoute: AuthSettingsRoute,
   AuthStatsRoute: AuthStatsRoute,
diff --git a/spa/src/routes/_auth.tsx b/spa/src/routes/_auth.tsx
index 207d789..37ecaae 100644
--- a/spa/src/routes/_auth.tsx
+++ b/spa/src/routes/_auth.tsx
@@ -1,6 +1,7 @@
 import { createFileRoute, Outlet, redirect } from "@tanstack/react-router"
 import { AppShell } from "@/components/layout/app-shell"
 import { Skeleton } from "@/components/ui/skeleton"
+import { useEnsureTimezone } from "@/hooks/use-timezone"
 
 export const Route = createFileRoute("/_auth")({
   beforeLoad: () => {
@@ -22,6 +23,8 @@ export const Route = createFileRoute("/_auth")({
 })
 
 function AuthLayout() {
+  useEnsureTimezone()
+
   return (
     <AppShell>
       <Outlet />
diff --git a/spa/src/routes/_auth/add.tsx b/spa/src/routes/_auth/add.tsx
index 94ef3d6..e037d8b 100644
--- a/spa/src/routes/_auth/add.tsx
+++ b/spa/src/routes/_auth/add.tsx
@@ -1,5 +1,6 @@
 import { createFileRoute, useNavigate } from "@tanstack/react-router"
-import { EntryForm, type EntryFormData } from "@/components/entry/entry-form"
+import { EntryForm } from "@/components/entry/entry-form"
+import type { EntryFormData } from "@/components/entry/entry-form"
 import { useCreateEntry } from "@/hooks/use-entries"
 
 export const Route = createFileRoute("/_auth/add")({ component: AddEntryPage })
diff --git a/spa/src/routes/_auth/calendar.tsx b/spa/src/routes/_auth/calendar.tsx
index 4c5f9a8..60d9856 100644
--- a/spa/src/routes/_auth/calendar.tsx
+++ b/spa/src/routes/_auth/calendar.tsx
@@ -35,10 +35,11 @@ function CalendarPage() {
     : false
   const canGoForward = isBefore(startOfMonth(month), startOfMonth(new Date()))
 
-  const selectedEntries = selectedDate
-    ? (days?.find((d) => isSameDay(new Date(d.date), selectedDate))?.entries ??
-      [])
-    : []
+  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">
@@ -75,8 +76,13 @@ function CalendarPage() {
 
       {selectedDate && (
         <section>
-          <h2 className="mb-2 text-sm font-medium text-muted-foreground">
+          <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">
@@ -117,8 +123,8 @@ function MoodCalendarGrid({
 
   const moodMap = new Map<string, number>()
   for (const day of days) {
-    if (day.dominantMood) {
-      moodMap.set(day.date, day.dominantMood)
+    if (day.mood) {
+      moodMap.set(day.date, day.mood)
     }
   }
 
diff --git a/spa/src/routes/_auth/edit.$id.tsx b/spa/src/routes/_auth/edit.$id.tsx
index 6c0e31b..e3b6c5e 100644
--- a/spa/src/routes/_auth/edit.$id.tsx
+++ b/spa/src/routes/_auth/edit.$id.tsx
@@ -1,8 +1,17 @@
+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, type EntryFormData } from "@/components/entry/entry-form"
+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"
 
@@ -62,10 +71,13 @@ function EditEntryPage() {
         onSubmit={handleSubmit}
         initial={{
           mood: entry.mood,
-          content: entry.content ?? undefined,
-          activities: entry.activities,
-          photos: entry.photos,
-          voiceMemos: entry.voiceMemos,
+          loggedAt: entry.loggedAt,
+          content: contentOf(entry) ?? undefined,
+          activities: activitiesOf(entry),
+          photos: photosOf(entry),
+          voiceMemos: voiceMemosOf(entry),
+          location: locationOf(entry),
+          song: songOf(entry),
         }}
       />
     </div>
diff --git a/spa/src/routes/_auth/entry.$id.tsx b/spa/src/routes/_auth/entry.$id.tsx
index 037a2f7..c696f10 100644
--- a/spa/src/routes/_auth/entry.$id.tsx
+++ b/spa/src/routes/_auth/entry.$id.tsx
@@ -1,8 +1,17 @@
+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 {
@@ -113,38 +122,70 @@ function EntryDetailPage() {
         </CardContent>
       </Card>
 
-      {entry.content && (
+      {contentOf(entry) && (
         <Card>
           <CardHeader className="pb-2">
             <CardTitle className="text-sm">Note</CardTitle>
           </CardHeader>
           <CardContent>
-            <p className="text-sm whitespace-pre-wrap">{entry.content}</p>
+            <p className="text-sm whitespace-pre-wrap">{contentOf(entry)}</p>
           </CardContent>
         </Card>
       )}
 
-      {entry.activities.length > 0 && (
+      {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={entry.activities}
+              activityIds={activitiesOf(entry)}
               allActivities={activities ?? []}
             />
           </CardContent>
         </Card>
       )}
 
-      {entry.photos.length > 0 && (
+      {photosOf(entry).length > 0 && (
         <Card>
           <CardHeader className="pb-2">
             <CardTitle className="text-sm">Photos</CardTitle>
           </CardHeader>
           <CardContent className="grid grid-cols-2 gap-2">
-            {entry.photos.map((photoId) => (
+            {photosOf(entry).map((photoId) => (
               <img
                 key={photoId}
                 src={media.photoUrl(photoId)}
@@ -156,13 +197,13 @@ function EntryDetailPage() {
         </Card>
       )}
 
-      {entry.voiceMemos.length > 0 && (
+      {voiceMemosOf(entry).length > 0 && (
         <Card>
           <CardHeader className="pb-2">
             <CardTitle className="text-sm">Voice memos</CardTitle>
           </CardHeader>
           <CardContent className="flex flex-col gap-2">
-            {entry.voiceMemos.map((memoId) => (
+            {voiceMemosOf(entry).map((memoId) => (
               <AudioPlayer key={memoId} src={media.voiceMemoUrl(memoId)} />
             ))}
           </CardContent>
diff --git a/spa/src/routes/_auth/export.tsx b/spa/src/routes/_auth/export.tsx
index 33d5c30..b283517 100644
--- a/spa/src/routes/_auth/export.tsx
+++ b/spa/src/routes/_auth/export.tsx
@@ -1,63 +1,100 @@
 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 { useExport } from "@/hooks/use-import-export"
-import { Download, FileArchive } from "lucide-react"
+import {
+  useCompleteBackup,
+  useShareableExtract,
+} from "@/hooks/use-import-export"
 
 export const Route = createFileRoute("/_auth/export")({
   component: ExportPage,
 })
 
 function ExportPage() {
-  const exportData = useExport()
+  const backup = useCompleteBackup()
+  const extract = useShareableExtract()
 
   return (
     <div className="flex flex-col gap-6 py-6">
-      <h1 className="text-xl font-bold">Export data</h1>
+      <h1 className="text-xl font-bold">Take your data out</h1>
 
-      <Card>
-        <CardHeader>
-          <CardTitle className="text-sm">What's included</CardTitle>
+      <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-2 text-sm text-muted-foreground">
-          <p>Your export will contain:</p>
-          <ul className="list-inside list-disc space-y-1">
-            <li>All mood entries with notes</li>
-            <li>Your activity catalog</li>
-            <li>Photos and voice memos</li>
-            <li>Reminder schedules</li>
-          </ul>
-          <p className="mt-2">
-            The export is a ZIP file in k-mood's native format. You can
-            re-import it into any k-mood instance.
+        <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>
 
-      <Button
-        size="lg"
-        onClick={() => exportData.mutate()}
-        disabled={exportData.isPending}
-        className="w-full"
-      >
-        {exportData.isPending ? (
-          <>Preparing export...</>
-        ) : (
-          <>
-            <Download className="mr-2 h-4 w-4" />
-            Download export
-          </>
-        )}
-      </Button>
-
-      {exportData.isSuccess && (
-        <Card>
-          <CardContent className="flex items-center gap-3 py-4">
-            <FileArchive className="h-5 w-5 text-green-500" />
-            <span className="text-sm">Export downloaded successfully</span>
-          </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/import.tsx b/spa/src/routes/_auth/import.tsx
index 2b9bd47..39e6d0a 100644
--- a/spa/src/routes/_auth/import.tsx
+++ b/spa/src/routes/_auth/import.tsx
@@ -2,11 +2,11 @@ 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 } from "@/hooks/use-import-export"
+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 } from "@/api/schema"
+import type { ImportResultResponse, RestoreOutcomeResponse } from "@/api/schema"
 
 export const Route = createFileRoute("/_auth/import")({
   component: ImportPage,
@@ -18,22 +18,30 @@ 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
-    importData.mutate(file, {
-      onSuccess: (data) => setResult(data),
-    })
+
+    if (source === "kmood") {
+      restoreBackup.mutate(file, { onSuccess: setRestored })
+      return
+    }
+
+    importData.mutate(file, { onSuccess: setResult })
   }
 
   return (
@@ -53,7 +61,7 @@ function ImportPage() {
             />
             <SourceOption
               label="k-mood backup"
-              description="Restore from a k-mood ZIP export"
+              description="Restore a complete backup, with everything in it"
               onClick={() => setSource("kmood")}
             />
             <SourceOption
@@ -65,7 +73,7 @@ function ImportPage() {
         </Card>
       )}
 
-      {(source === "daylio" || source === "kmood") && !result && (
+      {(source === "daylio" || source === "kmood") && !result && !restored && (
         <Card>
           <CardHeader>
             <CardTitle className="text-sm">
@@ -77,8 +85,8 @@ function ImportPage() {
           <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."
-                : "Upload a previously exported k-mood ZIP file to restore your data."}
+                ? "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
@@ -102,15 +110,19 @@ function ImportPage() {
               <Button
                 size="lg"
                 onClick={handleImport}
-                disabled={importData.isPending}
+                disabled={working}
                 className="w-full"
               >
-                {importData.isPending ? (
-                  "Importing..."
+                {working ? (
+                  source === "kmood" ? (
+                    "Restoring..."
+                  ) : (
+                    "Importing..."
+                  )
                 ) : (
                   <>
                     <Upload className="mr-2 h-4 w-4" />
-                    Import
+                    {source === "kmood" ? "Restore" : "Import"}
                   </>
                 )}
               </Button>
@@ -123,7 +135,9 @@ function ImportPage() {
 
       {result && <WizardResult result={result} />}
 
-      {source && !result && (
+      {restored && <RestoreSummary outcome={restored} />}
+
+      {source && !result && !restored && (
         <Button
           variant="ghost"
           onClick={() => {
@@ -158,3 +172,43 @@ function SourceOption({
     </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>
+  )
+}
diff --git a/spa/src/routes/_auth/index.tsx b/spa/src/routes/_auth/index.tsx
index 930a307..6019d35 100644
--- a/spa/src/routes/_auth/index.tsx
+++ b/spa/src/routes/_auth/index.tsx
@@ -1,9 +1,11 @@
 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"
 
@@ -15,6 +17,9 @@ function DashboardPage() {
   const { data: stats, isLoading: statsLoading } = useMoodStats()
 
   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
 
   return (
@@ -35,6 +40,20 @@ function DashboardPage() {
         </Card>
       )}
 
+      <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>
+
       {statsLoading ? (
         <Skeleton className="h-24" />
       ) : stats ? (
diff --git a/spa/src/routes/_auth/metrics.tsx b/spa/src/routes/_auth/metrics.tsx
new file mode 100644
index 0000000..99d5b00
--- /dev/null
+++ b/spa/src/routes/_auth/metrics.tsx
@@ -0,0 +1,156 @@
+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"
+
+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>
+  )
+}
diff --git a/spa/src/routes/_auth/reminders.tsx b/spa/src/routes/_auth/reminders.tsx
index 0dbed3c..cdc8d93 100644
--- a/spa/src/routes/_auth/reminders.tsx
+++ b/spa/src/routes/_auth/reminders.tsx
@@ -1,5 +1,5 @@
 import { useState } from "react"
-import { createFileRoute } from "@tanstack/react-router"
+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"
@@ -22,7 +22,6 @@ import {
 } from "@/hooks/use-reminders"
 import type { ReminderResponse, CreateReminderRequest } from "@/api/schema"
 import { Plus, Trash2, ArrowLeft } from "lucide-react"
-import { Link } from "@tanstack/react-router"
 
 export const Route = createFileRoute("/_auth/reminders")({
   component: RemindersPage,
@@ -293,7 +292,7 @@ function ReminderForm({
               {schedule[key] && (
                 <input
                   type="time"
-                  value={schedule[key]!}
+                  value={schedule[key]}
                   onChange={(e) => setTime(key, e.target.value)}
                   className="h-9 rounded-md border bg-transparent px-3 text-sm"
                 />
diff --git a/spa/src/routes/_auth/settings.tsx b/spa/src/routes/_auth/settings.tsx
index 0d97548..c96de6b 100644
--- a/spa/src/routes/_auth/settings.tsx
+++ b/spa/src/routes/_auth/settings.tsx
@@ -3,6 +3,10 @@ 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 {
@@ -80,6 +84,14 @@ function SettingsPage() {
         timezone={user?.timezone ?? null}
       />
 
+      <SubsonicCard />
+
+      <CycleCard />
+
+      <ApiTokensCard />
+
+      <RejectionsCard />
+
       <Card>
         <CardHeader>
           <CardTitle className="text-sm">Personalization</CardTitle>
diff --git a/spa/src/routes/_auth/stats.lazy.tsx b/spa/src/routes/_auth/stats.lazy.tsx
index 38702e9..5643a7b 100644
--- a/spa/src/routes/_auth/stats.lazy.tsx
+++ b/spa/src/routes/_auth/stats.lazy.tsx
@@ -8,7 +8,7 @@ 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 { ActivityCorrelations } from "@/components/stats/activity-correlations"
+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"
@@ -57,18 +57,18 @@ function StatsPage() {
               }
             />
             <StatCard label="Streak" value={`${stats.currentStreak}d`} />
-            <StatCard label="Entries" value={stats.totalEntries ?? 0} />
+            <StatCard label="Entries" value={stats.totalEntries} />
           </div>
 
           {trendEntries?.length ? (
             <MoodTrendChart entries={trendEntries} period={period} />
           ) : null}
 
-          {stats.frequency?.length ? (
+          {stats.frequency.length ? (
             <MoodDistribution frequency={stats.frequency} />
           ) : null}
 
-          <ActivityCorrelations />
+          <MoodCorrelations />
         </>
       ) : null}