fix: unauth vs. auth "home" feed

* add toggle for feed selector

* correct pull to refresh position

lib/src/features/composer/presentation/widgets/global_compose_fab.dart

···
 
     return FloatingActionButton.extended(
       onPressed: () => context.push(AppRoutes.compose),
-      icon: const Icon(Icons.edit_outlined),
-      label: const Text('Post'),
+      label: const Icon(Icons.edit_outlined),
       backgroundColor: theme.colorScheme.primary,
       foregroundColor: theme.colorScheme.onPrimary,
       elevation: 6,

lib/src/features/feeds/presentation/screens/feed_screen.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/pull_to_refresh_wrapper.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/feed_content_cleanup_controller.dart';
 import 'package:lazurite/src/features/feeds/application/feed_content_notifier.dart';
 import 'package:lazurite/src/features/feeds/application/feed_providers.dart';
···
 class _FeedScreenState extends ConsumerState<FeedScreen> {
   final ScrollController _scrollController = ScrollController();
   String? _lastRequestedFeed;
+  bool _isFeedSelectorExpanded = true;
 
   @override
   void initState() {
···
   Widget build(BuildContext context) {
     ref.watch(feedContentCleanupControllerProvider);
     final activeFeedUri = ref.watch(activeFeedProvider);
+    final authState = ref.watch(authProvider);
+    final isAuthenticated = authState is AuthStateAuthenticated;
+
+    // For authenticated users, wait for pinned feeds to load before showing content
+    // This prevents briefly showing the wrong feed during initialization
+    if (isAuthenticated) {
+      final pinnedFeedsAsync = ref.watch(pinnedFeedsProvider);
+      if (pinnedFeedsAsync.isLoading) {
+        return const Scaffold(body: LoadingView(key: ValueKey('pinned-feeds-loading')));
+      }
+    }
+
     final feedContentState = ref.watch(feedContentProvider(activeFeedUri));
     _ensureFeedLoaded(activeFeedUri);
 
···
                 physics: const AlwaysScrollableScrollPhysics(),
                 slivers: [
                   SliverAppBar(
-                    title: Text('Lazurite', style: Theme.of(context).textTheme.displaySmall),
+                    title: Row(
+                      mainAxisSize: MainAxisSize.min,
+                      children: [
+                        Text('Lazurite', style: Theme.of(context).textTheme.displaySmall),
+                        if (isAuthenticated)
+                          ScaleButton(
+                            child: IconButton(
+                              icon: Icon(
+                                _isFeedSelectorExpanded
+                                    ? Icons.keyboard_arrow_up
+                                    : Icons.keyboard_arrow_down,
+                                size: 20,
+                              ),
+                              onPressed: () {
+                                setState(() {
+                                  _isFeedSelectorExpanded = !_isFeedSelectorExpanded;
+                                });
+                              },
+                              tooltip: _isFeedSelectorExpanded ? 'Hide feeds' : 'Show feeds',
+                            ),
+                          ),
+                      ],
+                    ),
                     floating: true,
                     snap: true,
-                    bottom: const PreferredSize(
-                      preferredSize: Size.fromHeight(56),
-                      child: Padding(
-                        padding: EdgeInsets.only(bottom: 8.0),
-                        child: FeedSelectorTab(),
-                      ),
-                    ),
+                    bottom: isAuthenticated
+                        ? PreferredSize(
+                            preferredSize: Size.fromHeight(_isFeedSelectorExpanded ? 56 : 0),
+                            child: AnimatedSize(
+                              duration: const Duration(milliseconds: 200),
+                              curve: Curves.easeInOut,
+                              child: _isFeedSelectorExpanded
+                                  ? const Padding(
+                                      padding: EdgeInsets.only(bottom: 8.0),
+                                      child: FeedSelectorTab(),
+                                    )
+                                  : const SizedBox.shrink(),
+                            ),
+                          )
+                        : null,
                   ),
                   if (items.isEmpty)
                     const SliverFillRemaining(

lib/src/features/feeds/presentation/widgets/feed_selector_tab.dart

···
 
 /// Tab widget for selecting between pinned feeds.
 ///
-/// For authenticated users, shows their pinned feeds plus a "Manage Feeds" button.
-/// For unauthenticated users, shows only the "Discover" feed chip.
+/// For authenticated users, shows their pinned feeds with a persistent
+/// "Manage Feeds" button.
+/// For unauthenticated users, hides the feed selector entirely.
 class FeedSelectorTab extends ConsumerWidget {
   const FeedSelectorTab({super.key});
 
···
     final isAuthenticated = authState is AuthStateAuthenticated;
 
     if (!isAuthenticated) {
-      return _buildUnauthenticatedView(context, ref);
+      return _buildUnauthenticatedView();
     }
 
     return _buildAuthenticatedView(context, ref);
   }
 
   /// Builds the feed selector for unauthenticated users.
-  /// Shows only the "Discover" chip with no management options.
-  Widget _buildUnauthenticatedView(BuildContext context, WidgetRef ref) {
-    return SizedBox(
-      height: 48,
-      child: Padding(
-        padding: const EdgeInsets.symmetric(horizontal: 16),
-        child: Row(
-          children: [
-            FilterChip(
-              showCheckmark: false,
-              label: const Text('Discover'),
-              selected: true,
-              onSelected: (_) {},
-            ),
-          ],
-        ),
-      ),
-    );
+  /// Returns an empty widget since unauthenticated users don't need feed selection.
+  Widget _buildUnauthenticatedView() {
+    return const SizedBox.shrink();
   }
 
   /// Builds the feed selector for authenticated users.
-  /// Shows pinned feeds and a "Manage Feeds" button.
+  /// Shows pinned feeds with a persistent "Manage Feeds" button.
   Widget _buildAuthenticatedView(BuildContext context, WidgetRef ref) {
     final pinnedFeedsAsync = ref.watch(pinnedFeedsProvider);
     final activeFeedUri = ref.watch(activeFeedProvider);
···
 
         return SizedBox(
           height: 48,
-          child: ListView.separated(
-            padding: const EdgeInsets.symmetric(horizontal: 16),
-            scrollDirection: Axis.horizontal,
-            itemCount: displayFeeds.length + 1,
-            separatorBuilder: (context, index) => const SizedBox(width: 8),
-            itemBuilder: (context, index) {
-              if (index == displayFeeds.length) {
-                return Stack(
-                  alignment: Alignment.center,
-                  children: [
-                    Tooltip(
-                      message: 'Manage Feeds',
-                      child: ScaleButton(
-                        child: IconButton(
-                          icon: const Icon(Icons.tune),
-                          onPressed: () {
-                            context.push(AppRoutes.feeds);
-                          },
-                        ),
-                      ),
-                    ),
-                    Consumer(
-                      builder: (context, ref, child) {
-                        final hasPending =
-                            ref.watch(hasPendingSyncProvider).asData?.value ?? false;
-                        if (hasPending) {
-                          return Positioned(
-                            right: 8,
-                            top: 8,
-                            child: Container(
-                              width: 8,
-                              height: 8,
-                              decoration: const BoxDecoration(
-                                color: Colors.blue,
-                                shape: BoxShape.circle,
-                              ),
-                            ),
-                          );
+          child: Row(
+            children: [
+              // Scrollable feed chips
+              Expanded(
+                child: ListView.separated(
+                  padding: const EdgeInsets.only(left: 16),
+                  scrollDirection: Axis.horizontal,
+                  itemCount: displayFeeds.length,
+                  separatorBuilder: (context, index) => const SizedBox(width: 8),
+                  itemBuilder: (context, index) {
+                    final feed = displayFeeds[index];
+                    final isActive = feed.uri == activeFeedUri;
+
+                    return FilterChip(
+                      showCheckmark: false,
+                      label: Text(feed.displayName),
+                      avatar: feed.avatar != null
+                          ? CircleAvatar(backgroundImage: NetworkImage(feed.avatar!))
+                          : null,
+                      selected: isActive,
+                      onSelected: (selected) {
+                        if (selected) {
+                          ref.read(activeFeedProvider.notifier).switchFeed(feed.uri);
                         }
-                        return const SizedBox.shrink();
                       },
-                    ),
-                  ],
-                );
-              }
+                    );
+                  },
+                ),
+              ),
 
-              final feed = displayFeeds[index];
-              final isActive = feed.uri == activeFeedUri;
-
-              return FilterChip(
-                showCheckmark: false,
-                label: Text(feed.displayName),
-                avatar: feed.avatar != null
-                    ? CircleAvatar(backgroundImage: NetworkImage(feed.avatar!))
-                    : null,
-                selected: isActive,
-                onSelected: (selected) {
-                  if (selected) {
-                    ref.read(activeFeedProvider.notifier).switchFeed(feed.uri);
-                  }
-                },
-              );
-            },
+              // Persistent manage feeds button
+              Stack(
+                alignment: Alignment.center,
+                children: [
+                  Tooltip(
+                    message: 'Manage Feeds',
+                    child: ScaleButton(
+                      child: IconButton(
+                        icon: const Icon(Icons.tune),
+                        onPressed: () {
+                          context.push(AppRoutes.feeds);
+                        },
+                      ),
+                    ),
+                  ),
+                  Consumer(
+                    builder: (context, ref, child) {
+                      final hasPending = ref.watch(hasPendingSyncProvider).asData?.value ?? false;
+                      if (hasPending) {
+                        return Positioned(
+                          right: 8,
+                          top: 8,
+                          child: Container(
+                            width: 8,
+                            height: 8,
+                            decoration: const BoxDecoration(
+                              color: Colors.blue,
+                              shape: BoxShape.circle,
+                            ),
+                          ),
+                        );
+                      }
+                      return const SizedBox.shrink();
+                    },
+                  ),
+                ],
+              ),
+              const SizedBox(width: 8),
+            ],
           ),
         );
       },

lib/src/features/profile/presentation/profile_screen.dart

···
               ],
             ),
           ),
-          body: NestedScrollView(
-            headerSliverBuilder: (context, innerBoxIsScrolled) {
-              return [
-                SliverToBoxAdapter(
-                  child: ProfileHeader(
-                    profile: profile,
-                    onFollowersPressed: () {
-                      final encodedDid = Uri.encodeComponent(profile.did);
-                      context.push('/profile/followers/$encodedDid');
-                    },
-                    onFollowingPressed: () {
-                      final encodedDid = Uri.encodeComponent(profile.did);
-                      context.push('/profile/following/$encodedDid');
-                    },
-                    followButton: widget.isCurrentUser ? null : _followButton(profile),
-                  ),
-                ),
-              ];
+          body: RefreshIndicator(
+            onRefresh: () async {
+              await ref.read(profileProvider(widget.did).notifier).refresh();
+              await ref.read(authorFeedProvider(widget.did).notifier).refresh();
             },
-            body: feedAsync.when(
-              data: (items) {
-                return TabBarView(
-                  controller: _tabController,
-                  children: [
-                    _PostsTab(
-                      items: items
-                          .where(
-                            (item) =>
-                                !item.isReply &&
-                                (profile.pinnedPostUri == null ||
-                                    item.uri != profile.pinnedPostUri),
-                          )
-                          .toList(),
-                      pinnedPostUri: profile.pinnedPostUri,
-                      hasMore: hasMore,
-                      isLoading: false,
-                      onLoadMore: () =>
-                          ref.read(authorFeedProvider(widget.did).notifier).loadMore(),
-                      onRefresh: () async {
-                        await ref.read(profileProvider(widget.did).notifier).refresh();
-                        await ref.read(authorFeedProvider(widget.did).notifier).refresh();
-                      },
-                    ),
-                    RepliesTab(
-                      items: items,
-                      hasMore: hasMore,
-                      isLoading: false,
-                      onLoadMore: () =>
-                          ref.read(authorFeedProvider(widget.did).notifier).loadMore(),
-                      onRefresh: () async {
-                        await ref.read(profileProvider(widget.did).notifier).refresh();
-                        await ref.read(authorFeedProvider(widget.did).notifier).refresh();
+            child: NestedScrollView(
+              headerSliverBuilder: (context, innerBoxIsScrolled) {
+                return [
+                  SliverToBoxAdapter(
+                    child: ProfileHeader(
+                      profile: profile,
+                      onFollowersPressed: () {
+                        final encodedDid = Uri.encodeComponent(profile.did);
+                        context.push('/profile/followers/$encodedDid');
                       },
-                    ),
-                    MediaTab(
-                      items: items,
-                      hasMore: hasMore,
-                      isLoading: false,
-                      onLoadMore: () =>
-                          ref.read(authorFeedProvider(widget.did).notifier).loadMore(),
-                      onRefresh: () async {
-                        await ref.read(profileProvider(widget.did).notifier).refresh();
-                        await ref.read(authorFeedProvider(widget.did).notifier).refresh();
+                      onFollowingPressed: () {
+                        final encodedDid = Uri.encodeComponent(profile.did);
+                        context.push('/profile/following/$encodedDid');
                       },
+                      followButton: widget.isCurrentUser ? null : _followButton(profile),
                     ),
-                  ],
-                );
+                  ),
+                ];
               },
-              loading: () => const LoadingView(),
-              error: (err, _) => Center(child: Text('Error loading posts: $err')),
+              body: feedAsync.when(
+                data: (items) {
+                  return TabBarView(
+                    controller: _tabController,
+                    children: [
+                      _PostsTab(
+                        items: items
+                            .where(
+                              (item) =>
+                                  !item.isReply &&
+                                  (profile.pinnedPostUri == null ||
+                                      item.uri != profile.pinnedPostUri),
+                            )
+                            .toList(),
+                        pinnedPostUri: profile.pinnedPostUri,
+                        hasMore: hasMore,
+                        isLoading: false,
+                        onLoadMore: () =>
+                            ref.read(authorFeedProvider(widget.did).notifier).loadMore(),
+                      ),
+                      RepliesTab(
+                        items: items,
+                        hasMore: hasMore,
+                        isLoading: false,
+                        onLoadMore: () =>
+                            ref.read(authorFeedProvider(widget.did).notifier).loadMore(),
+                      ),
+                      MediaTab(
+                        items: items,
+                        hasMore: hasMore,
+                        isLoading: false,
+                        onLoadMore: () =>
+                            ref.read(authorFeedProvider(widget.did).notifier).loadMore(),
+                      ),
+                    ],
+                  );
+                },
+                loading: () => const LoadingView(),
+                error: (err, _) => Center(child: Text('Error loading posts: $err')),
+              ),
             ),
           ),
         );
···
     required this.hasMore,
     required this.isLoading,
     required this.onLoadMore,
-    required this.onRefresh,
   });
 
   final List<FeedItem> items;
···
   final bool hasMore;
   final bool isLoading;
   final VoidCallback onLoadMore;
-  final Future<void> Function() onRefresh;
 
   @override
   State<_PostsTab> createState() => _PostsTabState();
···
       return const Center(child: Text('No posts yet'));
     }
 
-    return RefreshIndicator(
-      onRefresh: widget.onRefresh,
-      child: ListView.builder(
-        physics: const AlwaysScrollableScrollPhysics(),
-        itemCount:
-            widget.items.length +
-            (widget.hasMore ? 1 : 0) +
-            (widget.pinnedPostUri != null ? 1 : 0),
-        itemBuilder: (context, index) {
-          int itemIndex = index;
+    return ListView.builder(
+      physics: const AlwaysScrollableScrollPhysics(),
+      itemCount:
+          widget.items.length + (widget.hasMore ? 1 : 0) + (widget.pinnedPostUri != null ? 1 : 0),
+      itemBuilder: (context, index) {
+        int itemIndex = index;
 
-          if (widget.pinnedPostUri != null) {
-            if (index == 0) {
-              return PinnedPostCard(widget.pinnedPostUri!);
-            }
-            itemIndex--;
+        if (widget.pinnedPostUri != null) {
+          if (index == 0) {
+            return PinnedPostCard(widget.pinnedPostUri!);
           }
+          itemIndex--;
+        }
 
-          if (itemIndex >= widget.items.length) {
-            widget.onLoadMore();
-            return const Padding(
-              padding: EdgeInsets.all(16),
-              child: Center(child: CircularProgressIndicator()),
-            );
-          }
+        if (itemIndex >= widget.items.length) {
+          widget.onLoadMore();
+          return const Padding(
+            padding: EdgeInsets.all(16),
+            child: Center(child: CircularProgressIndicator()),
+          );
+        }
 
-          final item = widget.items[itemIndex];
-          return FeedPostCard(
-            uri: item.uri,
-            authorDid: item.authorDid,
-            authorHandle: item.authorHandle,
-            authorDisplayName: item.authorDisplayName,
-            authorAvatar: item.authorAvatar,
-            text: item.text,
-            indexedAt: item.indexedAt,
-            replyCount: item.replyCount,
-            repostCount: item.repostCount,
-            likeCount: item.likeCount,
-            onTap: () {
-              final encodedUri = Uri.encodeComponent(item.uri);
-              GoRouter.of(context).push('/home/t/$encodedUri');
-            },
-            onAvatarTap: () {
-              final encodedDid = Uri.encodeComponent(item.authorDid);
-              GoRouter.of(context).push('/home/u/$encodedDid');
-            },
-          );
-        },
-      ),
+        final item = widget.items[itemIndex];
+        return FeedPostCard(
+          uri: item.uri,
+          authorDid: item.authorDid,
+          authorHandle: item.authorHandle,
+          authorDisplayName: item.authorDisplayName,
+          authorAvatar: item.authorAvatar,
+          text: item.text,
+          indexedAt: item.indexedAt,
+          replyCount: item.replyCount,
+          repostCount: item.repostCount,
+          likeCount: item.likeCount,
+          onTap: () {
+            final encodedUri = Uri.encodeComponent(item.uri);
+            GoRouter.of(context).push('/home/t/$encodedUri');
+          },
+          onAvatarTap: () {
+            final encodedDid = Uri.encodeComponent(item.authorDid);
+            GoRouter.of(context).push('/home/u/$encodedDid');
+          },
+        );
+      },
     );
   }
 }

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

···
     required this.hasMore,
     required this.isLoading,
     required this.onLoadMore,
-    required this.onRefresh,
     super.key,
   });
 
···
   final bool hasMore;
   final bool isLoading;
   final VoidCallback onLoadMore;
-  final Future<void> Function() onRefresh;
 
   @override
   State<MediaTab> createState() => _MediaTabState();
···
       return const Center(child: Text('No media posts yet'));
     }
 
-    return RefreshIndicator(
-      onRefresh: widget.onRefresh,
-      child: ListView.builder(
-        controller: _scrollController,
-        physics: const AlwaysScrollableScrollPhysics(),
-        itemCount: mediaItems.length + (widget.hasMore ? 1 : 0),
-        itemBuilder: (context, index) {
-          if (index >= mediaItems.length) {
-            return const Padding(
-              padding: EdgeInsets.all(16),
-              child: Center(child: CircularProgressIndicator()),
-            );
-          }
+    return ListView.builder(
+      controller: _scrollController,
+      physics: const AlwaysScrollableScrollPhysics(),
+      itemCount: mediaItems.length + (widget.hasMore ? 1 : 0),
+      itemBuilder: (context, index) {
+        if (index >= mediaItems.length) {
+          return const Padding(
+            padding: EdgeInsets.all(16),
+            child: Center(child: CircularProgressIndicator()),
+          );
+        }
 
-          final item = mediaItems[index];
-          return FeedPostCard(
-            uri: item.uri,
-            authorDid: item.authorDid,
-            authorHandle: item.authorHandle,
-            authorDisplayName: item.authorDisplayName,
-            authorAvatar: item.authorAvatar,
-            text: item.text,
-            indexedAt: item.indexedAt,
-            replyCount: item.replyCount,
-            repostCount: item.repostCount,
-            likeCount: item.likeCount,
-            onTap: () {
-              final encodedUri = Uri.encodeComponent(item.uri);
-              GoRouter.of(context).push('/home/t/$encodedUri');
-            },
-            onAvatarTap: () {
-              final encodedDid = Uri.encodeComponent(item.authorDid);
-              GoRouter.of(context).push('/home/u/$encodedDid');
-            },
-          );
-        },
-      ),
+        final item = mediaItems[index];
+        return FeedPostCard(
+          uri: item.uri,
+          authorDid: item.authorDid,
+          authorHandle: item.authorHandle,
+          authorDisplayName: item.authorDisplayName,
+          authorAvatar: item.authorAvatar,
+          text: item.text,
+          indexedAt: item.indexedAt,
+          replyCount: item.replyCount,
+          repostCount: item.repostCount,
+          likeCount: item.likeCount,
+          onTap: () {
+            final encodedUri = Uri.encodeComponent(item.uri);
+            GoRouter.of(context).push('/home/t/$encodedUri');
+          },
+          onAvatarTap: () {
+            final encodedDid = Uri.encodeComponent(item.authorDid);
+            GoRouter.of(context).push('/home/u/$encodedDid');
+          },
+        );
+      },
     );
   }
 }

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

···
     required this.hasMore,
     required this.isLoading,
     required this.onLoadMore,
-    required this.onRefresh,
     super.key,
   });
 
···
   final bool hasMore;
   final bool isLoading;
   final VoidCallback onLoadMore;
-  final Future<void> Function() onRefresh;
 
   @override
   State<RepliesTab> createState() => _RepliesTabState();
···
       return const Center(child: Text('No replies yet'));
     }
 
-    return RefreshIndicator(
-      onRefresh: widget.onRefresh,
-      child: ListView.builder(
-        controller: _scrollController,
-        physics: const AlwaysScrollableScrollPhysics(),
-        itemCount: replies.length + (widget.hasMore ? 1 : 0),
-        itemBuilder: (context, index) {
-          if (index >= replies.length) {
-            return const Padding(
-              padding: EdgeInsets.all(16),
-              child: Center(child: CircularProgressIndicator()),
-            );
-          }
+    return ListView.builder(
+      controller: _scrollController,
+      physics: const AlwaysScrollableScrollPhysics(),
+      itemCount: replies.length + (widget.hasMore ? 1 : 0),
+      itemBuilder: (context, index) {
+        if (index >= replies.length) {
+          return const Padding(
+            padding: EdgeInsets.all(16),
+            child: Center(child: CircularProgressIndicator()),
+          );
+        }
 
-          final item = replies[index];
-          return FeedPostCard(
-            uri: item.uri,
-            authorDid: item.authorDid,
-            authorHandle: item.authorHandle,
-            authorDisplayName: item.authorDisplayName,
-            authorAvatar: item.authorAvatar,
-            text: item.text,
-            indexedAt: item.indexedAt,
-            replyCount: item.replyCount,
-            repostCount: item.repostCount,
-            likeCount: item.likeCount,
-            onTap: () {
-              final encodedUri = Uri.encodeComponent(item.uri);
-              GoRouter.of(context).push('/home/t/$encodedUri');
-            },
-            onAvatarTap: () {
-              final encodedDid = Uri.encodeComponent(item.authorDid);
-              GoRouter.of(context).push('/home/u/$encodedDid');
-            },
-          );
-        },
-      ),
+        final item = replies[index];
+        return FeedPostCard(
+          uri: item.uri,
+          authorDid: item.authorDid,
+          authorHandle: item.authorHandle,
+          authorDisplayName: item.authorDisplayName,
+          authorAvatar: item.authorAvatar,
+          text: item.text,
+          indexedAt: item.indexedAt,
+          replyCount: item.replyCount,
+          repostCount: item.repostCount,
+          likeCount: item.likeCount,
+          onTap: () {
+            final encodedUri = Uri.encodeComponent(item.uri);
+            GoRouter.of(context).push('/home/t/$encodedUri');
+          },
+          onAvatarTap: () {
+            final encodedDid = Uri.encodeComponent(item.authorDid);
+            GoRouter.of(context).push('/home/u/$encodedDid');
+          },
+        );
+      },
     );
   }
 }

lib/src/infrastructure/network/endpoint_registry.dart

···
     'app.bsky.feed.getFeed': const EndpointMeta(
       nsid: 'app.bsky.feed.getFeed',
       method: HttpMethod.get,
-      hostKind: HostKind.pds,
-      requiresAuth: true,
+      hostKind: HostKind.publicApi,
+      requiresAuth: false,
     ),
     'app.bsky.feed.getFeedGenerator': const EndpointMeta(
       nsid: 'app.bsky.feed.getFeedGenerator',

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

···
   @override
   Future<void> onRequest(RequestOptions options, RequestInterceptorHandler handler) async {
     final requiresAuth = options.extra[requiresAuthKey] == true;
-
-    if (requiresAuth) {
-      var session = await getSession();
+    var session = await getSession();
 
-      if (session != null && session.isNearExpiration && !session.isExpired) {
-        _logger.debug('Token near expiration, proactively refreshing');
-        final refreshed = await _performRefresh();
-        if (refreshed != null) {
-          session = refreshed;
-        } else {
-          _logger.warning('Proactive refresh failed, continuing with existing token');
-        }
+    // Proactively refresh if token is near expiration
+    if (session != null && session.isNearExpiration && !session.isExpired) {
+      _logger.debug('Token near expiration, proactively refreshing');
+      final refreshed = await _performRefresh();
+      if (refreshed != null) {
+        session = refreshed;
+      } else {
+        _logger.warning('Proactive refresh failed, continuing with existing token');
       }
+    }
 
-      if (session != null) {
-        final token = session.accessJwt;
-        options.headers['Authorization'] = 'DPoP $token';
+    // Attach auth headers if session is available
+    // (required for requiresAuth endpoints, optional otherwise)
+    if (session != null) {
+      final token = session.accessJwt;
+      options.headers['Authorization'] = 'DPoP $token';
 
-        try {
-          final dpopKey = JsonWebKey.fromJson(session.dpopKey);
-          final url = options.uri.toString();
-          final method = options.method;
-          final nonce = _nonceStore.get(session.pdsUrl);
+      try {
+        final dpopKey = JsonWebKey.fromJson(session.dpopKey);
+        final url = options.uri.toString();
+        final method = options.method;
+        final nonce = _nonceStore.get(session.pdsUrl);
 
-          final proof = await DPoPUtils.createProof(
-            url: url,
-            method: method,
-            privateKey: dpopKey,
-            accessToken: token,
-            nonce: nonce,
-          );
+        final proof = await DPoPUtils.createProof(
+          url: url,
+          method: method,
+          privateKey: dpopKey,
+          accessToken: token,
+          nonce: nonce,
+        );
 
-          options.headers['DPoP'] = proof;
-        } catch (e) {
-          _logger.warning('Failed to create DPoP proof for request', e);
-        }
+        options.headers['DPoP'] = proof;
+      } catch (e) {
+        _logger.warning('Failed to create DPoP proof for request', e);
       }
+    } else if (requiresAuth) {
+      // Fail early if auth is required but no session exists
+      _logger.warning('Request requires auth but no session available');
     }
 
     handler.next(options);

test/src/features/profile/presentation/widgets/media_tab_test.dart

···
           hasMore: hasMore,
           isLoading: isLoading,
           onLoadMore: () {},
-          onRefresh: () async {},
         ),
       ),
     );

test/src/features/profile/presentation/widgets/replies_tab_test.dart

···
           hasMore: hasMore,
           isLoading: isLoading,
           onLoadMore: () {},
-          onRefresh: () async {},
         ),
       ),
     );

test/src/infrastructure/network/endpoint_registry_test.dart

···
     test('authenticated read endpoints use pds host', () {
       final authReads = [
         'app.bsky.feed.getTimeline',
-        'app.bsky.feed.getFeed',
         'app.bsky.feed.searchPosts',
         'app.bsky.notification.listNotifications',
         'app.bsky.actor.getPreferences',

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

···
         expect(response.statusCode, equals(200));
       });
 
-      test('does not attach token for non-authenticated requests', () async {
+      test('attaches token even for non-requiresAuth requests if session available', () async {
         final dio = Dio(BaseOptions(baseUrl: 'https://test.api'));
         final adapter = DioAdapter(dio: dio);
 
···
 
         final response = await dio.get('/public');
         expect(response.statusCode, equals(200));
-        expect(sessionRequested, isFalse);
+        expect(sessionRequested, isTrue);
       });
 
       test('handles null session gracefully', () async {
···
         expect(options.headers['Authorization'], isNull);
       });
 
-      test('skips auth when requiresAuth is false', () async {
+      test('attaches auth even when requiresAuth is false if session available', () async {
         final interceptor = AuthInterceptor(
           getSession: () async => _createTestSession(),
           refreshSession: () async => _createTestSession(accessJwt: 'refreshed'),
···
 
         await interceptor.onRequest(options, _NoOpRequestHandler());
 
-        expect(options.headers['Authorization'], isNull);
+        expect(options.headers['Authorization'], isNotNull);
+        expect(options.headers['Authorization'], startsWith('DPoP'));
       });
     });