feat: add pull to refresh for threads

* update feed syncing

justfile

···
 
 # Test with failures only to focus on failures and hanging tests
 test-quiet *paths='':
-    flutter test {{ paths }} --reporter=failures-only --timeout=120s
+    flutter test {{ paths }} --reporter=failures-only --fail-fast --timeout=120s
 
 # Run all tests
 test *paths='':
-    flutter test {{ paths }} --timeout=120s
+    flutter test {{ paths }} --fail-fast --timeout=120s
 
 # Run code gen
 gen:

lib/src/features/feeds/application/feed_sync_controller.dart

···
     } else {
       logger.debug('Not initialized yet, skipping auth change handling');
     }
-    unawaited(seedDefaults());
   });
 
   Future.microtask(() async {

lib/src/features/feeds/infrastructure/feed_repository.dart

···
       'Pinned URIs: ${pinnedStr.length > 500 ? pinnedStr.substring(0, 500) : pinnedStr}',
     );
 
-    final localFeeds = await _dao.getAllFeeds(ownerDid);
     final now = DateTime.now();
     final remoteSavedSet = remoteSavedUris.toSet();
     final feedsToInsert = <SavedFeedsCompanion>[];
···
     final feedsToSyncToRemote = <String>[];
 
     final newRemoteFeeds = <String>[];
+
     for (final uri in remoteSavedUris) {
-      if (uri.startsWith('at://') &&
-          !uri.contains('/app.bsky.graph.list/') &&
-          !localFeeds.any((f) => f.uri == uri)) {
+      if (uri.startsWith('at://') && !uri.contains('/app.bsky.graph.list/')) {
         newRemoteFeeds.add(uri);
       }
     }
···
     } else {
       _logger.debug('No new feeds need metadata fetching');
     }
+
+    final localFeeds = await _dao.getAllFeeds(ownerDid);
 
     for (var i = 0; i < remoteSavedUris.length; i++) {
       final remoteUri = remoteSavedUris[i];
···
               'isPinned': remoteIsPinned,
             });
           } else {
-            _logger.warning('Missing metadata for $remoteUri');
+            _logger.warning('Missing metadata for $remoteUri, inserting placeholder');
+            feedsToInsert.add(
+              SavedFeedsCompanion.insert(
+                uri: remoteUri,
+                ownerDid: ownerDid,
+                displayName: 'Unknown Feed',
+                description: const Value('Metadata unavailable'),
+                creatorDid: '',
+                likeCount: const Value(0),
+                sortOrder: i,
+                isPinned: Value(remoteIsPinned),
+                lastSynced: now,
+                localUpdatedAt: const Value(null),
+              ),
+            );
           }
         }
       } else if (local.localUpdatedAt == null ||
···
   ///
   /// For unauthenticated users (ownerDid="unauthenticated"), ensures Discover feed.
   /// For authenticated users, cleans up legacy/seed feeds that shouldn't be there.
+  ///
+  /// We only delete 'home' as it is an internal alias and never a valid remote URI.
+  /// We leave 'For You' and 'Discover' alone - syncPreferences will remove them
+  /// if they are not in the user's remote preferences.
   Future<void> seedDefaultFeeds(String ownerDid) async {
     _logger.debug('Seeding default feeds');
 
-    final migration = await _migrateDeprecatedFeed(ownerDid); // Pass ownerDid if needed
+    final migration = await _migrateDeprecatedFeed(ownerDid);
 
     if (_api.isAuthenticated) {
       await _dao.deleteFeed(kHomeFeedUri, ownerDid);
-      await _dao.deleteFeed(kForYouFeedUri, ownerDid);
-      await _dao.deleteFeed(kDiscoverFeedUri, ownerDid);
-      _logger.debug('Removed seeded feeds for authenticated user');
+      _logger.debug('Cleaned up legacy home feed alias for authenticated user');
       return;
     }
 

lib/src/features/feeds/presentation/screens/widgets/feed_post_card.dart

···
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:go_router/go_router.dart';
 import 'package:lazurite/src/core/domain/content_label.dart';
+import 'package:lazurite/src/core/utils/logger_provider.dart';
 import 'package:lazurite/src/features/auth/application/auth_providers.dart';
 import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:lazurite/src/features/feeds/application/post_interaction_providers.dart';
···
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final filterService = ref.watch(labelFilterServiceProvider);
+    final interactionAsync = ref.watch(postInteractionStateProvider(item.post.uri));
+    final interaction = interactionAsync.value;
+    final logger = ref.read(loggerProvider('[FeedPostCard|${item.post.uri}]'));
 
     Map<String, dynamic>? record;
     try {
···
       if (decoded is Map<String, dynamic>) {
         record = decoded;
       }
-    } catch (_) {
-      /* Invalid JSON, use empty record */
+    } catch (e) {
+      logger.warning('Failed to parse record ${item.post.record}: ${e.toString()}');
     }
+
     final text = record?['text'] as String? ?? '';
     final createdAt = DateTime.tryParse(item.post.indexedAt?.toIso8601String() ?? '');
 
···
         if (decoded is Map<String, dynamic>) {
           reasonJson = decoded;
         }
-      } catch (_) {
-        /* Invalid JSON, skip reason */
+      } catch (e) {
+        logger.warning('Failed to parse reason ${item.reason}: ${e.toString()}');
       }
     }
 
···
           replyCount: item.post.replyCount,
           repostCount: item.post.repostCount,
           likeCount: item.post.likeCount,
-          viewerLikeUri: item.interaction?.likeUri ?? item.post.viewerLikeUri,
-          viewerRepostUri: item.interaction?.repostUri ?? item.post.viewerRepostUri,
-          viewerBookmarked: item.interaction?.bookmarked ?? item.post.viewerBookmarked,
+          viewerLikeUri:
+              interaction?.likeUri ?? item.interaction?.likeUri ?? item.post.viewerLikeUri,
+          viewerRepostUri:
+              interaction?.repostUri ?? item.interaction?.repostUri ?? item.post.viewerRepostUri,
+          viewerBookmarked:
+              interaction?.bookmarked ??
+              item.interaction?.bookmarked ??
+              item.post.viewerBookmarked,
           onReply: () {
             final encodedUri = Uri.encodeComponent(item.post.uri);
             GoRouter.of(context).push('/compose?replyTo=$encodedUri');

lib/src/features/profile/domain/profile.dart

···
+import 'package:lazurite/src/core/utils/logger.dart';
+
 /// Domain model for profile data.
 class ProfileData {
   factory ProfileData.fromJson(Map<String, dynamic> json) {
···
 /// Represents a single feed item from author feed.
 class FeedItem {
   factory FeedItem.fromPostView(Map<String, dynamic> json) {
+    const logger = Logger('[FeedItem]');
+
+    logger.info('json: $json');
+
     final author = json['author'] as Map<String, dynamic>;
     final record = json['record'] as Map<String, dynamic>;
     final embed = json['embed'] as Map<String, dynamic>?;

lib/src/features/profile/presentation/widgets/pinned_post_card.dart

···
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:go_router/go_router.dart';
+import 'package:lazurite/src/core/utils/logger_provider.dart';
 import 'package:lazurite/src/features/auth/application/auth_providers.dart';
 import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:lazurite/src/features/feeds/application/post_interaction_providers.dart';
···
     final postAsync = ref.watch(pinnedPostProvider(postUri));
     final interaction = ref.watch(postInteractionStateProvider(postUri)).value;
 
+    final logger = ref.watch(loggerProvider('[PinnedPostCard]'));
+
     return postAsync.when(
       data: (item) {
+        logger.info('item: $item');
         if (item == null) return const SizedBox.shrink();
 
         final author = Profile(

lib/src/features/thread/infrastructure/thread_repository.dart

···
 import 'package:lazurite/src/core/utils/logger.dart';
 import 'package:lazurite/src/infrastructure/db/app_database.dart';
 import 'package:lazurite/src/infrastructure/db/daos/feed_content_dao.dart';
+import 'package:lazurite/src/infrastructure/network/network_failure.dart';
 import 'package:lazurite/src/infrastructure/network/xrpc_client.dart';
 
 import '../domain/thread.dart';
···
 
       return thread;
     } catch (e, stack) {
-      _logger.error('Failed to fetch thread', e, stack);
+      if (e is AuthFailure && e.message?.contains('nonce') == true) {
+        _logger.warning('Failed to fetch thread (recoverable auth error): ${e.message}');
+      } else {
+        _logger.error('Failed to fetch thread', e, stack);
+      }
       rethrow;
     }
   }

lib/src/features/thread/presentation/thread_screen.dart

···
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:lazurite/src/core/utils/error_message.dart';
-import 'package:lazurite/src/core/widgets/error_view.dart';
-import 'package:lazurite/src/core/widgets/loading_view.dart';
+import 'package:lazurite/src/core/widgets/widgets.dart';
 import 'package:lazurite/src/features/feeds/presentation/screens/widgets/feed_post_card.dart';
 import 'package:lazurite/src/features/settings/application/settings_providers.dart';
 import 'package:lazurite/src/features/settings/domain/bluesky_preferences.dart';
···
   Widget _buildTreeView(ThreadViewPost thread, ThreadViewPref pref) {
     final parents = thread.parent != null ? _getParents(thread.parent!) : <ThreadViewPost>[];
     final sortedReplies = _sortReplies(thread.replies, pref);
+    return PullToRefreshWrapper(
+      key: ValueKey(thread.post.uri),
+      onRefresh: () async {
+        await ref.read(threadProvider(widget.postUri).notifier).refresh();
+      },
+      child: CustomScrollView(
+        slivers: [
+          if (parents.isNotEmpty)
+            SliverList(
+              delegate: SliverChildBuilderDelegate((context, index) {
+                final parent = parents[index];
+                final position = _getThreadLinePosition(
+                  index: index,
+                  total: parents.length,
+                  isParentChain: true,
+                );
+                return _buildThreadPost(parent, position: position);
+              }, childCount: parents.length),
+            ),
 
-    return CustomScrollView(
-      slivers: [
-        if (parents.isNotEmpty)
+          SliverToBoxAdapter(child: _buildFocalPost(thread)),
+
           SliverList(
             delegate: SliverChildBuilderDelegate((context, index) {
-              final parent = parents[index];
-              final position = _getThreadLinePosition(
-                index: index,
-                total: parents.length,
-                isParentChain: true,
-              );
-              return _buildThreadPost(parent, position: position);
-            }, childCount: parents.length),
+              final reply = sortedReplies[index];
+              return _buildReplyTree(reply, depth: 1);
+            }, childCount: sortedReplies.length),
           ),
-
-        SliverToBoxAdapter(child: _buildFocalPost(thread)),
-
-        SliverList(
-          delegate: SliverChildBuilderDelegate((context, index) {
-            final reply = sortedReplies[index];
-            return _buildReplyTree(reply, depth: 1);
-          }, childCount: sortedReplies.length),
-        ),
-      ],
+        ],
+      ),
     );
   }
 

lib/src/infrastructure/db/daos/saved_feeds_dao.dart

···
   /// Used during sync merge operations to update sort order, pin status, and
   /// sync timestamps without requiring all fields. This only affects existing
   /// records - it will not insert a new record if the feed doesn't exist.
+  ///
+  /// We only apply sync updates if the user hasn't modified it locally since
+  /// the sync started (implied by localUpdatedAt being null).
+  ///
+  /// If clearLocalModification is true, we clear the localUpdatedAt timestamp
+  /// after successful remote sync.
   Future<int> updateSyncState({
     required String uri,
     required int sortOrder,
···
   }) {
     return (update(savedFeeds)
           ..where((t) => t.uri.equals(uri))
-          ..where((t) => t.ownerDid.equals(ownerDid)))
+          ..where((t) => t.ownerDid.equals(ownerDid))
+          ..where((t) => t.localUpdatedAt.isNull()))
         .write(
           SavedFeedsCompanion(
             sortOrder: Value(sortOrder),

lib/src/infrastructure/network/interceptors/auth_interceptor.dart

···
   Future<void> onError(DioException err, ErrorInterceptorHandler handler) async {
     final requiresAuth = err.requestOptions.extra[requiresAuthKey] == true;
 
-    final session = await getSession();
-    if (session != null && err.response != null) {
+    if (err.response != null) {
       final nonce = DPoPNonceStore.extractFromHeaders(err.response!.headers.map);
       if (nonce != null) {
         final origin = _getOrigin(err.requestOptions.uri);
···
       }
     }
 
+    final session = await getSession();
+
     if (requiresAuth) {
       if (await _tryRefreshAfterInvalidToken(err, handler)) {
         return;
···
     if (err.response?.statusCode != 401) {
       return handler.next(err);
     }
+
+    final errorCode = _extractErrorCode(err.response);
+    if (errorCode == 'use_dpop_nonce') {
+      final hasRetried = err.requestOptions.extra['_authRetried'] == true;
+      if (!hasRetried) {
+        if (session != null) {
+          final origin = _getOrigin(err.requestOptions.uri);
+          final nonce = _nonceStore.get(origin);
+
+          if (nonce != null) {
+            _logger.debug('Retrying request with new DPoP nonce');
+            return _retryRequestWithSession(err, session, handler);
+          } else {
+            _logger.warning('Received use_dpop_nonce but no nonce found in store');
+          }
+        }
+      }
+    }
+
     if (!requiresAuth) {
       return handler.next(err);
     }

lib/src/infrastructure/network/xrpc_client.dart

···
       return _parseResponse(response);
     } on DioException catch (e) {
       final failure = _convertError(e);
-      _logger.error('XRPC call failed: $nsid', failure, e.stackTrace);
+
+      if (failure is AuthFailure && failure.message?.contains('nonce') == true) {
+        _logger.warning('XRPC auth failure (recoverable): ${failure.message}');
+      } else {
+        _logger.error('XRPC call failed: $nsid', failure, e.stackTrace);
+      }
+
       throw failure;
     }
   }

test/src/features/feeds/infrastructure/feed_repository_query_test.dart

···
   });
 
   group('seedDefaultFeeds', () {
-    test('removes all seeded feeds for authenticated users', () async {
+    test('removes only legacy home alias for authenticated users', () async {
       when(() => mockApi.isAuthenticated).thenReturn(true);
 
       await db.savedFeedsDao.upsertFeeds([
···
       await repository.seedDefaultFeeds(ownerDid);
 
       final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
-      expect(feeds, isEmpty);
+      expect(feeds, hasLength(2));
+      expect(feeds.any((f) => f.uri == FeedRepository.kForYouFeedUri), isTrue);
+      expect(feeds.any((f) => f.uri == FeedRepository.kDiscoverFeedUri), isTrue);
+      expect(feeds.any((f) => f.uri == FeedRepository.kHomeFeedUri), isFalse);
     });
 
     test('seeds Discover feed for unauthenticated users', () async {

test/src/features/feeds/infrastructure/feed_repository_sync_test.dart

···
       await repository.syncPreferences(ownerDid);
 
       final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
-      expect(feeds, hasLength(1));
-      expect(feeds[0].displayName, 'Test Feed 2');
+      expect(feeds, hasLength(2));
+
+      expect(feeds[0].uri, 'at://did:plc:abc/app.bsky.feed.generator/test1');
+      expect(feeds[0].displayName, 'Unknown Feed');
+      expect(feeds[1].displayName, 'Test Feed 2');
     });
   });
 

test/src/features/feeds/infrastructure/feed_repository_test.dart

···
+import 'package:drift/drift.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lazurite/src/core/utils/logger.dart';
+import 'package:lazurite/src/features/feeds/infrastructure/feed_repository.dart';
+import 'package:lazurite/src/infrastructure/db/app_database.dart';
+import 'package:lazurite/src/infrastructure/db/daos/preference_sync_queue_dao.dart';
+import 'package:lazurite/src/infrastructure/db/daos/profile_dao.dart';
+import 'package:lazurite/src/infrastructure/db/daos/saved_feeds_dao.dart';
+import 'package:lazurite/src/infrastructure/network/xrpc_client.dart';
+import 'package:mocktail/mocktail.dart';
+
+class MockXrpcClient extends Mock implements XrpcClient {}
+
+class MockSavedFeedsDao extends Mock implements SavedFeedsDao {}
+
+class MockPreferenceSyncQueueDao extends Mock implements PreferenceSyncQueueDao {}
+
+class MockProfileDao extends Mock implements ProfileDao {}
+
+class MockLogger extends Mock implements Logger {}
+
+void main() {
+  late MockXrpcClient mockApi;
+  late MockSavedFeedsDao mockSavedFeedsDao;
+  late MockPreferenceSyncQueueDao mockSyncQueueDao;
+  late MockProfileDao mockProfileDao;
+  late MockLogger mockLogger;
+  late FeedRepository repository;
+
+  setUp(() {
+    mockApi = MockXrpcClient();
+    mockSavedFeedsDao = MockSavedFeedsDao();
+    mockSyncQueueDao = MockPreferenceSyncQueueDao();
+    mockProfileDao = MockProfileDao();
+    mockLogger = MockLogger();
+
+    repository = FeedRepository(
+      mockApi,
+      mockSavedFeedsDao,
+      mockSyncQueueDao,
+      mockProfileDao,
+      mockLogger,
+    );
+
+    registerFallbackValue(
+      SavedFeedsCompanion.insert(
+        uri: 'uri',
+        ownerDid: 'did',
+        displayName: 'name',
+        creatorDid: 'did',
+        sortOrder: 0,
+        lastSynced: DateTime.now(),
+      ),
+    );
+  });
+
+  group('FeedRepository', () {
+    test('syncPreferences inserts placeholder when metadata fetch fails', () async {
+      const ownerDid = 'did:web:test';
+      const feedUri = 'at://did:test/app.bsky.feed.generator/test';
+
+      when(() => mockApi.isAuthenticated).thenReturn(true);
+
+      when(() => mockApi.call('app.bsky.actor.getPreferences')).thenAnswer(
+        (_) async => {
+          'preferences': [
+            {
+              r'$type': 'app.bsky.actor.defs#savedFeedsPrefV2',
+              'items': [
+                {'type': 'feed', 'value': feedUri, 'pinned': true, 'id': '1'},
+              ],
+            },
+          ],
+        },
+      );
+
+      when(() => mockSavedFeedsDao.getAllFeeds(ownerDid)).thenAnswer((_) async => []);
+
+      when(
+        () => mockApi.call('app.bsky.feed.getFeedGenerators', params: any(named: 'params')),
+      ).thenThrow(Exception('Network error'));
+
+      when(() => mockSavedFeedsDao.upsertFeeds(any())).thenAnswer((_) async {});
+      when(
+        () => mockSavedFeedsDao.db,
+      ).thenThrow(UnimplementedError('DB access not expected unless transaction used'));
+
+      await repository.syncPreferences(ownerDid);
+
+      final captured = verify(() => mockSavedFeedsDao.upsertFeeds(captureAny())).captured;
+      final insertedFeeds = captured.first as List<SavedFeedsCompanion>;
+
+      expect(insertedFeeds.length, 1);
+      expect(insertedFeeds.first.uri.value, feedUri);
+      expect(insertedFeeds.first.displayName.value, 'Unknown Feed'); // This is the placeholder!
+      expect(insertedFeeds.first.description.value, 'Metadata unavailable');
+    });
+    test('seedDefaultFeeds only cleans up legacy home alias for authenticated users', () async {
+      const ownerDid = 'did:web:test';
+      when(() => mockApi.isAuthenticated).thenReturn(true);
+
+      when(() => mockSavedFeedsDao.getFeed(any(), any())).thenAnswer((_) async => null);
+      when(() => mockSavedFeedsDao.deleteFeed(any(), any())).thenAnswer((_) async => 1);
+      await repository.seedDefaultFeeds(ownerDid);
+
+      verify(() => mockSavedFeedsDao.deleteFeed(FeedRepository.kHomeFeedUri, ownerDid)).called(1);
+
+      verifyNever(() => mockSavedFeedsDao.deleteFeed(FeedRepository.kForYouFeedUri, ownerDid));
+      verifyNever(() => mockSavedFeedsDao.deleteFeed(FeedRepository.kDiscoverFeedUri, ownerDid));
+    });
+  });
+}

test/src/features/feeds/presentation/widgets/feed_preview_modal_test.dart

···
     expect(find.text('@creator'), findsOneWidget);
     expect(find.text('Author 2'), findsOneWidget);
     expect(find.text('Save'), findsOneWidget);
+
+    await tester.pumpWidget(const SizedBox());
+    await tester.pumpAndSettle();
   });
 
   testWidgets('Save button in FeedPreviewModal calls repository', (tester) async {

test/src/infrastructure/db/daos/saved_feeds_dao_test.dart

···
       expect(updated, 0);
     });
   });
+
+  group('updateSyncState', () {
+    test('updates sync state when localUpdatedAt is null', () async {
+      await dao.upsertFeed(
+        SavedFeedsCompanion.insert(
+          uri: 'at://did:plc:abc/app.bsky.feed.generator/test',
+          displayName: 'Test Feed',
+          creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
+          sortOrder: 0,
+          isPinned: const Value(false),
+          lastSynced: DateTime(2025, 1, 1),
+        ),
+      );
+
+      final updated = await dao.updateSyncState(
+        uri: 'at://did:plc:abc/app.bsky.feed.generator/test',
+        sortOrder: 5,
+        isPinned: true,
+        lastSynced: DateTime(2025, 1, 2),
+        ownerDid: ownerDid,
+      );
+
+      expect(updated, 1);
+
+      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test', ownerDid);
+      expect(result!.sortOrder, 5);
+      expect(result.isPinned, true);
+    });
+
+    test('ignores update when localUpdatedAt is set (race condition prevention)', () async {
+      await dao.upsertFeed(
+        SavedFeedsCompanion.insert(
+          uri: 'at://did:plc:abc/app.bsky.feed.generator/conflicted',
+          displayName: 'Conflicted Feed',
+          creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
+          sortOrder: 0,
+          isPinned: const Value(false),
+          lastSynced: DateTime(2025, 1, 1),
+          localUpdatedAt: Value(DateTime.now()), // SIMULATE LOCAL MODIFICATION
+        ),
+      );
+
+      final updated = await dao.updateSyncState(
+        uri: 'at://did:plc:abc/app.bsky.feed.generator/conflicted',
+        sortOrder: 5,
+        isPinned: true,
+        lastSynced: DateTime(2025, 1, 2),
+        ownerDid: ownerDid,
+        clearLocalModification: true,
+      );
+
+      expect(updated, 0, reason: 'Should not update rows where localUpdatedAt is not null');
+
+      final result = await dao.getFeed(
+        'at://did:plc:abc/app.bsky.feed.generator/conflicted',
+        ownerDid,
+      );
+
+      expect(result!.sortOrder, 0);
+      expect(result.isPinned, false);
+      expect(result.localUpdatedAt, isNotNull);
+    });
+
+    test('clears localUpdatedAt when flag is set and update succeeds', () async {
+      await dao.upsertFeed(
+        SavedFeedsCompanion.insert(
+          uri: 'at://did:plc:abc/app.bsky.feed.generator/sync_success',
+          displayName: 'Synced Feed',
+          creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
+          sortOrder: 0,
+          lastSynced: DateTime(2025, 1, 1),
+        ),
+      );
+
+      final initial = await dao.getFeed(
+        'at://did:plc:abc/app.bsky.feed.generator/sync_success',
+        ownerDid,
+      );
+      expect(initial!.localUpdatedAt, isNull);
+
+      final updated = await dao.updateSyncState(
+        uri: 'at://did:plc:abc/app.bsky.feed.generator/sync_success',
+        sortOrder: 1,
+        isPinned: true,
+        lastSynced: DateTime(2025, 1, 2),
+        ownerDid: ownerDid,
+        clearLocalModification: true,
+      );
+
+      expect(updated, 1);
+      final result = await dao.getFeed(
+        'at://did:plc:abc/app.bsky.feed.generator/sync_success',
+        ownerDid,
+      );
+      expect(result!.localUpdatedAt, isNull);
+    });
+  });
 }

test/src/infrastructure/network/interceptors/auth_interceptor_test.dart

···
     });
 
     group('401 retry behavior', () {
+      test('retries request immediately on use_dpop_nonce without refresh', () async {
+        final dio = Dio(BaseOptions(baseUrl: 'https://test.api'));
+        final adapter = DioAdapter(dio: dio);
+
+        var refreshCalled = false;
+
+        dio.interceptors.add(
+          AuthInterceptor(
+            getSession: () async => _createTestSession(),
+            refreshSession: () async {
+              refreshCalled = true;
+              return _createTestSession(accessJwt: 'new-token');
+            },
+          ),
+        );
+
+        adapter.onGet(
+          '/test',
+          (server) => server.reply(
+            401,
+            {'error': 'use_dpop_nonce'},
+            headers: {
+              'DPoP-Nonce': ['new-nonce-value'],
+            },
+          ),
+          headers: {
+            'Authorization': ['DPoP test-token'],
+          },
+        );
+
+        adapter.onGet(
+          '/test',
+          (server) => server.reply(200, {'success': true}),
+          headers: {'Authorization': 'DPoP test-token'},
+        );
+
+        final response = await dio.get(
+          '/test',
+          options: Options(extra: {AuthInterceptor.requiresAuthKey: true}),
+        );
+
+        expect(response.statusCode, equals(200));
+        expect(refreshCalled, isFalse);
+      });
+
       test('retries request with new token on 401', () async {
         final dio = Dio(BaseOptions(baseUrl: 'https://test.api'));
         final adapter = DioAdapter(dio: dio);
···
         adapter.onGet('/public', (server) => server.reply(400, {'error': 'InvalidToken'}));
 
         try {
-          await dio.get('/public'); // No requiresAuth flag
+          await dio.get('/public');
           fail('Should throw exception');
         } catch (e) {
           expect(e, isA<DioException>());