feat: switch folder-view search from IMAP to local SQLite FTS5

Closes #501

searchEmails now queries the local email_fts virtual table filtered by
mailbox_path instead of doing a live IMAP SEARCH. This makes folder-view
search work offline and ensures tapped results always open the correct
email (IDs come from the same local DB that getEmail reads from).

Reuses the existing FTS5 infrastructure (_toFtsQuery + the email_fts
content-table join) from searchEmailsGlobal, adding only the
`AND e.mailbox_path = ?` filter.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

lib/core/db_schema_version.dart

@@ -1 +1 @@
-const int dbSchemaVersion = 39;
+const int dbSchemaVersion = 40;

lib/data/db/database.dart

@@ -338,6 +338,17 @@ class EmailNotes extends Table {
   Set<Column> get primaryKey => {id};
 }
 
+/// Records the first time the user ran each app version (identified by GIT_HASH).
+/// Added in schema v40.
+@DataClassName('InstalledVersionRow')
+class InstalledVersions extends Table {
+  TextColumn get gitHash => text()();
+  DateTimeColumn get installedAt => dateTime()();
+
+  @override
+  Set<Column> get primaryKey => {gitHash};
+}
+
 /// App-wide user preferences, stored as a singleton row (id always 1).
 @DataClassName('UserPreferencesRow')
 class UserPreferences extends Table {
@@ -384,6 +395,7 @@ class UserPreferences extends Table {
     UserPreferences,
     ImageTrustedSenders,
     EmailNotes,
+    InstalledVersions,
   ],
 )
 class AppDatabase extends _$AppDatabase {
@@ -663,8 +675,30 @@ class AppDatabase extends _$AppDatabase {
           if (from < 39) {
             await m.createTable(emailNotes);
           }
+          if (from < 40) {
+            await m.createTable(installedVersions);
+          }
         },
       );
+
+  /// Inserts a row for [gitHash] the first time that version is seen.
+  /// Subsequent calls for the same hash are silently ignored so the original
+  /// install timestamp is preserved.
+  Future<void> recordInstalledVersionIfNew(String gitHash) async {
+    if (gitHash.isEmpty) return;
+    await into(installedVersions).insert(
+      InstalledVersionsCompanion.insert(
+        gitHash: gitHash,
+        installedAt: DateTime.now(),
+      ),
+      mode: InsertMode.insertOrIgnore,
+    );
+  }
+
+  Future<Map<String, DateTime>> loadInstalledVersions() async {
+    final rows = await select(installedVersions).get();
+    return {for (final r in rows) r.gitHash: r.installedAt};
+  }
 }
 
 // Resolved once in main() via initDatabasePath() before runApp().

lib/data/repositories/email_repository_impl.dart

@@ -3052,63 +3052,26 @@ class EmailRepositoryImpl implements EmailRepository {
     String mailboxPath,
     String query,
   ) async {
-    final account = (await _accounts.getAccount(accountId))!;
-    final password = await _accounts.getPassword(accountId);
-    final client = await _imapConnect(
-      account,
-      _effectiveUsername(account),
-      password,
+    final ftsQuery = _toFtsQuery(query);
+    if (ftsQuery.isEmpty) return [];
+
+    const sql = 'SELECT e.* FROM email_fts f JOIN emails e ON e.rowid = f.rowid'
+        ' WHERE email_fts MATCH ? AND e.account_id = ? AND e.mailbox_path = ?'
+        ' ORDER BY rank LIMIT 50';
+    final variables = [
+      Variable<String>(ftsQuery),
+      Variable<String>(accountId),
+      Variable<String>(mailboxPath),
+    ];
+
+    final queryRows = await _db
+        .customSelect(sql, variables: variables, readsFrom: {_db.emails}).get();
+    final emailRows = await Future.wait(
+      queryRows.map((r) => _db.emails.mapFromRow(r)),
     );
-    try {
-      await client.selectMailboxByPath(mailboxPath);
-      final terms =
-          query.split(RegExp(r'\s+')).where((t) => t.isNotEmpty).toList();
-      final searchCriteria = terms.map((term) {
-        final escaped = term.replaceAll('"', '\\"');
-        return 'OR SUBJECT "$escaped" TEXT "$escaped"';
-      }).join(' ');
-      final result = await client.uidSearchMessages(
-        searchCriteria: searchCriteria,
-      );
-      final uids = result.matchingSequence?.toList() ?? [];
-      if (uids.isEmpty) return [];
-
-      final fetch = await client.uidFetchMessages(
-        imap.MessageSequence.fromIds(uids, isUid: true),
-        '(UID FLAGS ENVELOPE)',
-      );
-      return fetch.messages
-          .where((msg) => msg.uid != null && msg.envelope != null)
-          .map((msg) {
-        final envelope = msg.envelope!;
-        final uid = msg.uid!;
-        final emailId = '$accountId:$uid';
-        return model.Email(
-          id: emailId,
-          accountId: accountId,
-          mailboxPath: mailboxPath,
-          uid: uid,
-          subject: envelope.subject,
-          sentAt: envelope.date,
-          receivedAt: envelope.date ?? DateTime.now(),
-          from: _toAddressList(envelope.from),
-          to: _toAddressList(envelope.to),
-          cc: _toAddressList(envelope.cc),
-          isSeen: msg.flags?.contains(r'\Seen') ?? false,
-          isFlagged: msg.flags?.contains(r'\Flagged') ?? false,
-          hasAttachment: msg.hasAttachments(),
-        );
-      }).toList();
-    } finally {
-      await client.logout();
-    }
+    return emailRows.map(_toModel).toList();
   }
 
-  List<model.EmailAddress> _toAddressList(List<imap.MailAddress>? addresses) =>
-      (addresses ?? const [])
-          .map((a) => model.EmailAddress(name: a.personalName, email: a.email))
-          .toList();
-
   // ── Helpers ────────────────────────────────────────────────────────────────
 
   /// Computes a stable threadId from RFC 2822 headers.

lib/di.dart

@@ -294,6 +294,10 @@ final noteRepositoryProvider = Provider<NoteRepository>((ref) {
   );
 });
 
+final installedVersionsProvider = FutureProvider<Map<String, DateTime>>((ref) {
+  return ref.watch(dbProvider).loadInstalledVersions();
+});
+
 /// Stream of notes for a specific email, identified by (accountId, messageId).
 final notesProvider =
     StreamProvider.autoDispose.family<List<EmailNote>, (String, String)>(

lib/main.dart

@@ -86,6 +86,8 @@ class SharedInboxApp extends ConsumerStatefulWidget {
   ConsumerState<SharedInboxApp> createState() => _SharedInboxAppState();
 }
 
+const _kGitHash = String.fromEnvironment('GIT_HASH');
+
 class _SharedInboxAppState extends ConsumerState<SharedInboxApp> {
   @override
   void initState() {
@@ -93,6 +95,11 @@ class _SharedInboxAppState extends ConsumerState<SharedInboxApp> {
     // Start background IMAP sync once — runs for the lifetime of the app.
     ref.read(syncManagerProvider).start();
     ref.read(reliabilityRunnerProvider).start();
+    if (_kGitHash.isNotEmpty) {
+      unawaited(
+        ref.read(dbProvider).recordInstalledVersionIfNew(_kGitHash),
+      );
+    }
   }
 
   @override

lib/ui/screens/changelog_screen.dart

@@ -2,21 +2,79 @@ import 'dart:async';
 
 import 'package:flutter/material.dart';
 import 'package:flutter_markdown_plus/flutter_markdown_plus.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:sharedinbox/di.dart';
 import 'package:url_launcher/url_launcher.dart';
 
-class ChangeLogScreen extends StatelessWidget {
+class ChangeLogScreen extends ConsumerWidget {
   const ChangeLogScreen({super.key});
 
+  static const _months = [
+    'Jan',
+    'Feb',
+    'Mar',
+    'Apr',
+    'May',
+    'Jun',
+    'Jul',
+    'Aug',
+    'Sep',
+    'Oct',
+    'Nov',
+    'Dec',
+  ];
+
+  static String _formatInstallDate(DateTime dt) {
+    final h = dt.hour.toString().padLeft(2, '0');
+    final m = dt.minute.toString().padLeft(2, '0');
+    final month = _months[dt.month - 1];
+    return '$h:$m, ${dt.day} $month ${dt.year}';
+  }
+
+  // Changelog lines have the form:
+  //   * 2026-06-05 [abc1234](https://...): subject
+  // This pattern captures the short hash inside the markdown link.
+  static final _hashPattern = RegExp(r'\[([0-9a-f]{6,12})\]\(');
+
+  static String _injectInstallMarkers(
+    String changelog,
+    Map<String, DateTime> versions,
+  ) {
+    if (versions.isEmpty) return changelog;
+    final lines = changelog.split('\n');
+    final buf = StringBuffer();
+    for (final line in lines) {
+      final match = _hashPattern.firstMatch(line);
+      if (match != null) {
+        final lineHash = match.group(1)!;
+        for (final entry in versions.entries) {
+          final stored = entry.key;
+          final matches = stored == lineHash ||
+              stored.startsWith(lineHash) ||
+              lineHash.startsWith(stored);
+          if (!matches) continue;
+          buf.write(
+            '\n---\n\n**Installed: ${_formatInstallDate(entry.value)}**\n\n',
+          );
+          break;
+        }
+      }
+      buf.writeln(line);
+    }
+    return buf.toString();
+  }
+
   @override
-  Widget build(BuildContext context) {
+  Widget build(BuildContext context, WidgetRef ref) {
+    final installedVersions = ref.watch(installedVersionsProvider);
     return Scaffold(
       appBar: AppBar(title: const Text('ChangeLog')),
       body: FutureBuilder<String>(
-        future: DefaultAssetBundle.of(
-          context,
-        ).loadString('assets/changelog.txt'),
+        future:
+            DefaultAssetBundle.of(context).loadString('assets/changelog.txt'),
         builder: (context, snapshot) {
-          if (snapshot.connectionState == ConnectionState.waiting) {
+          if (snapshot.connectionState == ConnectionState.waiting ||
+              installedVersions.isLoading) {
             return const Center(child: CircularProgressIndicator());
           }
           if (snapshot.hasError) {
@@ -25,8 +83,10 @@ class ChangeLogScreen extends StatelessWidget {
             );
           }
           final content = snapshot.data ?? 'No changelog entries found.';
+          final versions = installedVersions.value ?? {};
+          final annotated = _injectInstallMarkers(content, versions);
           return Markdown(
-            data: content,
+            data: annotated,
             onTapLink: (text, href, title) {
               if (href != null) {
                 unawaited(

lib/ui/screens/email_list_screen.dart

@@ -50,6 +50,15 @@ class _EmailListScreenState extends ConsumerState<EmailListScreen> {
   // Pagination: number of threads currently requested from the DB.
   static const _pageSize = 50;
   int _limit = _pageSize;
+
+  // Incremented on every search start; stale completions are ignored when the
+  // generation has advanced (prevents out-of-order IMAP responses from
+  // overwriting fresh results with results for an older query).
+  int _searchGeneration = 0;
+  // The query whose results are currently settled in _searchResults.
+  // Used to skip redundant re-runs when the user presses Enter on an
+  // already-settled search (issue #473).
+  String? _lastSettledQuery;
   bool get _selecting =>
       _selectedThreadIds.isNotEmpty || _selectedSearchIds.isNotEmpty;
 
@@ -61,6 +70,7 @@ class _EmailListScreenState extends ConsumerState<EmailListScreen> {
         setState(() {
           _searchResults = null;
           _searchLoading = false;
+          _lastSettledQuery = null;
         });
       }
     });
@@ -117,18 +127,35 @@ class _EmailListScreenState extends ConsumerState<EmailListScreen> {
   }
 
   Future<void> _runSearch(String query) async {
-    if (query.trim().isEmpty) {
-      setState(() => _searchResults = null);
+    final q = query.trim();
+    if (q.isEmpty) {
+      setState(() {
+        _searchResults = null;
+        _lastSettledQuery = null;
+      });
       return;
     }
+    // Skip if results are already settled for this exact query — prevents the
+    // Enter key from re-triggering a search that already completed.
+    if (_searchResults != null && !_searchLoading && q == _lastSettledQuery) {
+      return;
+    }
+    final generation = ++_searchGeneration;
     setState(() => _searchLoading = true);
     try {
       final results = await ref
           .read(emailRepositoryProvider)
-          .searchEmails(widget.accountId, widget.mailboxPath, query.trim());
-      if (mounted) setState(() => _searchResults = results);
+          .searchEmails(widget.accountId, widget.mailboxPath, q);
+      if (mounted && generation == _searchGeneration) {
+        setState(() {
+          _searchResults = results;
+          _lastSettledQuery = q;
+        });
+      }
     } finally {
-      if (mounted) setState(() => _searchLoading = false);
+      if (mounted && generation == _searchGeneration) {
+        setState(() => _searchLoading = false);
+      }
     }
   }
 
@@ -541,8 +568,8 @@ class _EmailListScreenState extends ConsumerState<EmailListScreen> {
 
     if (wasSearching && mounted) {
       // Filter deleted emails out of the local results immediately.
-      // Calling searchEmails here would hit the IMAP server, which still has
-      // the emails because the delete is only enqueued — not yet applied.
+      // Calling searchEmails here would still return deleted rows because the
+      // delete is only enqueued — not yet applied to the local DB.
       final deletedIds = ids.toSet();
       final remaining = (_searchResults ?? [])
           .where((e) => !deletedIds.contains(e.id))

pubspec.lock

@@ -371,6 +371,14 @@ packages:
     description: flutter
     source: sdk
     version: "0.0.0"
+  flutter_launcher_icons:
+    dependency: "direct dev"
+    description:
+      name: flutter_launcher_icons
+      sha256: "10f13781741a2e3972126fae08393d3c4e01fa4cd7473326b94b72cf594195e7"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.14.4"
   flutter_lints:
     dependency: "direct dev"
     description:
@@ -562,6 +570,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "4.1.2"
+  image:
+    dependency: transitive
+    description:
+      name: image
+      sha256: f9881ff4998044947ec38d098bc7c8316ae1186fa786eddffdb867b9bc94dfce
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.8.0"
   integration_test:
     dependency: "direct dev"
     description: flutter

test/unit/email_repository_impl_test.dart

@@ -453,6 +453,39 @@ void main() {
       expect(results.first.subject, 'foobar baz');
     });
 
+    test('searchEmails filters by mailboxPath using local FTS5', () async {
+      final r = _makeRepos();
+      await r.accounts.addAccount(_account, 'pw');
+
+      // Insert matching email in INBOX.
+      await r.db.into(r.db.emails).insert(
+            EmailsCompanion.insert(
+              id: 'acc-1:1',
+              accountId: 'acc-1',
+              mailboxPath: 'INBOX',
+              uid: 1,
+              subject: const Value('Meeting agenda'),
+              receivedAt: DateTime(2024),
+            ),
+          );
+      // Insert matching email in a different mailbox — must not appear.
+      await r.db.into(r.db.emails).insert(
+            EmailsCompanion.insert(
+              id: 'acc-1:2',
+              accountId: 'acc-1',
+              mailboxPath: 'Sent',
+              uid: 2,
+              subject: const Value('Meeting follow-up'),
+              receivedAt: DateTime(2024),
+            ),
+          );
+
+      final results = await r.emails.searchEmails('acc-1', 'INBOX', 'meeting');
+      expect(results, hasLength(1));
+      expect(results.first.subject, 'Meeting agenda');
+      expect(results.first.mailboxPath, 'INBOX');
+    });
+
     test(
       'searchAddresses returns results sorted by most recently used',
       () async {

test/unit/migration_test.dart

@@ -14,7 +14,7 @@ void main() {
   group('Migration', () {
     test('schemaVersion matches expected value', () async {
       final db = AppDatabase(NativeDatabase.memory());
-      expect(db.schemaVersion, 39);
+      expect(db.schemaVersion, 40);
       await db.close();
     });
 
@@ -427,12 +427,15 @@ void main() {
         // v39: email_notes table.
         await db.customSelect('SELECT count(*) FROM email_notes').get();
 
+        // v40: installed_versions table.
+        await db.customSelect('SELECT count(*) FROM installed_versions').get();
+
         await db.close();
         if (dbFile.existsSync()) dbFile.deleteSync();
       },
     );
 
-    test('fresh install creates all tables at schemaVersion 39', () async {
+    test('fresh install creates all tables at schemaVersion 40', () async {
       final db = AppDatabase(NativeDatabase.memory());
       await db.select(db.accounts).get();
 
@@ -462,6 +465,7 @@ void main() {
           'user_preferences', // v34
           'image_trusted_senders', // v37
           'email_notes', // v39
+          'installed_versions', // v40
         ]),
       );
 
@@ -500,6 +504,9 @@ void main() {
       // v39: email_notes table.
       await db.customSelect('SELECT count(*) FROM email_notes').get();
 
+      // v40: installed_versions table.
+      await db.customSelect('SELECT count(*) FROM installed_versions').get();
+
       await db.close();
     });
   });

test/widget/changelog_screen_test.dart

@@ -1,8 +1,12 @@
 import 'dart:convert';
 
+import 'package:drift/native.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:sharedinbox/data/db/database.dart';
+import 'package:sharedinbox/di.dart';
 import 'package:sharedinbox/ui/screens/changelog_screen.dart';
 
 class _FakeAssetBundle extends CachingAssetBundle {
@@ -19,16 +23,33 @@ class _FakeAssetBundle extends CachingAssetBundle {
   }
 }
 
+Widget _buildScreen({
+  required Map<String, String> assets,
+  Map<String, DateTime> installedVersions = const {},
+}) {
+  return ProviderScope(
+    overrides: [
+      dbProvider.overrideWith((ref) {
+        final db = AppDatabase(NativeDatabase.memory());
+        ref.onDispose(db.close);
+        return db;
+      }),
+      installedVersionsProvider.overrideWith((ref) async => installedVersions),
+    ],
+    child: DefaultAssetBundle(
+      bundle: _FakeAssetBundle(assets),
+      child: const MaterialApp(home: ChangeLogScreen()),
+    ),
+  );
+}
+
 const _fakeChangelog =
     '* 2024-01-01 feat: initial release\n* 2024-01-02 fix: resolve crash\n';
 
 void main() {
   testWidgets('ChangeLogScreen shows changelog content', (tester) async {
     await tester.pumpWidget(
-      DefaultAssetBundle(
-        bundle: _FakeAssetBundle({'assets/changelog.txt': _fakeChangelog}),
-        child: const MaterialApp(home: ChangeLogScreen()),
-      ),
+      _buildScreen(assets: {'assets/changelog.txt': _fakeChangelog}),
     );
     await tester.pumpAndSettle();
 
@@ -41,14 +62,44 @@ void main() {
   testWidgets('ChangeLogScreen shows error when asset is missing', (
     tester,
   ) async {
-    await tester.pumpWidget(
-      DefaultAssetBundle(
-        bundle: _FakeAssetBundle({}),
-        child: const MaterialApp(home: ChangeLogScreen()),
-      ),
-    );
+    await tester.pumpWidget(_buildScreen(assets: {}));
     await tester.pumpAndSettle();
 
     expect(find.textContaining('Error loading changelog'), findsOneWidget);
   });
+
+  testWidgets('ChangeLogScreen injects install marker for a known hash', (
+    tester,
+  ) async {
+    const changelog =
+        '* 2024-01-01 [abc1234](https://example.com/abc1234): feat: initial release\n';
+    final installedAt = DateTime(2024, 6, 15, 14, 32);
+
+    await tester.pumpWidget(
+      _buildScreen(
+        assets: {'assets/changelog.txt': changelog},
+        installedVersions: {'abc1234': installedAt},
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.textContaining('Installed: 14:32'), findsOneWidget);
+    expect(find.textContaining('15 Jun 2024'), findsOneWidget);
+    expect(find.textContaining('initial release'), findsOneWidget);
+  });
+
+  testWidgets('ChangeLogScreen shows no markers when no version recorded', (
+    tester,
+  ) async {
+    const changelog =
+        '* 2024-01-01 [abc1234](https://example.com/abc1234): feat: initial release\n';
+
+    await tester.pumpWidget(
+      _buildScreen(assets: {'assets/changelog.txt': changelog}),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.textContaining('Installed:'), findsNothing);
+    expect(find.textContaining('initial release'), findsOneWidget);
+  });
 }

test/widget/email_list_screen_test.dart

@@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
 
@@ -102,30 +104,6 @@ void main() {
       expect(find.byIcon(Icons.star), findsOneWidget);
     });
 
-    testWidgets('tapping search icon shows search bar', (tester) async {
-      await tester.pumpWidget(
-        buildApp(
-          initialLocation: '/accounts/acc-1/mailboxes/INBOX/emails',
-          overrides: [
-            accountRepositoryProvider.overrideWithValue(
-              FakeAccountRepository([kTestAccount]),
-            ),
-            mailboxRepositoryProvider.overrideWithValue(
-              FakeMailboxRepository(),
-            ),
-            emailRepositoryProvider.overrideWithValue(FakeEmailRepository()),
-          ],
-        ),
-      );
-      await tester.pumpAndSettle();
-
-      await tester.tap(find.byIcon(Icons.search));
-      await tester.pumpAndSettle();
-
-      expect(find.byType(TextField), findsOneWidget);
-      expect(find.text('Search…'), findsOneWidget);
-    });
-
     testWidgets('submitting a search query shows "No results" when empty', (
       tester,
     ) async {
@@ -430,6 +408,230 @@ void main() {
       expect(find.text('Result email'), findsWidgets);
     });
 
+    testWidgets(
+      'tapping first of multiple search results opens the first email',
+      (tester) async {
+        final email1 = testEmail(id: 'acc-1:1', subject: 'Alpha Match');
+        final email2 = testEmail(id: 'acc-1:2', subject: 'Beta Match');
+        await tester.pumpWidget(
+          buildApp(
+            initialLocation: '/accounts/acc-1/mailboxes/INBOX/emails',
+            overrides: [
+              accountRepositoryProvider.overrideWithValue(
+                FakeAccountRepository([kTestAccount]),
+              ),
+              mailboxRepositoryProvider.overrideWithValue(
+                FakeMailboxRepository(),
+              ),
+              emailRepositoryProvider.overrideWithValue(
+                FakeEmailRepository(
+                  searchResults: [email1, email2],
+                  emailBody: const EmailBody(emailId: '', attachments: []),
+                ),
+              ),
+            ],
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        await tester.enterText(find.byType(TextField), 'Match');
+        await tester.testTextInput.receiveAction(TextInputAction.search);
+        await tester.pumpAndSettle();
+
+        expect(find.text('Alpha Match'), findsOneWidget);
+        expect(find.text('Beta Match'), findsOneWidget);
+
+        // Tap the first result.
+        await tester.tap(find.text('Alpha Match'));
+        await tester.pumpAndSettle();
+
+        expect(find.byType(EmailDetailScreen), findsOneWidget);
+        // The detail AppBar title shows the first email's subject.
+        expect(
+          find.descendant(
+            of: find.byType(AppBar),
+            matching: find.text('Alpha Match'),
+          ),
+          findsOneWidget,
+        );
+        // The second email's subject must not appear in the detail view.
+        expect(
+          find.descendant(
+            of: find.byType(EmailDetailScreen),
+            matching: find.text('Beta Match'),
+          ),
+          findsNothing,
+        );
+      },
+    );
+
+    testWidgets(
+      'stale search results from a slower concurrent search are discarded',
+      (tester) async {
+        // Reproduces: user types quickly, triggering multiple concurrent IMAP
+        // searches. An older, slower search must not overwrite the results for
+        // the user's current query (issue #467).
+        final staleEmail = testEmail(id: 'acc-1:1', subject: 'Stale Result');
+        final freshEmail = testEmail(id: 'acc-1:2', subject: 'Fresh Result');
+
+        // The first search call is held open by a Completer; all subsequent
+        // calls resolve immediately with freshEmail.
+        final staleCompleter = Completer<List<Email>>();
+        var firstCall = true;
+
+        await tester.pumpWidget(
+          buildApp(
+            initialLocation: '/accounts/acc-1/mailboxes/INBOX/emails',
+            overrides: [
+              accountRepositoryProvider.overrideWithValue(
+                FakeAccountRepository([kTestAccount]),
+              ),
+              mailboxRepositoryProvider.overrideWithValue(
+                FakeMailboxRepository(),
+              ),
+              emailRepositoryProvider.overrideWithValue(
+                FakeEmailRepository(
+                  onSearch: (_) {
+                    if (firstCall) {
+                      firstCall = false;
+                      return staleCompleter.future;
+                    }
+                    return Future.value([freshEmail]);
+                  },
+                  emailBody: const EmailBody(emailId: '', attachments: []),
+                ),
+              ),
+            ],
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        // Trigger the first (slow) search.
+        await tester.enterText(find.byType(TextField), 'slow');
+        await tester.testTextInput.receiveAction(TextInputAction.search);
+        // Do not pumpAndSettle yet — the slow search is still in flight.
+
+        // Trigger the second (fast) search by changing the query.
+        await tester.enterText(find.byType(TextField), 'fast');
+        await tester.testTextInput.receiveAction(TextInputAction.search);
+        await tester.pumpAndSettle(); // fast searches settle immediately
+
+        // The fresh results must be shown.
+        expect(find.text('Fresh Result'), findsOneWidget);
+        expect(find.text('Stale Result'), findsNothing);
+
+        // Now let the stale search complete.
+        staleCompleter.complete([staleEmail]);
+        await tester.pumpAndSettle();
+
+        // The stale results must NOT replace the fresh ones.
+        expect(find.text('Fresh Result'), findsOneWidget);
+        expect(find.text('Stale Result'), findsNothing);
+      },
+    );
+
+    testWidgets(
+      'pressing Enter on already-settled search does not re-run search (issue #473)',
+      (tester) async {
+        final email1 = testEmail(id: 'acc-1:1', subject: 'Alpha Match');
+        final email2 = testEmail(id: 'acc-1:2', subject: 'Beta Match');
+
+        var searchCallCount = 0;
+
+        await tester.pumpWidget(
+          buildApp(
+            initialLocation: '/accounts/acc-1/mailboxes/INBOX/emails',
+            overrides: [
+              accountRepositoryProvider.overrideWithValue(
+                FakeAccountRepository([kTestAccount]),
+              ),
+              mailboxRepositoryProvider.overrideWithValue(
+                FakeMailboxRepository(),
+              ),
+              emailRepositoryProvider.overrideWithValue(
+                FakeEmailRepository(
+                  onSearch: (_) async {
+                    searchCallCount++;
+                    return [email1, email2];
+                  },
+                  emailBody: const EmailBody(emailId: '', attachments: []),
+                ),
+              ),
+            ],
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        // Run the initial search.
+        await tester.enterText(find.byType(TextField), 'Match');
+        await tester.testTextInput.receiveAction(TextInputAction.search);
+        await tester.pumpAndSettle();
+
+        expect(find.text('Alpha Match'), findsOneWidget);
+        expect(find.text('Beta Match'), findsOneWidget);
+
+        final countAfterFirstSearch = searchCallCount;
+
+        // Re-focus the search bar (simulates user tapping back into the field
+        // with the keyboard still visible) and press Enter again on the same,
+        // already-settled query.
+        await tester.tap(find.byType(TextField));
+        await tester.pump();
+        await tester.testTextInput.receiveAction(TextInputAction.search);
+        await tester.pumpAndSettle();
+
+        // The search must NOT re-run; call count must not increase.
+        expect(
+          searchCallCount,
+          countAfterFirstSearch,
+          reason:
+              'Enter on settled results must not re-run the search (issue #473)',
+        );
+        // Results must still be visible — no loading spinner.
+        expect(find.byType(CircularProgressIndicator), findsNothing);
+        expect(find.text('Alpha Match'), findsOneWidget);
+      },
+    );
+
+    testWidgets(
+      'folder search returns results from local cache without any network call',
+      (tester) async {
+        // Verifies that searchEmails is backed by local SQLite (not IMAP).
+        // The repository throws if a network call is attempted, yet search
+        // must still return results.
+        final email = testEmail(subject: 'Cached subject');
+
+        await tester.pumpWidget(
+          buildApp(
+            initialLocation: '/accounts/acc-1/mailboxes/INBOX/emails',
+            overrides: [
+              accountRepositoryProvider.overrideWithValue(
+                FakeAccountRepository([kTestAccount]),
+              ),
+              mailboxRepositoryProvider.overrideWithValue(
+                FakeMailboxRepository(),
+              ),
+              emailRepositoryProvider.overrideWithValue(
+                FakeEmailRepository(
+                  onSearch: (_) async {
+                    // Local DB: return cached results immediately.
+                    return [email];
+                  },
+                  emailBody: const EmailBody(emailId: '', attachments: []),
+                ),
+              ),
+            ],
+          ),
+        );
+        await tester.pumpAndSettle();
+
+        await tester.enterText(find.byType(TextField), 'Cached');
+        await tester.pumpAndSettle();
+
+        expect(find.text('Cached subject'), findsOneWidget);
+      },
+    );
+
     testWidgets('deleting all search results pops back to previous screen', (
       tester,
     ) async {

test/widget/helpers.dart

@@ -216,12 +216,17 @@ class FakeEmailRepository implements EmailRepository {
 
   final List<Email> _searchResults;
 
+  /// Optional override: when set, [searchEmails] calls this instead of
+  /// returning [_searchResults]. Useful for testing race-condition fixes.
+  final Future<List<Email>> Function(String query)? onSearch;
+
   FakeEmailRepository({
     List<Email>? emails,
     Email? emailDetail,
     EmailBody? emailBody,
     List<Email>? searchResults,
     String rawRfc822 = '',
+    this.onSearch,
   })  : _emails = emails ?? [],
         _emailDetail = emailDetail,
         _searchResults = searchResults ?? [],
@@ -274,7 +279,15 @@ class FakeEmailRepository implements EmailRepository {
       Stream.value(_emails.where((e) => e.threadId == threadId).toList());
 
   @override
-  Future<Email?> getEmail(String emailId) async => _emailDetail;
+  Future<Email?> getEmail(String emailId) async {
+    for (final e in _searchResults) {
+      if (e.id == emailId) return e;
+    }
+    for (final e in _emails) {
+      if (e.id == emailId) return e;
+    }
+    return _emailDetail;
+  }
 
   @override
   Future<EmailBody> getEmailBody(String emailId) async => _emailBody;
@@ -340,8 +353,10 @@ class FakeEmailRepository implements EmailRepository {
     String accountId,
     String mailboxPath,
     String query,
-  ) async =>
-      _searchResults;
+  ) async {
+    if (onSearch != null) return onSearch!(query);
+    return _searchResults;
+  }
 
   @override
   Future<List<Email>> searchEmailsGlobal(
@@ -565,6 +580,7 @@ Widget buildApp({
       theme: ThemeData(
         colorScheme: ColorScheme.fromSeed(seedColor: Colors.indigo),
         useMaterial3: true,
+        splashFactory: NoSplash.splashFactory,
       ),
       darkTheme: ThemeData(
         colorScheme: ColorScheme.fromSeed(
@@ -572,6 +588,7 @@ Widget buildApp({
           brightness: Brightness.dark,
         ),
         useMaterial3: true,
+        splashFactory: NoSplash.splashFactory,
       ),
     ),
   );