feat(chat): usable 1:1 chat — bottom-anchored, Drift-backed, dated

- Anchor the message list to the bottom (`reverse: true`) so new messages
  stay in view instead of landing below the fold.
- Move chat history from the OS keystore (O(n²) JSON blob, silent 200-msg
  cap) to a separate encrypted Drift/SQLCipher DB (`ChatDatabase`):
  indexed append, uncapped history, dedup as a unique-key invariant. It's
  an ephemeral per-device cache, isolated from the inventory schema, its
  migrations, and its sync. No data migration (pre-release).
- Add day separators (Today/Yesterday/locale date) and a per-bubble time,
  all via ICU (12/24h per locale; Localizations locale maps Asturian →
  Spanish for intl date symbols).
- Add peer avatars (deterministic colour from the pubkey + name initial),
  surface send failures that were previously silent, and make bubble text
  selectable (addresses, links).
- New i18n keys in en/es/pt/ast; tests for grouping, formatting, avatars,
  scroll anchoring, storage and send errors.

Docs: docs/design/chat-storage.md + open-decisions.md.

apps/app_seeds/test/domain/chat_timeline_test.dart

@@ -0,0 +1,120 @@
+import 'package:commons_core/commons_core.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:intl/date_symbol_data_local.dart';
+import 'package:tane/domain/chat_timeline.dart';
+
+void main() {
+  // In the app, flutter_localizations loads intl's locale symbols; a pure test
+  // must initialize them itself before any DateFormat.
+  setUpAll(initializeDateFormatting);
+
+  PrivateMessage at(DateTime when) =>
+      PrivateMessage(fromPubkey: 'p', text: 't', at: when);
+
+  group('chatTimeline', () {
+    test('empty in, empty out', () {
+      expect(chatTimeline(const []), isEmpty);
+    });
+
+    test('a day separator precedes the first message of each day', () {
+      final items = chatTimeline([
+        at(DateTime(2026, 6, 14, 10)),
+        at(DateTime(2026, 6, 14, 11)),
+        at(DateTime(2026, 6, 15, 9)),
+      ]);
+      // sep, msg, msg, sep, msg
+      expect(items.map((i) => i is ChatDaySeparator), [
+        true,
+        false,
+        false,
+        true,
+        false,
+      ]);
+      expect((items[0] as ChatDaySeparator).day, DateTime(2026, 6, 14));
+      expect((items[3] as ChatDaySeparator).day, DateTime(2026, 6, 15));
+    });
+
+    test('messages stay oldest-first', () {
+      final items = chatTimeline([
+        at(DateTime(2026, 1, 1, 8)),
+        at(DateTime(2026, 1, 1, 9)),
+      ]);
+      expect(items.whereType<ChatMessageRow>(), hasLength(2));
+      expect(items.whereType<ChatDaySeparator>(), hasLength(1));
+    });
+  });
+
+  group('chatDayLabel', () {
+    final now = DateTime(2026, 6, 15, 12);
+
+    test('the two most recent days use the given today/yesterday labels', () {
+      expect(
+        chatDayLabel(
+          DateTime(2026, 6, 15),
+          now: now,
+          today: 'Today',
+          yesterday: 'Yesterday',
+          localeCode: 'en',
+        ),
+        'Today',
+      );
+      expect(
+        chatDayLabel(
+          DateTime(2026, 6, 14),
+          now: now,
+          today: 'Today',
+          yesterday: 'Yesterday',
+          localeCode: 'en',
+        ),
+        'Yesterday',
+      );
+    });
+
+    test('older days use a locale date, not today/yesterday', () {
+      final label = chatDayLabel(
+        DateTime(2026, 6, 10),
+        now: now,
+        today: 'Today',
+        yesterday: 'Yesterday',
+        localeCode: 'en',
+      );
+      expect(label, isNot(anyOf('Today', 'Yesterday')));
+      expect(label, contains('10')); // the day number
+    });
+
+    test('a previous year is shown', () {
+      final label = chatDayLabel(
+        DateTime(2024, 6, 10),
+        now: now,
+        today: 'Today',
+        yesterday: 'Yesterday',
+        localeCode: 'en',
+      );
+      expect(label, contains('2024'));
+    });
+
+    test('respects the locale (Spanish month name)', () {
+      final label = chatDayLabel(
+        DateTime(2026, 6, 10),
+        now: now,
+        today: 'Hoy',
+        yesterday: 'Ayer',
+        localeCode: 'es',
+      );
+      expect(label.toLowerCase(), contains('junio'));
+    });
+  });
+
+  group('chatBubbleTime', () {
+    test('English uses a 12-hour clock', () {
+      final s = chatBubbleTime(DateTime(2026, 1, 1, 14, 5), 'en');
+      expect(s.toUpperCase(), contains('PM'));
+    });
+
+    test('Spanish uses a 24-hour clock', () {
+      final s = chatBubbleTime(DateTime(2026, 1, 1, 14, 5), 'es');
+      expect(s, contains('14'));
+      expect(s.toUpperCase(), isNot(contains('PM')));
+    });
+  });
+}

apps/app_seeds/test/services/inbox_service_test.dart

@@ -46,7 +46,7 @@ void main() {
   late InboxService inbox;
 
   setUp(() async {
-    store = MessageStore(InMemorySecretStore());
+    store = MessageStore(newTestChatDatabase());
     inbox = InboxService(
       connection: await offlineConnection(),
       selfPubkey: 'me',

apps/app_seeds/test/services/message_store_test.dart

@@ -1,18 +1,24 @@
 import 'package:commons_core/commons_core.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:tane/db/chat_database.dart';
 import 'package:tane/services/message_store.dart';
 
 import '../support/test_support.dart';
 
 void main() {
+  late ChatDatabase db;
   late MessageStore store;
-  setUp(() => store = MessageStore(InMemorySecretStore()));
+  setUp(() {
+    db = newTestChatDatabase();
+    store = MessageStore(db);
+  });
+  tearDown(() => db.close());
 
-  PrivateMessage msg(String from, String text, int atMs) =>
-      PrivateMessage(
-          fromPubkey: from,
-          text: text,
-          at: DateTime.fromMillisecondsSinceEpoch(atMs));
+  PrivateMessage msg(String from, String text, int atMs) => PrivateMessage(
+    fromPubkey: from,
+    text: text,
+    at: DateTime.fromMillisecondsSinceEpoch(atMs),
+  );
 
   test('history is empty for an unknown peer', () async {
     expect(await store.history('peer'), isEmpty);
@@ -34,53 +40,62 @@ void main() {
     expect((await store.history('b')).single.text, 'toB');
   });
 
-  test('conversations lists peers newest-first with their last message',
-      () async {
-    await store.append('peerA', msg('me', 'hi A', 1000));
-    await store.append('peerB', msg('peerB', 'yo B', 3000));
-    await store.append('peerA', msg('peerA', 'back A', 2000));
+  test(
+    'conversations lists peers newest-first with their last message',
+    () async {
+      await store.append('peerA', msg('me', 'hi A', 1000));
+      await store.append('peerB', msg('peerB', 'yo B', 3000));
+      await store.append('peerA', msg('peerA', 'back A', 2000));
 
-    final convos = await store.conversations();
-    expect(convos.map((c) => c.peerPubkey), ['peerB', 'peerA']); // 3000 > 2000
-    expect(convos.first.lastText, 'yo B');
-    expect(convos.last.lastText, 'back A');
-  });
+      final convos = await store.conversations();
+      expect(convos.map((c) => c.peerPubkey), [
+        'peerB',
+        'peerA',
+      ]); // 3000 > 2000
+      expect(convos.first.lastText, 'yo B');
+      expect(convos.last.lastText, 'back A');
+    },
+  );
 
-  test('append is idempotent: a re-delivered message is not duplicated',
-      () async {
-    // Same sender + timestamp + text = the same gift wrap redelivered by a
-    // relay on resubscribe. It must not pile up.
-    expect(await store.append('peer', msg('peer', 'hola', 1000)), isTrue);
-    expect(await store.append('peer', msg('peer', 'hola', 1000)), isFalse);
-    expect(await store.history('peer'), hasLength(1));
+  test(
+    'append is idempotent: a re-delivered message is not duplicated',
+    () async {
+      // Same sender + timestamp + text = the same gift wrap redelivered by a
+      // relay on resubscribe. It must not pile up.
+      expect(await store.append('peer', msg('peer', 'hola', 1000)), isTrue);
+      expect(await store.append('peer', msg('peer', 'hola', 1000)), isFalse);
+      expect(await store.history('peer'), hasLength(1));
 
-    // A genuinely different message (later timestamp) still lands.
-    expect(await store.append('peer', msg('peer', 'hola', 2000)), isTrue);
-    expect(await store.history('peer'), hasLength(2));
-  });
+      // A genuinely different message (later timestamp) still lands.
+      expect(await store.append('peer', msg('peer', 'hola', 2000)), isTrue);
+      expect(await store.history('peer'), hasLength(2));
+    },
+  );
 
-  test('per-identity scope isolates conversations (0 = legacy keys)', () async {
-    final secret = InMemorySecretStore();
-    final acct0 = MessageStore(secret); // legacy / account 0
-    final acct1 = MessageStore(secret, accountScope: 'acct1');
+  test(
+    'per-identity scope isolates conversations (0 = legacy scope)',
+    () async {
+      final acct0 = MessageStore(db); // legacy / account 0
+      final acct1 = MessageStore(db, accountScope: 'acct1');
 
-    await acct0.append('peer', msg('peer', 'for identity 0', 1000));
-    await acct1.append('peer', msg('peer', 'for identity 1', 2000));
+      await acct0.append('peer', msg('peer', 'for identity 0', 1000));
+      await acct1.append('peer', msg('peer', 'for identity 1', 2000));
 
-    // Same peer, but each identity sees only its own conversation.
-    expect((await acct0.history('peer')).single.text, 'for identity 0');
-    expect((await acct1.history('peer')).single.text, 'for identity 1');
-    expect((await acct0.conversations()).single.lastText, 'for identity 0');
-    expect((await acct1.conversations()).single.lastText, 'for identity 1');
-  });
+      // Same peer, but each identity sees only its own conversation.
+      expect((await acct0.history('peer')).single.text, 'for identity 0');
+      expect((await acct1.history('peer')).single.text, 'for identity 1');
+      expect((await acct0.conversations()).single.lastText, 'for identity 0');
+      expect((await acct1.conversations()).single.lastText, 'for identity 1');
+    },
+  );
 
-  test('history is capped to the most recent 200', () async {
+  test('history is uncapped: nothing is silently dropped', () async {
     for (var i = 0; i < 210; i++) {
       await store.append('peer', msg('me', 'm$i', i));
     }
     final history = await store.history('peer');
-    expect(history, hasLength(200));
-    expect(history.first.text, 'm10'); // oldest 10 dropped
+    expect(history, hasLength(210));
+    expect(history.first.text, 'm0'); // the oldest survives
     expect(history.last.text, 'm209');
   });
 }

apps/app_seeds/test/services/unread_service_test.dart

@@ -15,7 +15,7 @@ void main() {
   late UnreadService unread;
 
   setUp(() {
-    store = MessageStore(InMemorySecretStore());
+    store = MessageStore(newTestChatDatabase());
     unread = UnreadService(store, InMemorySecretStore());
   });
 

apps/app_seeds/test/state/messages_cubit_test.dart

@@ -26,6 +26,19 @@ class FakeMessageTransport implements MessageTransport {
   Future<void> close() async => _inbox.close();
 }
 
+/// A transport whose [send] always fails (e.g. no relay reachable).
+class _FailingSendTransport implements MessageTransport {
+  @override
+  Future<void> send({required String toPubkey, required String text}) async =>
+      throw StateError('no relay');
+
+  @override
+  Stream<PrivateMessage> inbox() => const Stream.empty();
+
+  @override
+  Future<void> close() async {}
+}
+
 void main() {
   const peer = 'aa';
   const me = 'bb';
@@ -35,8 +48,8 @@ void main() {
 
   test('receives messages from the peer only', () async {
     final transport = FakeMessageTransport();
-    final cubit =
-        MessagesCubit(transport, peerPubkey: peer, selfPubkey: me)..start();
+    final cubit = MessagesCubit(transport, peerPubkey: peer, selfPubkey: me)
+      ..start();
 
     transport.receive(msg(peer, 'hola'));
     transport.receive(msg('cc', 'not for this chat')); // other conversation
@@ -62,8 +75,8 @@ void main() {
 
   test('a full exchange keeps order and sides', () async {
     final transport = FakeMessageTransport();
-    final cubit =
-        MessagesCubit(transport, peerPubkey: peer, selfPubkey: me)..start();
+    final cubit = MessagesCubit(transport, peerPubkey: peer, selfPubkey: me)
+      ..start();
 
     await cubit.send('hi');
     transport.receive(msg(peer, 'hello'));
@@ -74,6 +87,19 @@ void main() {
     await cubit.close();
   });
 
+  test(
+    'a failed send surfaces an error and drops the optimistic message',
+    () async {
+      final transport = _FailingSendTransport();
+      final cubit = MessagesCubit(transport, peerPubkey: peer, selfPubkey: me);
+      await cubit.send('hi');
+      expect(cubit.state.error, isNotNull);
+      expect(cubit.state.sending, isFalse);
+      expect(cubit.state.messages, isEmpty);
+      await cubit.close();
+    },
+  );
+
   test('empty/whitespace text is not sent', () async {
     final transport = FakeMessageTransport();
     final cubit = MessagesCubit(transport, peerPubkey: peer, selfPubkey: me);
@@ -83,57 +109,88 @@ void main() {
     await cubit.close();
   });
 
-  test('loads saved history on start and persists across a new cubit',
-      () async {
-    final store = MessageStore(InMemorySecretStore());
-    await store.append(
-        peer, msg(peer, 'earlier')); // a message from a previous session
+  test(
+    'loads saved history on start and persists across a new cubit',
+    () async {
+      // History is ordered by each message's own timestamp, so use realistic
+      // monotonic times: 'earlier' predates the sent 'hi' (stamped now() by the
+      // cubit), and 'reply' comes after it.
+      PrivateMessage at(String from, String text, DateTime when) =>
+          PrivateMessage(fromPubkey: from, text: text, at: when);
 
-    final transport = FakeMessageTransport();
-    final cubit = MessagesCubit(transport,
-        peerPubkey: peer, selfPubkey: me, store: store);
-    await cubit.start();
-    expect(cubit.state.messages.map((m) => m.text), ['earlier']);
+      final store = MessageStore(newTestChatDatabase());
+      await store.append(
+        peer,
+        at(peer, 'earlier', DateTime(2020)),
+      ); // from a previous session
 
-    await cubit.send('hi'); // persisted
-    transport.receive(msg(peer, 'reply')); // persisted
-    await pumpEventQueue();
-    expect(cubit.state.messages.map((m) => m.text), ['earlier', 'hi', 'reply']);
-    await cubit.close();
+      final transport = FakeMessageTransport();
+      final cubit = MessagesCubit(
+        transport,
+        peerPubkey: peer,
+        selfPubkey: me,
+        store: store,
+      );
+      await cubit.start();
+      expect(cubit.state.messages.map((m) => m.text), ['earlier']);
 
-    // A fresh cubit (even offline) sees the saved conversation.
-    final reopened =
-        MessagesCubit(null, peerPubkey: peer, selfPubkey: me, store: store);
-    await reopened.start();
-    expect(reopened.state.messages.map((m) => m.text),
-        ['earlier', 'hi', 'reply']);
-    await reopened.close();
-  });
+      await cubit.send('hi'); // persisted, stamped now()
+      transport.receive(at(peer, 'reply', DateTime(2100))); // persisted, later
+      await pumpEventQueue();
+      expect(cubit.state.messages.map((m) => m.text), [
+        'earlier',
+        'hi',
+        'reply',
+      ]);
+      await cubit.close();
 
-  test('a re-delivered wrap is shown once (relay resends stored events)',
-      () async {
-    final transport = FakeMessageTransport();
-    final cubit =
-        MessagesCubit(transport, peerPubkey: peer, selfPubkey: me)..start();
+      // A fresh cubit (even offline) sees the saved conversation.
+      final reopened = MessagesCubit(
+        null,
+        peerPubkey: peer,
+        selfPubkey: me,
+        store: store,
+      );
+      await reopened.start();
+      expect(reopened.state.messages.map((m) => m.text), [
+        'earlier',
+        'hi',
+        'reply',
+      ]);
+      await reopened.close();
+    },
+  );
 
-    final same = msg(peer, 'hola'); // identical sender+timestamp+text
-    transport.receive(same);
-    transport.receive(same); // relay re-delivery on the same subscription
-    await pumpEventQueue();
+  test(
+    'a re-delivered wrap is shown once (relay resends stored events)',
+    () async {
+      final transport = FakeMessageTransport();
+      final cubit = MessagesCubit(transport, peerPubkey: peer, selfPubkey: me)
+        ..start();
 
-    expect(cubit.state.messages, hasLength(1));
-    await cubit.close();
-  });
+      final same = msg(peer, 'hola'); // identical sender+timestamp+text
+      transport.receive(same);
+      transport.receive(same); // relay re-delivery on the same subscription
+      await pumpEventQueue();
+
+      expect(cubit.state.messages, hasLength(1));
+      await cubit.close();
+    },
+  );
 
   test('history already surfaced live is not shown twice', () async {
     // The stored message is ALSO handed back by the live subscription on open.
-    final store = MessageStore(InMemorySecretStore());
+    final store = MessageStore(newTestChatDatabase());
     final m = msg(peer, 'hola');
     await store.append(peer, m);
 
     final transport = FakeMessageTransport();
-    final cubit = MessagesCubit(transport,
-        peerPubkey: peer, selfPubkey: me, store: store);
+    final cubit = MessagesCubit(
+      transport,
+      peerPubkey: peer,
+      selfPubkey: me,
+      store: store,
+    );
     unawaited(cubit.start());
     transport.receive(m); // live redelivery races the history load
     await pumpEventQueue();
@@ -143,7 +200,8 @@ void main() {
   });
 
   test('offline (no transport) never throws', () async {
-    final cubit = MessagesCubit(null, peerPubkey: peer, selfPubkey: me)..start();
+    final cubit = MessagesCubit(null, peerPubkey: peer, selfPubkey: me)
+      ..start();
     expect(cubit.isOnline, isFalse);
     await cubit.send('hi');
     expect(cubit.state.messages, isEmpty);

apps/app_seeds/test/support/test_support.dart

@@ -6,6 +6,7 @@ import 'package:flutter_localizations/flutter_localizations.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:tane/data/species_repository.dart';
 import 'package:tane/data/variety_repository.dart';
+import 'package:tane/db/chat_database.dart';
 import 'package:tane/db/database.dart';
 import 'package:tane/i18n/strings.g.dart';
 import 'package:tane/security/secret_store.dart';
@@ -19,6 +20,9 @@ import 'package:tane/ui/variety_detail_screen.dart';
 /// verified separately in the SQLCipher-only security test).
 AppDatabase newTestDatabase() => AppDatabase(NativeDatabase.memory());
 
+/// A fresh in-memory chat cache for host tests (unencrypted; see above).
+ChatDatabase newTestChatDatabase() => ChatDatabase(NativeDatabase.memory());
+
 /// Unmounts the widget tree *inside* the test and drains the zero-duration
 /// timer Drift schedules when its stream subscription is cancelled. Without
 /// this, flutter_test reports "a Timer is still pending after disposal". Call

apps/app_seeds/test/ui/chat_message_list_test.dart

@@ -0,0 +1,166 @@
+import 'dart:async';
+
+import 'package:commons_core/commons_core.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tane/domain/chat_timeline.dart';
+import 'package:tane/i18n/strings.g.dart';
+import 'package:tane/state/messages_cubit.dart';
+import 'package:tane/ui/chat_screen.dart';
+import 'package:tane/ui/peer_avatar.dart';
+
+/// In-memory [MessageTransport]: lets a test push inbox messages. (Same shape
+/// as the one in messages_cubit_test.dart.)
+class _FakeMessageTransport implements MessageTransport {
+  final StreamController<PrivateMessage> _inbox =
+      StreamController<PrivateMessage>.broadcast();
+
+  void receive(PrivateMessage message) => _inbox.add(message);
+
+  @override
+  Future<void> send({required String toPubkey, required String text}) async {}
+
+  @override
+  Stream<PrivateMessage> inbox() => _inbox.stream;
+
+  @override
+  Future<void> close() async => _inbox.close();
+}
+
+void main() {
+  const peer = 'aa';
+  const me = 'bb';
+
+  PrivateMessage msg(String from, String text, int minute) => PrivateMessage(
+    fromPubkey: from,
+    text: text,
+    at: DateTime(2026, 1, 1, 0, minute),
+  );
+
+  Widget host(MessagesCubit cubit) {
+    LocaleSettings.setLocaleSync(AppLocale.en);
+    return TranslationProvider(
+      child: MaterialApp(
+        locale: AppLocale.en.flutterLocale,
+        supportedLocales: AppLocaleUtils.supportedLocales,
+        localizationsDelegates: const [
+          GlobalMaterialLocalizations.delegate,
+          GlobalWidgetsLocalizations.delegate,
+          GlobalCupertinoLocalizations.delegate,
+        ],
+        home: Scaffold(
+          body: BlocProvider.value(
+            value: cubit,
+            child: const ChatMessageList(),
+          ),
+        ),
+      ),
+    );
+  }
+
+  testWidgets('renders oldest at top, newest at the bottom of the viewport', (
+    tester,
+  ) async {
+    final transport = _FakeMessageTransport();
+    final cubit = MessagesCubit(transport, peerPubkey: peer, selfPubkey: me)
+      ..start();
+    addTearDown(cubit.close);
+
+    transport.receive(msg(peer, 'first', 0));
+    transport.receive(msg(peer, 'second', 1));
+    transport.receive(msg(peer, 'third', 2));
+    await tester.pumpWidget(host(cubit));
+    await tester.pump(); // let the stream events flush into the cubit
+
+    // Bottom-anchored: the newest ('third') sits lower than the oldest.
+    final firstY = tester.getTopLeft(find.text('first')).dy;
+    final thirdY = tester.getTopLeft(find.text('third')).dy;
+    expect(thirdY, greaterThan(firstY));
+
+    // One day separator (all three are the same day) and a per-bubble time.
+    expect(find.byKey(const Key('chat.daySeparator')), findsOneWidget);
+    expect(
+      find.text(chatBubbleTime(DateTime(2026, 1, 1, 0, 0), 'en')),
+      findsOneWidget,
+    );
+  });
+
+  testWidgets('a separator is inserted per calendar day', (tester) async {
+    final transport = _FakeMessageTransport();
+    final cubit = MessagesCubit(transport, peerPubkey: peer, selfPubkey: me)
+      ..start();
+    addTearDown(cubit.close);
+
+    transport.receive(
+      PrivateMessage(
+        fromPubkey: peer,
+        text: 'day one',
+        at: DateTime(2026, 1, 1, 9),
+      ),
+    );
+    transport.receive(
+      PrivateMessage(
+        fromPubkey: peer,
+        text: 'day two',
+        at: DateTime(2026, 1, 2, 9),
+      ),
+    );
+    await tester.pumpWidget(host(cubit));
+    await tester.pump();
+
+    expect(find.byKey(const Key('chat.daySeparator')), findsNWidgets(2));
+  });
+
+  testWidgets('the peer bubble carries an avatar, mine does not', (
+    tester,
+  ) async {
+    final transport = _FakeMessageTransport();
+    final cubit = MessagesCubit(transport, peerPubkey: peer, selfPubkey: me)
+      ..start();
+    addTearDown(cubit.close);
+
+    transport.receive(msg(peer, 'from peer', 0));
+    await cubit.send('from me'); // optimistically mine (fromPubkey == me)
+    await tester.pumpWidget(host(cubit));
+    await tester.pump();
+
+    // One avatar, for the single peer message; my own bubble has none.
+    expect(find.byType(PeerAvatar), findsOneWidget);
+  });
+
+  testWidgets('a new message lands in view at the bottom, not below the fold', (
+    tester,
+  ) async {
+    final transport = _FakeMessageTransport();
+    final cubit = MessagesCubit(transport, peerPubkey: peer, selfPubkey: me)
+      ..start();
+    addTearDown(cubit.close);
+
+    // Fill past a single screen so a naive top-anchored list would push the
+    // newest message off-screen.
+    for (var i = 0; i < 40; i++) {
+      transport.receive(msg(peer, 'line $i', i));
+    }
+    await tester.pumpWidget(host(cubit));
+    await tester.pump();
+
+    transport.receive(msg(peer, 'brand new', 41));
+    await tester.runAsync(() => Future<void>.delayed(Duration.zero));
+    await tester.pump();
+
+    // The just-arrived message is visible without any manual scroll.
+    expect(find.text('brand new'), findsOneWidget);
+  });
+
+  testWidgets('shows the empty note when there are no messages', (
+    tester,
+  ) async {
+    final cubit = MessagesCubit(null, peerPubkey: peer, selfPubkey: me);
+    addTearDown(cubit.close);
+    await tester.pumpWidget(host(cubit));
+    await tester.pump();
+    expect(find.byType(ListView), findsNothing);
+  });
+}

apps/app_seeds/test/ui/peer_avatar_test.dart

@@ -0,0 +1,38 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tane/ui/peer_avatar.dart';
+
+void main() {
+  group('peerAvatarColor', () {
+    test('is deterministic for the same pubkey', () {
+      expect(peerAvatarColor('ab' * 32), peerAvatarColor('ab' * 32));
+    });
+
+    test('differs for different pubkeys', () {
+      expect(peerAvatarColor('ab' * 32), isNot(peerAvatarColor('cd' * 32)));
+    });
+
+    test('is fully opaque (legible disc)', () {
+      expect(peerAvatarColor('feed').a, 1.0);
+    });
+  });
+
+  group('PeerAvatar', () {
+    Widget host(Widget child) => MaterialApp(
+      home: Scaffold(body: Center(child: child)),
+    );
+
+    testWidgets('shows the name initial when known', (tester) async {
+      await tester.pumpWidget(host(PeerAvatar(pubkey: 'aa', name: 'rosa')));
+      expect(find.text('R'), findsOneWidget); // uppercased first letter
+    });
+
+    testWidgets('falls back to a glyph when the name is unknown', (
+      tester,
+    ) async {
+      await tester.pumpWidget(host(const PeerAvatar(pubkey: 'aa')));
+      expect(find.byIcon(Icons.person_outline), findsOneWidget);
+      expect(find.byType(Text), findsNothing);
+    });
+  });
+}

apps/app_seeds/test/ui/unread_badge_test.dart

@@ -16,7 +16,7 @@ void main() {
   late UnreadService unread;
 
   setUp(() {
-    store = MessageStore(InMemorySecretStore());
+    store = MessageStore(newTestChatDatabase());
     unread = UnreadService(store, InMemorySecretStore());
   });