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/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());
   });