richardthe3rd
diff --git a/‎docs/adr/0006-check-in-as-primary-my-festival-entity.md‎
Lines changed: 67 additions & 7 deletions b/‎docs/adr/0006-check-in-as-primary-my-festival-entity.md‎
Lines changed: 67 additions & 7 deletions
diff --git a/‎docs/adr/README.md‎
Lines changed: 1 addition & 1 deletion b/‎docs/adr/README.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎lib/constants/preference_keys.dart‎
Lines changed: 36 additions & 6 deletions b/‎lib/constants/preference_keys.dart‎
Lines changed: 36 additions & 6 deletions
diff --git a/‎lib/domain/repositories/api_drink_repository.dart‎
Lines changed: 60 additions & 60 deletions b/‎lib/domain/repositories/api_drink_repository.dart‎
Lines changed: 60 additions & 60 deletions
@@ -1,11 +1,24 @@
 # ADR 0006: The Check-in as the Primary My Festival Entity
 
-**Status**: Accepted
+**Status**: Accepted (amended 2026-07-05 — see [Amendments](#amendments))
 
 **Date**: 2026-07-04
 
 **Deciders**: Maintainer (richardthe3rd)
 
+> **Amendment 2026-07-05 (implemented in #461/#463):** one sub-decision below
+> was reversed during implementation. A drink's **rating and notes are
+> drink-level and independent of the tasting timeline** — a user can rate or
+> note a drink *without* recording that they drank it, and clearing the tasting
+> log never wipes a rating. They are **not** derived from "the most recent
+> tasting." This supersedes the "Drink-level values are derived, not stored"
+> text in [Decision](#decision) bullet 4, the migration's rated-but-never-tasted
+> synthesis in [Consequences](#consequences), and Open Question 1 — read the
+> [Amendments](#amendments) section for the current model. (This change is about
+> **rating and notes** only; `wouldRecommend` remains a reserved **per-pour**
+> field, unaffected.) The rest of the ADR — the check-in as the primary diary
+> entity, the per-entry timeline, `wantToTry` as the plan axis — stands.
+
 **Context**: "My Festival" has two jobs for a user: it is a **plan** (a
 forward-looking wishlist of drinks they intend to try) *and* a **diary** (a
 backward-looking record of their festival). The current model is
@@ -259,15 +272,62 @@ migration **first and alone**:
 ## Open Questions
 
 1. **Migration of a rating with no tasting**: synthesise a tasting entry, or keep
-   a per-drink "overall"? (Recommended: synthesise, to keep one model.)
+   a per-drink "overall"? — **Resolved** by the 2026-07-05 amendment: keep a
+   per-drink detail record; do **not** synthesise. See [Amendments](#amendments).
 2. **When, if ever, does the wire contract go per-entry?** (Deferred to a future
    proto-first ADR; not required for the local diary.)
 
 _Decided:_
 - _Kind is **derived** from `drinkId` (present = tasting, absent = freeform
-  `other`); no stored `kind` field. Two kinds only; rating/recommend on tastings._
-- _A drink's displayed/synced rating & recommend = its **most recent tasting's**
-  value (shown as "your latest"); pours = tasting count._
-- _Storage is **per-entry keyed records** + a per-drink `wantToTry` flag; no
-  entry pruning (explicit delete only)._
+  `other`); no stored `kind` field. Two kinds only._
+- _A drink's rating & notes are **drink-level and independent of tastings**
+  (amended 2026-07-05 — superseded "most recent tasting's value"); pours =
+  tasting count. See [Amendments](#amendments)._
+- _Storage is **per-entry keyed records** for the timeline, a per-drink
+  `wantToTry` flag, and a per-drink **detail record** for rating/notes/photos;
+  no entry pruning (explicit delete only)._
 - _Rollout is **migration-first**, one consumer per PR (see Phasing)._
+
+---
+
+## Amendments
+
+### 2026-07-05 — rating & notes are drink-level, independent of tastings
+
+**Implemented in:** #461 / PR #463.
+
+**What changed:** the ADR originally decided that a drink's rating/recommend/notes
+**derive from its most recent tasting**, with a rated-but-never-tasted drink
+**synthesising** a tasting on migration. Implementation reversed this.
+
+**Why:** rating a drink is *personal tracking, not a claim that the drink was
+drunk*. A user must be able to rate or note a drink they have only looked at, and
+untoggling "Tasted" (or deleting every tasting) must never wipe a rating. Deriving
+rating from a tasting forced a rating to fabricate a tasting — changing `isTasted`
+as a side effect and making a note-then-clear leave a phantom pour. That
+contradicted the phase's own "interface-preserving, no behaviour change" goal.
+
+**The model now:** three orthogonal per-drink axes.
+
+| Axis | What | Storage |
+|---|---|---|
+| **Plan** | want-to-try | per-festival `want_to_try_{festivalId}` set |
+| **Diary** | timeline of tasting check-ins (pours) | per-entry `log_entry_{festivalId}_{id}` |
+| **Detail** | drink-level rating / notes / photos | per-drink `drink_detail_{festivalId}_{drinkId}`, pruned when empty |
+
+`UserDrinkState` derives rating/notes/photos from the **detail** record and pours
+from the tasting entries. `isTasted` depends only on tastings, so a rated,
+never-tasted drink has `isTasted == false`.
+
+**Migration consequence:** the v1→v2 fold is now lossless and behaviour-preserving
+— `rating`/`notes`/`photoIds` move to the detail record, tasting timestamps become
+**bare pour entries**, and a rated-but-never-tasted drink keeps `isTasted == false`
+(no synthesis).
+
+**Still per-pour (unchanged):** `LogEntry` retains optional `rating` /
+`wouldRecommend` / `note` fields for **future per-pour capture** (#415/#417). This
+amendment only governs the *drink-level* value the current UI reads; if and when a
+per-pour vs drink-level rating both exist, reconciling them is a later decision.
+
+**Wire contract (unchanged):** sync still carries the single per-drink aggregate;
+the detail record is that drink-level value's home.
@@ -32,7 +32,7 @@ Each ADR follows this structure:
 | [0003](0003-parallel-build-strategy.md) | Parallel Build Strategy for Android Releases | Accepted | 2025-12-27 |
 | [0004](0004-path-based-url-strategy.md) | Path-Based URL Strategy for Deep Linking | Accepted | 2025-12-21 |
 | [0005](0005-e2e-testing-strategy.md) | E2E Testing Strategy (Playwright for URL Smoke Tests) | Accepted | 2025-12-21 |
-| [0006](0006-check-in-as-primary-my-festival-entity.md) | The Check-in as the Primary My Festival Entity | Accepted | 2026-07-04 |
+| [0006](0006-check-in-as-primary-my-festival-entity.md) | The Check-in as the Primary My Festival Entity | Accepted (amended 2026-07-05) | 2026-07-04 |
 
 ## Creating a New ADR
 
 
@@ -29,15 +29,36 @@ class PreferenceKeys {
 
   // --- UserDataStore ---
 
-  /// Prefix for the unified per-drink personal record (favourite/want-to-try,
-  /// ratings, tasting events, notes, photos). One structured JSON entry per
-  /// drink-per-festival, scoped as `$userStatePrefix${festivalId}_$drinkId`.
+  /// Prefix for the **legacy v1** unified per-drink personal record
+  /// (favourite/want-to-try, ratings, tasting events, notes, photos). One
+  /// structured JSON blob per drink-per-festival, scoped as
+  /// `$userStatePrefix${festivalId}_$drinkId`.
   ///
-  /// Unifies the former `favorites`, `ratings`, and `tasting_log_` key schemes
-  /// (#391). A one-time migration folds any data stored under those legacy keys
-  /// into this format on first launch (see [legacy keys] below).
+  /// Unified the former `favorites`, `ratings`, and `tasting_log_` key schemes
+  /// (#391). Superseded by the v2 [logEntryPrefix] / [wantToTryPrefix] model
+  /// (ADR 0006): [SharedPreferencesUserDataStore.migrateToLogEntries] reads any
+  /// blob stored under this prefix, folds it into the v2 model, then deletes it.
+  /// Read-only from v2 onward; never written again.
   static const userStatePrefix = 'user_state_';
 
+  /// Prefix for a single **My Festival log entry** (check-in) in the v2 schema
+  /// (ADR 0006). Scoped as `$logEntryPrefix${festivalId}_$entryId`, where
+  /// `entryId` is a UUID. One JSON record per entry; edit/delete key off the
+  /// id. A tasting is an entry whose `drinkId` is non-null.
+  static const logEntryPrefix = 'log_entry_';
+
+  /// Per-festival "want to try" plan set in the v2 schema (ADR 0006). Scoped as
+  /// `$wantToTryPrefix$festivalId` → a `StringList` of drink IDs. Present only
+  /// while non-empty (the key is removed when the set empties).
+  static const wantToTryPrefix = 'want_to_try_';
+
+  /// Per-drink **detail** record in the v2 schema: the user's drink-level
+  /// rating, notes, and photo IDs, stored **independently of the tasting
+  /// timeline** so a drink can be rated/noted without being marked tasted.
+  /// Scoped as `$drinkDetailPrefix${festivalId}_$drinkId` → a JSON object.
+  /// Present only while it carries a signal (pruned when empty).
+  static const drinkDetailPrefix = 'drink_detail_';
+
   // --- Legacy personal-state keys (read-only; migration only) ---
 
   /// Legacy favourites key: `${favoritesLegacy}_$festivalId` → `StringList` of
@@ -62,6 +83,15 @@ class PreferenceKeys {
   /// collide with a per-drink record key (`user_state_{festivalId}_{drinkId}`).
   static const legacyMigrationComplete = 'personal_state_migration_v1';
 
+  /// Flag set to `true` after the one-time v1 → v2 migration of per-drink
+  /// [userStatePrefix] blobs into the v2 LogEntry model
+  /// ([logEntryPrefix] + [wantToTryPrefix], ADR 0006). When present and true the
+  /// key-scan is skipped on every launch after the first successful run.
+  ///
+  /// Like [legacyMigrationComplete], deliberately does NOT share the v2 prefixes
+  /// so it cannot collide with an entry or want-to-try record.
+  static const logEntryMigrationComplete = 'my_festival_migration_v2';
+
   // --- FestivalStorageService ---
 
   /// The last selected festival ID. Stored with `setString`.
 
@@ -1,5 +1,8 @@
 import 'dart:async';
 
+import 'package:collection/collection.dart';
+import 'package:uuid/uuid.dart';
+
 import '../../models/models.dart';
 import '../../services/services.dart';
 import 'drink_repository.dart';
@@ -15,6 +18,8 @@ class ApiDrinkRepository implements DrinkRepository {
   final DrinkCacheService _cacheService;
   final AnalyticsService _analyticsService;
 
+  static const Uuid _uuid = Uuid();
+
   ApiDrinkRepository({
     required BeerApiService apiService,
     required UserDataStore userDataStore,
@@ -25,9 +30,14 @@ class ApiDrinkRepository implements DrinkRepository {
        _cacheService = cacheService,
        _analyticsService = analyticsService;
 
-  /// The current record, or a fresh empty one, ready to be mutated and written.
-  UserDrinkState _mutableState(String festivalId, String drinkId) =>
-      _userDataStore.read(festivalId, drinkId) ?? UserDrinkState.initial();
+  /// The drink's tasting entries, oldest first. A tasting is an entry whose
+  /// `drinkId` matches (ADR 0006).
+  List<LogEntry> _tastingsFor(String festivalId, String drinkId) =>
+      _userDataStore
+          .readEntries(festivalId)
+          .where((e) => e.drinkId == drinkId)
+          .toList()
+        ..sort((a, b) => a.when.compareTo(b.when));
 
   @override
   Future<List<Drink>> getDrinks(Festival festival) async {
@@ -129,13 +139,9 @@ class ApiDrinkRepository implements DrinkRepository {
     String festivalId,
     String drinkId,
   ) async {
-    final current = _mutableState(festivalId, drinkId);
-    final persisted = current.copyWith(
-      wantToTry: !current.wantToTry,
-      updatedAt: DateTime.now(),
-    );
-    await _userDataStore.write(festivalId, drinkId, persisted);
-    return persisted.isEmpty ? null : persisted;
+    final want = _userDataStore.readWantToTry(festivalId).contains(drinkId);
+    await _userDataStore.setWantToTry(festivalId, drinkId, value: !want);
+    return _userDataStore.read(festivalId, drinkId);
   }
 
   @override
@@ -156,25 +162,20 @@ class ApiDrinkRepository implements DrinkRepository {
         'Rating must be between 1 and 5 inclusive',
       );
     }
-    final current = _mutableState(festivalId, drinkId);
-    final persisted = current.copyWith(
-      rating: rating,
-      updatedAt: DateTime.now(),
-    );
-    await _userDataStore.write(festivalId, drinkId, persisted);
-    return persisted.isEmpty ? null : persisted;
+    // Rating is a drink-level signal, independent of the tasting timeline — a
+    // user can rate a drink without recording that they drank it, and removing
+    // a tasting never touches the rating.
+    await _userDataStore.setDrinkRating(festivalId, drinkId, rating: rating);
+    return _userDataStore.read(festivalId, drinkId);
   }
 
   @override
   Future<UserDrinkState?> removeRating(
     String festivalId,
     String drinkId,
   ) async {
-    final current = _userDataStore.read(festivalId, drinkId);
-    if (current == null) return null;
-    final persisted = current.copyWith(rating: null, updatedAt: DateTime.now());
-    await _userDataStore.write(festivalId, drinkId, persisted);
-    return persisted.isEmpty ? null : persisted;
+    await _userDataStore.setDrinkRating(festivalId, drinkId, rating: null);
+    return _userDataStore.read(festivalId, drinkId);
   }
 
   @override
@@ -187,16 +188,21 @@ class ApiDrinkRepository implements DrinkRepository {
     String festivalId,
     String drinkId,
   ) async {
-    final current = _mutableState(festivalId, drinkId);
-    final now = DateTime.now();
     // Binary toggle preserves the prior single-timestamp behaviour: tasting a
-    // fresh drink records one event; toggling off clears the log. (Recording
-    // multiple tastings is feature work tracked in #315.)
-    final next = current.isTasted
-        ? current.copyWith(tastingEvents: const [], updatedAt: now)
-        : current.copyWith(tastingEvents: [now], updatedAt: now);
-    await _userDataStore.write(festivalId, drinkId, next);
-    return next.isEmpty ? null : next;
+    // fresh drink records one event; toggling off clears the tasting log.
+    // (Multi-tasting capture is #415, built on addTasting/removeTasting.)
+    final tastings = _tastingsFor(festivalId, drinkId);
+    if (tastings.isEmpty) {
+      await _userDataStore.writeEntry(
+        festivalId,
+        LogEntry(id: _uuid.v4(), when: DateTime.now(), drinkId: drinkId),
+      );
+    } else {
+      for (final tasting in tastings) {
+        await _userDataStore.removeEntry(festivalId, tasting.id);
+      }
+    }
+    return _userDataStore.read(festivalId, drinkId);
   }
 
   @override
@@ -205,18 +211,16 @@ class ApiDrinkRepository implements DrinkRepository {
     String drinkId, {
     DateTime? now,
   }) async {
-    final current = _mutableState(festivalId, drinkId);
     final timestamp = now ?? DateTime.now();
-    // Consecutive rapid taps intentionally append duplicate events rather
-    // than debouncing: v1 ships a per-timestamp delete UI to recover from
-    // accidents, and a debounce would add hidden temporal state (#411).
-    final persisted = current.copyWith(
-      tastingEvents: [...current.tastingEvents, timestamp],
-      updatedAt: timestamp,
+    // Consecutive rapid taps intentionally append duplicate events rather than
+    // debouncing: v1 ships a per-timestamp delete UI to recover from accidents,
+    // and a debounce would add hidden temporal state (#411). Each tasting is a
+    // distinct entry with its own id, so identical timestamps stay distinct.
+    await _userDataStore.writeEntry(
+      festivalId,
+      LogEntry(id: _uuid.v4(), when: timestamp, drinkId: drinkId),
     );
-    await _userDataStore.write(festivalId, drinkId, persisted);
-    // An append always leaves at least one event, so the record is never empty.
-    return persisted;
+    return _userDataStore.read(festivalId, drinkId);
   }
 
   @override
@@ -225,18 +229,18 @@ class ApiDrinkRepository implements DrinkRepository {
     String drinkId,
     DateTime event,
   ) async {
-    final current = _userDataStore.read(festivalId, drinkId);
-    if (current == null) return null;
-    final updated = [...current.tastingEvents];
     // Removes the first matching pour; identical timestamps are distinct pours,
-    // so only one goes. Returns the record untouched when the event is absent.
-    if (!updated.remove(event)) return current;
-    final persisted = current.copyWith(
-      tastingEvents: updated,
-      updatedAt: DateTime.now(),
-    );
-    await _userDataStore.write(festivalId, drinkId, persisted);
-    return persisted.isEmpty ? null : persisted;
+    // so only one goes. Leaves the state untouched when the event is absent.
+    // Returns the derived state (null only when the drink has no signal at all —
+    // never prunes a want-to-try / rated drink that simply has no tastings).
+    final match = _tastingsFor(
+      festivalId,
+      drinkId,
+    ).firstWhereOrNull((e) => e.when == event);
+    if (match != null) {
+      await _userDataStore.removeEntry(festivalId, match.id);
+    }
+    return _userDataStore.read(festivalId, drinkId);
   }
 
   @override
@@ -245,16 +249,12 @@ class ApiDrinkRepository implements DrinkRepository {
     String drinkId,
     String? notes,
   ) async {
-    final current = _mutableState(festivalId, drinkId);
     // Blank is not a distinct signal from "no note": store it as null so the
-    // null-means-unset convention holds and the record can prune to empty.
+    // null-means-unset convention holds. Notes are drink-level, independent of
+    // the tasting timeline (same as rating).
     final normalised = (notes == null || notes.isEmpty) ? null : notes;
-    final persisted = current.copyWith(
-      notes: normalised,
-      updatedAt: DateTime.now(),
-    );
-    await _userDataStore.write(festivalId, drinkId, persisted);
-    return persisted.isEmpty ? null : persisted;
+    await _userDataStore.setDrinkNotes(festivalId, drinkId, notes: normalised);
+    return _userDataStore.read(festivalId, drinkId);
   }
 
   @override