Merge branch 'feat/multi-feed-state'

Multi-feed state management with security hardening:

- FeedState model with sentinel copyWith pattern for nullable field clearing
- MultiFeedProvider with per-feed state and cross-session security guards
- FeedPage widget with pull-to-refresh on empty state
- FeedScreen auth sync and lazy feed loading
- Comprehensive tests for new architecture

Fixes:
- copyWith can now clear nullable fields (cursor, error, lastRefreshTime)
- Cross-session data leaks prevented via DID comparison
- Empty feed states are now refreshable
- PageController syncs with auth state on sign-out
- For You tab loads on first access after sign-in

lib/main.dart

···
 import 'constants/app_colors.dart';
 import 'models/post.dart';
 import 'providers/auth_provider.dart';
-import 'providers/feed_provider.dart';
+import 'providers/multi_feed_provider.dart';
 import 'providers/vote_provider.dart';
 import 'screens/auth/login_screen.dart';
 import 'screens/home/main_shell_screen.dart';
···
                 authProvider: authProvider,
               ),
         ),
-        ChangeNotifierProxyProvider2<AuthProvider, VoteProvider, FeedProvider>(
+        ChangeNotifierProxyProvider2<
+          AuthProvider,
+          VoteProvider,
+          MultiFeedProvider
+        >(
           create:
-              (context) => FeedProvider(
+              (context) => MultiFeedProvider(
                 authProvider,
                 voteProvider: context.read<VoteProvider>(),
               ),
           update: (context, auth, vote, previous) {
             // Reuse existing provider to maintain state across rebuilds
-            return previous ?? FeedProvider(auth, voteProvider: vote);
+            return previous ?? MultiFeedProvider(auth, voteProvider: vote);
           },
         ),
         // CommentsProviderCache manages per-post CommentsProvider instances
         // with LRU eviction and sign-out cleanup
         ProxyProvider2<AuthProvider, VoteProvider, CommentsProviderCache>(
-          create: (context) => CommentsProviderCache(
-            authProvider: authProvider,
-            voteProvider: context.read<VoteProvider>(),
-            commentService: commentService,
-          ),
+          create:
+              (context) => CommentsProviderCache(
+                authProvider: authProvider,
+                voteProvider: context.read<VoteProvider>(),
+                commentService: commentService,
+              ),
           update: (context, auth, vote, previous) {
             // Reuse existing cache
-            return previous ?? CommentsProviderCache(
-              authProvider: auth,
-              voteProvider: vote,
-              commentService: commentService,
-            );
+            return previous ??
+                CommentsProviderCache(
+                  authProvider: auth,
+                  voteProvider: vote,
+                  commentService: commentService,
+                );
           },
           dispose: (_, cache) => cache.dispose(),
         ),

lib/models/feed_state.dart

···
+import 'post.dart';
+
+/// Sentinel value for copyWith to distinguish "not provided" from "null"
+const _sentinel = Object();
+
+/// Per-feed state container
+///
+/// Holds all state for a single feed (Discover or For You) including posts,
+/// pagination, loading states, and scroll position.
+class FeedState {
+  const FeedState({
+    this.posts = const [],
+    this.cursor,
+    this.hasMore = true,
+    this.isLoading = false,
+    this.isLoadingMore = false,
+    this.error,
+    this.scrollPosition = 0.0,
+    this.lastRefreshTime,
+  });
+
+  /// Create a default empty state
+  factory FeedState.initial() {
+    return const FeedState();
+  }
+
+  /// Feed posts
+  final List<FeedViewPost> posts;
+
+  /// Pagination cursor for next page
+  final String? cursor;
+
+  /// Whether more pages are available
+  final bool hasMore;
+
+  /// Initial load in progress
+  final bool isLoading;
+
+  /// Pagination (load more) in progress
+  final bool isLoadingMore;
+
+  /// Error message if any
+  final String? error;
+
+  /// Cached scroll position for this feed
+  final double scrollPosition;
+
+  /// Last refresh timestamp for staleness checks
+  final DateTime? lastRefreshTime;
+
+  /// Create a copy with modified fields (immutable updates)
+  ///
+  /// Nullable fields (cursor, error, lastRefreshTime) use a sentinel pattern
+  /// to distinguish between "not provided" and "explicitly set to null".
+  /// Pass null explicitly to clear these fields.
+  FeedState copyWith({
+    List<FeedViewPost>? posts,
+    Object? cursor = _sentinel,
+    bool? hasMore,
+    bool? isLoading,
+    bool? isLoadingMore,
+    Object? error = _sentinel,
+    double? scrollPosition,
+    Object? lastRefreshTime = _sentinel,
+  }) {
+    return FeedState(
+      posts: posts ?? this.posts,
+      cursor: cursor == _sentinel ? this.cursor : cursor as String?,
+      hasMore: hasMore ?? this.hasMore,
+      isLoading: isLoading ?? this.isLoading,
+      isLoadingMore: isLoadingMore ?? this.isLoadingMore,
+      error: error == _sentinel ? this.error : error as String?,
+      scrollPosition: scrollPosition ?? this.scrollPosition,
+      lastRefreshTime:
+          lastRefreshTime == _sentinel
+              ? this.lastRefreshTime
+              : lastRefreshTime as DateTime?,
+    );
+  }
+}

lib/providers/feed_provider.dart

···
-import 'dart:async';
-
-import 'package:flutter/foundation.dart';
-import '../models/post.dart';
-import '../services/coves_api_service.dart';
-import 'auth_provider.dart';
-import 'vote_provider.dart';
-
-/// Feed types available in the app
-enum FeedType {
-  /// All posts across the network
-  discover,
-
-  /// Posts from subscribed communities (authenticated only)
-  forYou,
-}
-
-/// Feed Provider
-///
-/// Manages feed state and fetching logic.
-/// Supports both authenticated timeline and public discover feed.
-///
-/// IMPORTANT: Accepts AuthProvider reference to fetch fresh access
-/// tokens before each authenticated request (critical for atProto OAuth
-/// token rotation).
-class FeedProvider with ChangeNotifier {
-  FeedProvider(
-    this._authProvider, {
-    CovesApiService? apiService,
-    VoteProvider? voteProvider,
-  }) : _voteProvider = voteProvider {
-    // Use injected service (for testing) or create new one (for production)
-    // Pass token getter, refresh handler, and sign out handler to API service
-    // for automatic fresh token retrieval and automatic token refresh on 401
-    _apiService =
-        apiService ??
-        CovesApiService(
-          tokenGetter: _authProvider.getAccessToken,
-          tokenRefresher: _authProvider.refreshToken,
-          signOutHandler: _authProvider.signOut,
-        );
-
-    // Track initial auth state
-    _wasAuthenticated = _authProvider.isAuthenticated;
-
-    // [P0 FIX] Listen to auth state changes and clear feed on sign-out
-    // This prevents privacy bug where logged-out users see their private
-    // timeline until they manually refresh.
-    _authProvider.addListener(_onAuthChanged);
-  }
-
-  /// Handle authentication state changes
-  ///
-  /// Only clears and reloads feed when transitioning from authenticated
-  /// to unauthenticated (actual sign-out), not when staying unauthenticated
-  /// (e.g., failed sign-in attempt). This prevents unnecessary API calls.
-  void _onAuthChanged() {
-    final isAuthenticated = _authProvider.isAuthenticated;
-
-    // Only reload if transitioning from authenticated → unauthenticated
-    if (_wasAuthenticated && !isAuthenticated && _posts.isNotEmpty) {
-      if (kDebugMode) {
-        debugPrint('🔒 User signed out - clearing feed');
-      }
-      // Reset feed type to Discover since For You requires auth
-      _feedType = FeedType.discover;
-      reset();
-      // Automatically load the public discover feed
-      loadFeed(refresh: true);
-    }
-
-    // Update tracked state
-    _wasAuthenticated = isAuthenticated;
-  }
-
-  final AuthProvider _authProvider;
-  late final CovesApiService _apiService;
-  final VoteProvider? _voteProvider;
-
-  // Track previous auth state to detect transitions
-  bool _wasAuthenticated = false;
-
-  // Feed state
-  List<FeedViewPost> _posts = [];
-  bool _isLoading = false;
-  bool _isLoadingMore = false;
-  String? _error;
-  String? _cursor;
-  bool _hasMore = true;
-
-  // Feed configuration
-  String _sort = 'hot';
-  String? _timeframe;
-  FeedType _feedType = FeedType.discover;
-
-  // Time update mechanism for periodic UI refreshes
-  Timer? _timeUpdateTimer;
-  DateTime? _currentTime;
-
-  // Getters
-  List<FeedViewPost> get posts => _posts;
-  bool get isLoading => _isLoading;
-  bool get isLoadingMore => _isLoadingMore;
-  String? get error => _error;
-  bool get hasMore => _hasMore;
-  String get sort => _sort;
-  String? get timeframe => _timeframe;
-  DateTime? get currentTime => _currentTime;
-  FeedType get feedType => _feedType;
-
-  /// Check if For You feed is available (requires authentication)
-  bool get isForYouAvailable => _authProvider.isAuthenticated;
-
-  /// Start periodic time updates for "time ago" strings
-  ///
-  /// Updates currentTime every minute to trigger UI rebuilds for
-  /// post timestamps. This ensures "5m ago" updates to "6m ago" without
-  /// requiring user interaction.
-  void startTimeUpdates() {
-    // Cancel existing timer if any
-    _timeUpdateTimer?.cancel();
-
-    // Update current time immediately
-    _currentTime = DateTime.now();
-    notifyListeners();
-
-    // Set up periodic updates (every minute)
-    _timeUpdateTimer = Timer.periodic(const Duration(minutes: 1), (_) {
-      _currentTime = DateTime.now();
-      notifyListeners();
-    });
-
-    if (kDebugMode) {
-      debugPrint('⏰ Started periodic time updates for feed timestamps');
-    }
-  }
-
-  /// Stop periodic time updates
-  void stopTimeUpdates() {
-    _timeUpdateTimer?.cancel();
-    _timeUpdateTimer = null;
-    _currentTime = null;
-
-    if (kDebugMode) {
-      debugPrint('⏰ Stopped periodic time updates');
-    }
-  }
-
-  /// Load feed based on current feed type
-  ///
-  /// This method encapsulates the business logic of deciding which feed
-  /// to fetch based on the selected feed type.
-  Future<void> loadFeed({bool refresh = false}) async {
-    // For You requires authentication - fall back to Discover if not
-    if (_feedType == FeedType.forYou && _authProvider.isAuthenticated) {
-      await fetchTimeline(refresh: refresh);
-    } else {
-      await fetchDiscover(refresh: refresh);
-    }
-
-    // Start time updates when feed is loaded
-    if (_posts.isNotEmpty && _timeUpdateTimer == null) {
-      startTimeUpdates();
-    }
-  }
-
-  /// Switch feed type and reload
-  Future<void> setFeedType(FeedType type) async {
-    if (_feedType == type) {
-      return;
-    }
-
-    // For You requires authentication
-    if (type == FeedType.forYou && !_authProvider.isAuthenticated) {
-      return;
-    }
-
-    _feedType = type;
-    // Reset pagination state but keep posts visible until new feed loads
-    _cursor = null;
-    _hasMore = true;
-    _error = null;
-    notifyListeners();
-
-    // Load new feed - old posts stay visible until new ones arrive
-    await loadFeed(refresh: true);
-  }
-
-  /// Common feed fetching logic (DRY principle - eliminates code
-  /// duplication)
-  Future<void> _fetchFeed({
-    required bool refresh,
-    required Future<TimelineResponse> Function() fetcher,
-    required String feedName,
-  }) async {
-    if (_isLoading || _isLoadingMore) {
-      return;
-    }
-
-    try {
-      if (refresh) {
-        _isLoading = true;
-        // DON'T clear _posts, _cursor, or _hasMore yet
-        // Keep existing data visible until refresh succeeds
-        // This prevents transient failures from wiping the user's feed
-        // and pagination state
-        _error = null;
-      } else {
-        _isLoadingMore = true;
-      }
-      notifyListeners();
-
-      final response = await fetcher();
-
-      // Only update state after successful fetch
-      if (refresh) {
-        _posts = response.feed;
-      } else {
-        // Create new list instance to trigger context.select rebuilds
-        // Using spread operator instead of addAll to ensure reference changes
-        _posts = [..._posts, ...response.feed];
-      }
-
-      _cursor = response.cursor;
-      _hasMore = response.cursor != null;
-      _error = null;
-
-      if (kDebugMode) {
-        debugPrint('✅ $feedName loaded: ${_posts.length} posts total');
-      }
-
-      // Initialize vote state from viewer data in feed response
-      // IMPORTANT: Call setInitialVoteState for ALL feed items, even when
-      // viewer.vote is null. This ensures that if a user removed their vote
-      // on another device, the local state is cleared on refresh.
-      if (_authProvider.isAuthenticated && _voteProvider != null) {
-        for (final feedItem in response.feed) {
-          final viewer = feedItem.post.viewer;
-          _voteProvider.setInitialVoteState(
-            postUri: feedItem.post.uri,
-            voteDirection: viewer?.vote,
-            voteUri: viewer?.voteUri,
-          );
-        }
-      }
-    } on Exception catch (e) {
-      _error = e.toString();
-      if (kDebugMode) {
-        debugPrint('❌ Failed to fetch $feedName: $e');
-      }
-    } finally {
-      _isLoading = false;
-      _isLoadingMore = false;
-      notifyListeners();
-    }
-  }
-
-  /// Fetch timeline feed (authenticated)
-  ///
-  /// Fetches the user's personalized timeline.
-  /// Authentication is handled automatically via tokenGetter.
-  Future<void> fetchTimeline({bool refresh = false}) => _fetchFeed(
-    refresh: refresh,
-    fetcher:
-        () => _apiService.getTimeline(
-          sort: _sort,
-          timeframe: _timeframe,
-          cursor: refresh ? null : _cursor,
-        ),
-    feedName: 'Timeline',
-  );
-
-  /// Fetch discover feed (public)
-  ///
-  /// Fetches the public discover feed.
-  /// Does not require authentication.
-  Future<void> fetchDiscover({bool refresh = false}) => _fetchFeed(
-    refresh: refresh,
-    fetcher:
-        () => _apiService.getDiscover(
-          sort: _sort,
-          timeframe: _timeframe,
-          cursor: refresh ? null : _cursor,
-        ),
-    feedName: 'Discover',
-  );
-
-  /// Load more posts (pagination)
-  Future<void> loadMore() async {
-    if (!_hasMore || _isLoadingMore) {
-      return;
-    }
-    await loadFeed();
-  }
-
-  /// Change sort order
-  void setSort(String newSort, {String? newTimeframe}) {
-    _sort = newSort;
-    _timeframe = newTimeframe;
-    notifyListeners();
-  }
-
-  /// Retry loading after error
-  Future<void> retry() async {
-    _error = null;
-    await loadFeed(refresh: true);
-  }
-
-  /// Clear error
-  void clearError() {
-    _error = null;
-    notifyListeners();
-  }
-
-  /// Reset feed state
-  void reset() {
-    _posts = [];
-    _cursor = null;
-    _hasMore = true;
-    _error = null;
-    _isLoading = false;
-    _isLoadingMore = false;
-    notifyListeners();
-  }
-
-  @override
-  void dispose() {
-    // Stop time updates and cancel timer
-    stopTimeUpdates();
-    // Remove auth listener to prevent memory leaks
-    _authProvider.removeListener(_onAuthChanged);
-    _apiService.dispose();
-    super.dispose();
-  }
-}

lib/providers/multi_feed_provider.dart

···
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+import '../models/feed_state.dart';
+import '../models/post.dart';
+import '../services/coves_api_service.dart';
+import 'auth_provider.dart';
+import 'vote_provider.dart';
+
+/// Feed types available in the app
+enum FeedType {
+  /// All posts across the network
+  discover,
+
+  /// Posts from subscribed communities (authenticated only)
+  forYou,
+}
+
+/// Multi-Feed Provider
+///
+/// Manages independent state for multiple feeds (Discover and For You).
+/// Each feed maintains its own posts, scroll position, and pagination state.
+///
+/// IMPORTANT: Accepts AuthProvider reference to fetch fresh access
+/// tokens before each authenticated request (critical for atProto OAuth
+/// token rotation).
+class MultiFeedProvider with ChangeNotifier {
+  MultiFeedProvider(
+    this._authProvider, {
+    CovesApiService? apiService,
+    VoteProvider? voteProvider,
+  }) : _voteProvider = voteProvider {
+    // Use injected service (for testing) or create new one (for production)
+    // Pass token getter, refresh handler, and sign out handler to API service
+    // for automatic fresh token retrieval and automatic token refresh on 401
+    _apiService =
+        apiService ??
+        CovesApiService(
+          tokenGetter: _authProvider.getAccessToken,
+          tokenRefresher: _authProvider.refreshToken,
+          signOutHandler: _authProvider.signOut,
+        );
+
+    // Track initial auth state
+    _wasAuthenticated = _authProvider.isAuthenticated;
+
+    // Listen to auth state changes and clear For You feed on sign-out
+    // This prevents privacy bug where logged-out users see their
+    // private timeline until they manually refresh.
+    _authProvider.addListener(_onAuthChanged);
+  }
+
+  /// Handle authentication state changes
+  ///
+  /// Only clears For You feed when transitioning from authenticated to
+  /// unauthenticated (actual sign-out), not when staying unauthenticated
+  /// (e.g., failed sign-in attempt). This prevents unnecessary API calls.
+  void _onAuthChanged() {
+    final isAuthenticated = _authProvider.isAuthenticated;
+
+    // Only clear For You feed if transitioning from authenticated to
+    // unauthenticated
+    if (_wasAuthenticated && !isAuthenticated) {
+      if (kDebugMode) {
+        debugPrint('🔒 User signed out - clearing For You feed');
+      }
+      // Clear For You feed state, keep Discover intact
+      _feedStates.remove(FeedType.forYou);
+
+      // Switch to Discover if currently on For You
+      if (_currentFeedType == FeedType.forYou) {
+        _currentFeedType = FeedType.discover;
+      }
+
+      notifyListeners();
+    }
+
+    // Update tracked state
+    _wasAuthenticated = isAuthenticated;
+  }
+
+  final AuthProvider _authProvider;
+  late final CovesApiService _apiService;
+  final VoteProvider? _voteProvider;
+
+  // Track previous auth state to detect transitions
+  bool _wasAuthenticated = false;
+
+  // Per-feed state storage
+  final Map<FeedType, FeedState> _feedStates = {};
+
+  // Currently active feed
+  FeedType _currentFeedType = FeedType.discover;
+
+  // Feed configuration (shared across feeds)
+  String _sort = 'hot';
+  String? _timeframe;
+
+  // Time update mechanism for periodic UI refreshes
+  Timer? _timeUpdateTimer;
+  DateTime? _currentTime;
+
+  // Getters
+  FeedType get currentFeedType => _currentFeedType;
+  String get sort => _sort;
+  String? get timeframe => _timeframe;
+  DateTime? get currentTime => _currentTime;
+
+  /// Check if For You feed is available (requires authentication)
+  bool get isForYouAvailable => _authProvider.isAuthenticated;
+
+  /// Get state for a specific feed (creates default if missing)
+  FeedState getState(FeedType type) {
+    return _feedStates[type] ?? FeedState.initial();
+  }
+
+  /// Set the current active feed type
+  ///
+  /// This just updates which feed is active, does NOT load data.
+  /// The UI should call loadFeed() separately if needed.
+  void setCurrentFeed(FeedType type) {
+    if (_currentFeedType == type) {
+      return;
+    }
+
+    // For You requires authentication
+    if (type == FeedType.forYou && !_authProvider.isAuthenticated) {
+      return;
+    }
+
+    _currentFeedType = type;
+    notifyListeners();
+  }
+
+  /// Save scroll position for a feed (passive, no notifyListeners)
+  ///
+  /// This is called frequently during scrolling, so we don't trigger
+  /// rebuilds. The scroll position is persisted in the feed state for
+  /// restoration when the user switches back to this feed.
+  void saveScrollPosition(FeedType type, double position) {
+    final currentState = getState(type);
+    _feedStates[type] = currentState.copyWith(scrollPosition: position);
+    // Intentionally NOT calling notifyListeners() - this is a passive save
+  }
+
+  /// Start periodic time updates for "time ago" strings
+  ///
+  /// Updates currentTime every minute to trigger UI rebuilds for
+  /// post timestamps. This ensures "5m ago" updates to "6m ago" without
+  /// requiring user interaction.
+  void startTimeUpdates() {
+    // Cancel existing timer if any
+    _timeUpdateTimer?.cancel();
+
+    // Update current time immediately
+    _currentTime = DateTime.now();
+    notifyListeners();
+
+    // Set up periodic updates (every minute)
+    _timeUpdateTimer = Timer.periodic(const Duration(minutes: 1), (_) {
+      _currentTime = DateTime.now();
+      notifyListeners();
+    });
+
+    if (kDebugMode) {
+      debugPrint('⏰ Started periodic time updates for feed timestamps');
+    }
+  }
+
+  /// Stop periodic time updates
+  void stopTimeUpdates() {
+    _timeUpdateTimer?.cancel();
+    _timeUpdateTimer = null;
+    _currentTime = null;
+
+    if (kDebugMode) {
+      debugPrint('⏰ Stopped periodic time updates');
+    }
+  }
+
+  /// Load feed based on feed type
+  ///
+  /// This method encapsulates the business logic of deciding which feed
+  /// to fetch based on the selected feed type.
+  Future<void> loadFeed(FeedType type, {bool refresh = false}) async {
+    // For You requires authentication - fall back to Discover if not
+    if (type == FeedType.forYou && _authProvider.isAuthenticated) {
+      await _fetchTimeline(type, refresh: refresh);
+    } else {
+      await _fetchDiscover(type, refresh: refresh);
+    }
+
+    // Start time updates when feed is loaded
+    final state = getState(type);
+    if (state.posts.isNotEmpty && _timeUpdateTimer == null) {
+      startTimeUpdates();
+    }
+  }
+
+  /// Load more posts for a feed (pagination)
+  Future<void> loadMore(FeedType type) async {
+    final state = getState(type);
+
+    if (!state.hasMore || state.isLoadingMore) {
+      return;
+    }
+
+    await loadFeed(type);
+  }
+
+  /// Common feed fetching logic (DRY principle - eliminates code
+  /// duplication)
+  Future<void> _fetchFeed({
+    required FeedType type,
+    required bool refresh,
+    required Future<TimelineResponse> Function() fetcher,
+    required String feedName,
+  }) async {
+    final currentState = getState(type);
+
+    if (currentState.isLoading || currentState.isLoadingMore) {
+      return;
+    }
+
+    // Capture session identity before fetch to detect any auth change
+    // (sign-out, or sign-in as different user) during the request
+    final sessionDidBeforeFetch = _authProvider.did;
+
+    try {
+      if (refresh) {
+        // Start loading, keep existing data visible
+        _feedStates[type] = currentState.copyWith(isLoading: true, error: null);
+      } else {
+        // Pagination
+        _feedStates[type] = currentState.copyWith(isLoadingMore: true);
+      }
+      notifyListeners();
+
+      final response = await fetcher();
+
+      // SECURITY: If session changed during fetch, discard the response
+      // to prevent cross-session data leaks. This handles:
+      // - User signed out (DID became null)
+      // - User signed out and back in as same user (unlikely but safe)
+      // - User signed out and different user signed in (DID changed)
+      // This is especially important for the For You feed which contains
+      // private timeline data.
+      if (type == FeedType.forYou &&
+          sessionDidBeforeFetch != _authProvider.did) {
+        if (kDebugMode) {
+          debugPrint(
+            '🔒 Discarding $feedName response - session changed during fetch',
+          );
+        }
+        // Remove the feed state entirely (don't write back stale data)
+        // _onAuthChanged already removed this, but ensure it stays removed
+        _feedStates.remove(type);
+        notifyListeners();
+        return;
+      }
+
+      // Only update state after successful fetch
+      final List<FeedViewPost> newPosts;
+      if (refresh) {
+        newPosts = response.feed;
+      } else {
+        // Create new list instance to trigger context.select rebuilds
+        // Using spread operator instead of addAll to ensure reference changes
+        newPosts = [...currentState.posts, ...response.feed];
+      }
+
+      _feedStates[type] = currentState.copyWith(
+        posts: newPosts,
+        cursor: response.cursor,
+        hasMore: response.cursor != null,
+        error: null,
+        isLoading: false,
+        isLoadingMore: false,
+        lastRefreshTime:
+            refresh ? DateTime.now() : currentState.lastRefreshTime,
+      );
+
+      if (kDebugMode) {
+        debugPrint('✅ $feedName loaded: ${newPosts.length} posts total');
+      }
+
+      // Initialize vote state from viewer data in feed response
+      // IMPORTANT: Call setInitialVoteState for ALL feed items, even
+      // when viewer.vote is null. This ensures that if a user removed
+      // their vote on another device, the local state is cleared on
+      // refresh.
+      if (_authProvider.isAuthenticated && _voteProvider != null) {
+        for (final feedItem in response.feed) {
+          final viewer = feedItem.post.viewer;
+          _voteProvider.setInitialVoteState(
+            postUri: feedItem.post.uri,
+            voteDirection: viewer?.vote,
+            voteUri: viewer?.voteUri,
+          );
+        }
+      }
+    } on Exception catch (e) {
+      // SECURITY: Also check session change in error path to prevent
+      // leaking stale data when a fetch fails after sign-out
+      if (type == FeedType.forYou &&
+          sessionDidBeforeFetch != _authProvider.did) {
+        if (kDebugMode) {
+          debugPrint(
+            '🔒 Discarding $feedName error - session changed during fetch',
+          );
+        }
+        _feedStates.remove(type);
+        notifyListeners();
+        return;
+      }
+
+      _feedStates[type] = currentState.copyWith(
+        error: e.toString(),
+        isLoading: false,
+        isLoadingMore: false,
+      );
+
+      if (kDebugMode) {
+        debugPrint('❌ Failed to fetch $feedName: $e');
+      }
+    }
+
+    notifyListeners();
+  }
+
+  /// Fetch timeline feed (authenticated)
+  ///
+  /// Fetches the user's personalized timeline.
+  /// Authentication is handled automatically via tokenGetter.
+  Future<void> _fetchTimeline(FeedType type, {bool refresh = false}) {
+    final currentState = getState(type);
+
+    return _fetchFeed(
+      type: type,
+      refresh: refresh,
+      fetcher:
+          () => _apiService.getTimeline(
+            sort: _sort,
+            timeframe: _timeframe,
+            cursor: refresh ? null : currentState.cursor,
+          ),
+      feedName: 'Timeline',
+    );
+  }
+
+  /// Fetch discover feed (public)
+  ///
+  /// Fetches the public discover feed.
+  /// Does not require authentication.
+  Future<void> _fetchDiscover(FeedType type, {bool refresh = false}) {
+    final currentState = getState(type);
+
+    return _fetchFeed(
+      type: type,
+      refresh: refresh,
+      fetcher:
+          () => _apiService.getDiscover(
+            sort: _sort,
+            timeframe: _timeframe,
+            cursor: refresh ? null : currentState.cursor,
+          ),
+      feedName: 'Discover',
+    );
+  }
+
+  /// Change sort order
+  void setSort(String newSort, {String? newTimeframe}) {
+    _sort = newSort;
+    _timeframe = newTimeframe;
+    notifyListeners();
+  }
+
+  /// Retry loading after error for a specific feed
+  Future<void> retry(FeedType type) async {
+    final currentState = getState(type);
+    _feedStates[type] = currentState.copyWith(error: null);
+    notifyListeners();
+
+    await loadFeed(type);
+  }
+
+  /// Clear error for a specific feed
+  void clearError(FeedType type) {
+    final currentState = getState(type);
+    _feedStates[type] = currentState.copyWith(error: null);
+    notifyListeners();
+  }
+
+  /// Reset feed state for a specific feed
+  void reset(FeedType type) {
+    _feedStates[type] = FeedState.initial();
+    notifyListeners();
+  }
+
+  /// Reset all feeds
+  void resetAll() {
+    _feedStates.clear();
+    notifyListeners();
+  }
+
+  @override
+  void dispose() {
+    // Stop time updates and cancel timer
+    stopTimeUpdates();
+    // Remove auth listener to prevent memory leaks
+    _authProvider.removeListener(_onAuthChanged);
+    _apiService.dispose();
+    super.dispose();
+  }
+}

lib/screens/home/feed_screen.dart

···
 import 'package:provider/provider.dart';
 
 import '../../constants/app_colors.dart';
-import '../../models/post.dart';
 import '../../providers/auth_provider.dart';
-import '../../providers/feed_provider.dart';
+import '../../providers/multi_feed_provider.dart';
+import '../../widgets/feed_page.dart';
 import '../../widgets/icons/bluesky_icons.dart';
-import '../../widgets/post_card.dart';
 
 /// Header layout constants
 const double _kHeaderHeight = 44;
 const double _kTabUnderlineWidth = 28;
 const double _kTabUnderlineHeight = 3;
-const double _kHeaderContentPadding = _kHeaderHeight;
 
 class FeedScreen extends StatefulWidget {
   const FeedScreen({super.key, this.onSearchTap});
···
 }
 
 class _FeedScreenState extends State<FeedScreen> {
-  final ScrollController _scrollController = ScrollController();
+  late PageController _pageController;
+  final Map<FeedType, ScrollController> _scrollControllers = {};
+  late AuthProvider _authProvider;
+  bool _wasAuthenticated = false;
 
   @override
   void initState() {
     super.initState();
-    _scrollController.addListener(_onScroll);
 
-    // Fetch feed after frame is built
+    // Initialize PageController
+    // Start on page 0 (Discover) or 1 (For You) based on current feed
+    final provider = context.read<MultiFeedProvider>();
+    final initialPage = provider.currentFeedType == FeedType.forYou ? 1 : 0;
+    _pageController = PageController(initialPage: initialPage);
+
+    // Save reference to AuthProvider for listener management
+    _authProvider = context.read<AuthProvider>();
+    _wasAuthenticated = _authProvider.isAuthenticated;
+
+    // Listen to auth changes to sync PageController with provider state
+    _authProvider.addListener(_onAuthChanged);
+
+    // Load initial feed after frame is built
     WidgetsBinding.instance.addPostFrameCallback((_) {
-      // Check if widget is still mounted before loading
       if (mounted) {
-        _loadFeed();
+        _loadInitialFeed();
       }
     });
   }
 
   @override
   void dispose() {
-    _scrollController.dispose();
+    _authProvider.removeListener(_onAuthChanged);
+    _pageController.dispose();
+    for (final controller in _scrollControllers.values) {
+      controller.dispose();
+    }
     super.dispose();
   }
 
-  /// Load feed - business logic is now in FeedProvider
-  void _loadFeed() {
-    Provider.of<FeedProvider>(context, listen: false).loadFeed(refresh: true);
+  /// Handle auth state changes to sync PageController with provider
+  ///
+  /// When user signs out while on For You tab, the provider switches to
+  /// Discover but PageController stays on page 1. This listener ensures
+  /// they stay in sync.
+  void _onAuthChanged() {
+    final isAuthenticated = _authProvider.isAuthenticated;
+
+    // On sign-out: jump to Discover (page 0) to match provider state
+    if (_wasAuthenticated && !isAuthenticated) {
+      if (_pageController.hasClients && _pageController.page != 0) {
+        _pageController.jumpToPage(0);
+      }
+    }
+
+    _wasAuthenticated = isAuthenticated;
+  }
+
+  /// Load initial feed based on authentication
+  void _loadInitialFeed() {
+    final provider = context.read<MultiFeedProvider>();
+    final isAuthenticated = context.read<AuthProvider>().isAuthenticated;
+
+    // Load the current feed
+    provider.loadFeed(provider.currentFeedType, refresh: true);
+
+    // Preload the other feed if authenticated
+    if (isAuthenticated) {
+      final otherFeed =
+          provider.currentFeedType == FeedType.discover
+              ? FeedType.forYou
+              : FeedType.discover;
+      provider.loadFeed(otherFeed, refresh: true);
+    }
   }
 
-  void _onScroll() {
-    if (_scrollController.position.pixels >=
-        _scrollController.position.maxScrollExtent - 200) {
-      Provider.of<FeedProvider>(context, listen: false).loadMore();
+  /// Get or create scroll controller for a feed type
+  ScrollController _getOrCreateScrollController(FeedType type) {
+    if (!_scrollControllers.containsKey(type)) {
+      final provider = context.read<MultiFeedProvider>();
+      final state = provider.getState(type);
+      _scrollControllers[type] = ScrollController(
+        initialScrollOffset: state.scrollPosition,
+      );
+      _scrollControllers[type]!.addListener(() => _onScroll(type));
     }
+    return _scrollControllers[type]!;
   }
 
-  Future<void> _onRefresh() async {
-    final feedProvider = Provider.of<FeedProvider>(context, listen: false);
-    await feedProvider.loadFeed(refresh: true);
+  /// Handle scroll events for pagination and scroll position saving
+  void _onScroll(FeedType type) {
+    final controller = _scrollControllers[type];
+    if (controller != null && controller.hasClients) {
+      // Save scroll position passively (no rebuild needed)
+      context.read<MultiFeedProvider>().saveScrollPosition(
+        type,
+        controller.position.pixels,
+      );
+
+      // Trigger pagination when near bottom
+      if (controller.position.pixels >=
+          controller.position.maxScrollExtent - 200) {
+        context.read<MultiFeedProvider>().loadMore(type);
+      }
+    }
   }
 
   @override
   Widget build(BuildContext context) {
-    // Optimized: Use select to only rebuild when specific fields change
-    // This prevents unnecessary rebuilds when unrelated provider fields change
+    // Use select to only rebuild when specific fields change
     final isAuthenticated = context.select<AuthProvider, bool>(
       (p) => p.isAuthenticated,
     );
-    final isLoading = context.select<FeedProvider, bool>((p) => p.isLoading);
-    final error = context.select<FeedProvider, String?>((p) => p.error);
-    final feedType = context.select<FeedProvider, FeedType>((p) => p.feedType);
-
-    // IMPORTANT: This relies on FeedProvider creating new list instances
-    // (_posts = [..._posts, ...response.feed]) rather than mutating in-place.
-    // context.select uses == for comparison, and Lists use reference equality,
-    // so in-place mutations (_posts.addAll(...)) would not trigger rebuilds.
-    final posts = context.select<FeedProvider, List<FeedViewPost>>(
-      (p) => p.posts,
-    );
-    final isLoadingMore = context.select<FeedProvider, bool>(
-      (p) => p.isLoadingMore,
-    );
-    final currentTime = context.select<FeedProvider, DateTime?>(
-      (p) => p.currentTime,
+    final currentFeed = context.select<MultiFeedProvider, FeedType>(
+      (p) => p.currentFeedType,
     );
 
     return Scaffold(
···
       body: SafeArea(
         child: Stack(
           children: [
-            // Feed content (behind header)
-            _buildBody(
-              isLoading: isLoading,
-              error: error,
-              posts: posts,
-              isLoadingMore: isLoadingMore,
+            // Feed content with PageView for swipe navigation
+            _buildBody(isAuthenticated: isAuthenticated),
+            // Transparent header overlay
+            _buildHeader(
+              feedType: currentFeed,
               isAuthenticated: isAuthenticated,
-              currentTime: currentTime,
             ),
-            // Transparent header overlay
-            _buildHeader(feedType: feedType, isAuthenticated: isAuthenticated),
           ],
         ),
       ),
···
         _buildFeedTypeTab(
           label: 'Discover',
           isActive: feedType == FeedType.discover,
-          onTap: () => _switchToFeedType(FeedType.discover),
+          onTap: () => _switchToFeedType(FeedType.discover, 0),
         ),
         const SizedBox(width: 24),
         _buildFeedTypeTab(
           label: 'For You',
           isActive: feedType == FeedType.forYou,
-          onTap: () => _switchToFeedType(FeedType.forYou),
+          onTap: () => _switchToFeedType(FeedType.forYou, 1),
         ),
       ],
     );
···
     );
   }
 
-  void _switchToFeedType(FeedType type) {
-    Provider.of<FeedProvider>(context, listen: false).setFeedType(type);
+  /// Switch to a feed type and animate PageView
+  void _switchToFeedType(FeedType type, int pageIndex) {
+    context.read<MultiFeedProvider>().setCurrentFeed(type);
+
+    // Animate to the corresponding page
+    _pageController.animateToPage(
+      pageIndex,
+      duration: const Duration(milliseconds: 300),
+      curve: Curves.easeInOut,
+    );
+
+    // Load the feed if it hasn't been loaded yet
+    _ensureFeedLoaded(type);
+
+    // Restore scroll position after page animation completes
+    _restoreScrollPosition(type);
   }
 
-  Widget _buildBody({
-    required bool isLoading,
-    required String? error,
-    required List<FeedViewPost> posts,
-    required bool isLoadingMore,
-    required bool isAuthenticated,
-    required DateTime? currentTime,
-  }) {
-    // Loading state (only show full-screen loader for initial load,
-    // not refresh)
-    if (isLoading && posts.isEmpty) {
-      return const Center(
-        child: CircularProgressIndicator(color: AppColors.primary),
-      );
-    }
+  /// Ensure a feed is loaded (trigger initial load if needed)
+  ///
+  /// Called when switching to a feed that may not have been loaded yet,
+  /// e.g., when user signs in after app start and taps "For You" tab.
+  void _ensureFeedLoaded(FeedType type) {
+    final provider = context.read<MultiFeedProvider>();
+    final state = provider.getState(type);
 
-    // Error state (only show full-screen error when no posts loaded
-    // yet). If we have posts but pagination failed, we'll show the error
-    // at the bottom
-    if (error != null && posts.isEmpty) {
-      return Center(
-        child: Padding(
-          padding: const EdgeInsets.all(24),
-          child: Column(
-            mainAxisAlignment: MainAxisAlignment.center,
-            children: [
-              const Icon(
-                Icons.error_outline,
-                size: 64,
-                color: AppColors.primary,
-              ),
-              const SizedBox(height: 16),
-              const Text(
-                'Failed to load feed',
-                style: TextStyle(
-                  fontSize: 20,
-                  color: AppColors.textPrimary,
-                  fontWeight: FontWeight.bold,
-                ),
-              ),
-              const SizedBox(height: 8),
-              Text(
-                _getUserFriendlyError(error),
-                style: const TextStyle(
-                  fontSize: 14,
-                  color: AppColors.textSecondary,
-                ),
-                textAlign: TextAlign.center,
-              ),
-              const SizedBox(height: 24),
-              ElevatedButton(
-                onPressed: () {
-                  Provider.of<FeedProvider>(context, listen: false).retry();
-                },
-                style: ElevatedButton.styleFrom(
-                  backgroundColor: AppColors.primary,
-                ),
-                child: const Text('Retry'),
-              ),
-            ],
-          ),
-        ),
-      );
+    // If the feed has no posts and isn't currently loading, trigger a load
+    if (state.posts.isEmpty && !state.isLoading) {
+      provider.loadFeed(type, refresh: true);
     }
+  }
 
-    // Empty state
-    if (posts.isEmpty) {
-      return Center(
-        child: Padding(
-          padding: const EdgeInsets.all(24),
-          child: Column(
-            mainAxisAlignment: MainAxisAlignment.center,
-            children: [
-              const Icon(Icons.forum, size: 64, color: AppColors.primary),
-              const SizedBox(height: 24),
-              Text(
-                isAuthenticated ? 'No posts yet' : 'No posts to discover',
-                style: const TextStyle(
-                  fontSize: 20,
-                  color: AppColors.textPrimary,
-                  fontWeight: FontWeight.bold,
-                ),
-              ),
-              const SizedBox(height: 8),
-              Text(
-                isAuthenticated
-                    ? 'Subscribe to communities to see posts in your feed'
-                    : 'Check back later for new posts',
-                style: const TextStyle(
-                  fontSize: 14,
-                  color: AppColors.textSecondary,
-                ),
-                textAlign: TextAlign.center,
-              ),
-            ],
-          ),
-        ),
-      );
+  /// Restore scroll position for a feed type
+  void _restoreScrollPosition(FeedType type) {
+    // Wait for the next frame to ensure the controller has clients
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (!mounted) {
+        return;
+      }
+
+      final controller = _scrollControllers[type];
+      if (controller != null && controller.hasClients) {
+        final provider = context.read<MultiFeedProvider>();
+        final savedPosition = provider.getState(type).scrollPosition;
+
+        // Only jump if the saved position differs from current
+        if ((controller.offset - savedPosition).abs() > 1) {
+          controller.jumpTo(savedPosition);
+        }
+      }
+    });
+  }
+
+  Widget _buildBody({required bool isAuthenticated}) {
+    // For unauthenticated users, show only Discover feed (no PageView)
+    if (!isAuthenticated) {
+      return _buildFeedPage(FeedType.discover, isAuthenticated);
     }
 
-    // Posts list
-    return RefreshIndicator(
-      onRefresh: _onRefresh,
-      color: AppColors.primary,
-      child: ListView.builder(
-        controller: _scrollController,
-        // Add top padding so content isn't hidden behind transparent header
-        padding: const EdgeInsets.only(top: _kHeaderContentPadding),
-        // Add extra item for loading indicator or pagination error
-        itemCount: posts.length + (isLoadingMore || error != null ? 1 : 0),
-        itemBuilder: (context, index) {
-          // Footer: loading indicator or error message
-          if (index == posts.length) {
-            // Show loading indicator for pagination
-            if (isLoadingMore) {
-              return const Center(
-                child: Padding(
-                  padding: EdgeInsets.all(16),
-                  child: CircularProgressIndicator(color: AppColors.primary),
-                ),
-              );
-            }
-            // Show error message for pagination failures
-            if (error != null) {
-              return Container(
-                margin: const EdgeInsets.all(16),
-                padding: const EdgeInsets.all(16),
-                decoration: BoxDecoration(
-                  color: AppColors.background,
-                  borderRadius: BorderRadius.circular(8),
-                  border: Border.all(color: AppColors.primary),
-                ),
-                child: Column(
-                  children: [
-                    const Icon(
-                      Icons.error_outline,
-                      color: AppColors.primary,
-                      size: 32,
-                    ),
-                    const SizedBox(height: 8),
-                    Text(
-                      _getUserFriendlyError(error),
-                      style: const TextStyle(
-                        color: AppColors.textSecondary,
-                        fontSize: 14,
-                      ),
-                      textAlign: TextAlign.center,
-                    ),
-                    const SizedBox(height: 12),
-                    TextButton(
-                      onPressed: () {
-                        Provider.of<FeedProvider>(context, listen: false)
-                          ..clearError()
-                          ..loadMore();
-                      },
-                      style: TextButton.styleFrom(
-                        foregroundColor: AppColors.primary,
-                      ),
-                      child: const Text('Retry'),
-                    ),
-                  ],
-                ),
-              );
-            }
-          }
-
-          final post = posts[index];
-          return Semantics(
-            label:
-                'Feed post in ${post.post.community.name} by '
-                '${post.post.author.displayName ?? post.post.author.handle}. '
-                '${post.post.title ?? ""}',
-            button: true,
-            child: PostCard(post: post, currentTime: currentTime),
-          );
-        },
-      ),
+    // For authenticated users, use PageView for swipe navigation
+    return PageView(
+      controller: _pageController,
+      onPageChanged: (index) {
+        final type = index == 0 ? FeedType.discover : FeedType.forYou;
+        context.read<MultiFeedProvider>().setCurrentFeed(type);
+        // Load the feed if it hasn't been loaded yet
+        _ensureFeedLoaded(type);
+        // Restore scroll position when swiping between feeds
+        _restoreScrollPosition(type);
+      },
+      children: [
+        _buildFeedPage(FeedType.discover, isAuthenticated),
+        _buildFeedPage(FeedType.forYou, isAuthenticated),
+      ],
     );
   }
 
-  /// Transform technical error messages into user-friendly ones
-  String _getUserFriendlyError(String error) {
-    final lowerError = error.toLowerCase();
+  /// Build a FeedPage widget with all required state from provider
+  Widget _buildFeedPage(FeedType feedType, bool isAuthenticated) {
+    return Consumer<MultiFeedProvider>(
+      builder: (context, provider, _) {
+        final state = provider.getState(feedType);
 
-    if (lowerError.contains('socketexception') ||
-        lowerError.contains('network') ||
-        lowerError.contains('connection refused')) {
-      return 'Please check your internet connection';
-    } else if (lowerError.contains('timeoutexception') ||
-        lowerError.contains('timeout')) {
-      return 'Request timed out. Please try again';
-    } else if (lowerError.contains('401') ||
-        lowerError.contains('unauthorized')) {
-      return 'Authentication failed. Please sign in again';
-    } else if (lowerError.contains('404') || lowerError.contains('not found')) {
-      return 'Content not found';
-    } else if (lowerError.contains('500') ||
-        lowerError.contains('internal server')) {
-      return 'Server error. Please try again later';
-    }
+        // Handle error: treat null and empty string as no error
+        final error = state.error;
+        final hasError = error != null && error.isNotEmpty;
 
-    // Fallback to generic message for unknown errors
-    return 'Something went wrong. Please try again';
+        return FeedPage(
+          feedType: feedType,
+          posts: state.posts,
+          isLoading: state.isLoading,
+          isLoadingMore: state.isLoadingMore,
+          error: hasError ? error : null,
+          scrollController: _getOrCreateScrollController(feedType),
+          onRefresh: () => provider.loadFeed(feedType, refresh: true),
+          onRetry: () => provider.retry(feedType),
+          onClearErrorAndLoadMore:
+              () =>
+                  provider
+                    ..clearError(feedType)
+                    ..loadMore(feedType),
+          isAuthenticated: isAuthenticated,
+          currentTime: provider.currentTime,
+        );
+      },
+    );
   }
 }

lib/widgets/feed_page.dart

···
+import 'package:flutter/material.dart';
+
+import '../constants/app_colors.dart';
+import '../models/post.dart';
+import '../providers/multi_feed_provider.dart';
+import 'post_card.dart';
+
+/// FeedPage widget for rendering a single feed's content
+///
+/// Displays a feed with:
+/// - Loading state (spinner when loading initial posts)
+/// - Error state (error message with retry button)
+/// - Empty state (no posts message)
+/// - Posts list (RefreshIndicator + ListView.builder with PostCard widgets)
+/// - Pagination footer (loading indicator or error retry at bottom)
+///
+/// This widget is used within a PageView to render individual feeds
+/// (Discover, For You) in the feed screen.
+///
+/// Uses AutomaticKeepAliveClientMixin to keep the page alive when swiping
+/// between feeds, preventing scroll position jumps during transitions.
+class FeedPage extends StatefulWidget {
+  const FeedPage({
+    required this.feedType,
+    required this.posts,
+    required this.isLoading,
+    required this.isLoadingMore,
+    required this.error,
+    required this.scrollController,
+    required this.onRefresh,
+    required this.onRetry,
+    required this.onClearErrorAndLoadMore,
+    required this.isAuthenticated,
+    required this.currentTime,
+    super.key,
+  });
+
+  final FeedType feedType;
+  final List<FeedViewPost> posts;
+  final bool isLoading;
+  final bool isLoadingMore;
+  final String? error;
+  final ScrollController scrollController;
+  final Future<void> Function() onRefresh;
+  final VoidCallback onRetry;
+  final VoidCallback onClearErrorAndLoadMore;
+  final bool isAuthenticated;
+  final DateTime? currentTime;
+
+  @override
+  State<FeedPage> createState() => _FeedPageState();
+}
+
+class _FeedPageState extends State<FeedPage>
+    with AutomaticKeepAliveClientMixin {
+  @override
+  bool get wantKeepAlive => true;
+
+  @override
+  Widget build(BuildContext context) {
+    // Required call for AutomaticKeepAliveClientMixin
+    super.build(context);
+
+    // Loading state (only show full-screen loader for initial load,
+    // not refresh)
+    if (widget.isLoading && widget.posts.isEmpty) {
+      return const Center(
+        child: CircularProgressIndicator(color: AppColors.primary),
+      );
+    }
+
+    // Error state (only show full-screen error when no posts loaded
+    // yet). If we have posts but pagination failed, we'll show the error
+    // at the bottom
+    if (widget.error != null && widget.posts.isEmpty) {
+      return Center(
+        child: Padding(
+          padding: const EdgeInsets.all(24),
+          child: Column(
+            mainAxisAlignment: MainAxisAlignment.center,
+            children: [
+              const Icon(
+                Icons.error_outline,
+                size: 64,
+                color: AppColors.primary,
+              ),
+              const SizedBox(height: 16),
+              const Text(
+                'Failed to load feed',
+                style: TextStyle(
+                  fontSize: 20,
+                  color: AppColors.textPrimary,
+                  fontWeight: FontWeight.bold,
+                ),
+              ),
+              const SizedBox(height: 8),
+              Text(
+                _getUserFriendlyError(widget.error!),
+                style: const TextStyle(
+                  fontSize: 14,
+                  color: AppColors.textSecondary,
+                ),
+                textAlign: TextAlign.center,
+              ),
+              const SizedBox(height: 24),
+              ElevatedButton(
+                onPressed: widget.onRetry,
+                style: ElevatedButton.styleFrom(
+                  backgroundColor: AppColors.primary,
+                ),
+                child: const Text('Retry'),
+              ),
+            ],
+          ),
+        ),
+      );
+    }
+
+    // Empty state - wrapped in RefreshIndicator so users can pull to refresh
+    if (widget.posts.isEmpty) {
+      return RefreshIndicator(
+        onRefresh: widget.onRefresh,
+        color: AppColors.primary,
+        child: CustomScrollView(
+          physics: const AlwaysScrollableScrollPhysics(),
+          slivers: [
+            SliverFillRemaining(
+              hasScrollBody: false,
+              child: Center(
+                child: Padding(
+                  padding: const EdgeInsets.all(24),
+                  child: Column(
+                    mainAxisAlignment: MainAxisAlignment.center,
+                    children: [
+                      const Icon(
+                        Icons.forum,
+                        size: 64,
+                        color: AppColors.primary,
+                      ),
+                      const SizedBox(height: 24),
+                      Text(
+                        widget.isAuthenticated
+                            ? 'No posts yet'
+                            : 'No posts to discover',
+                        style: const TextStyle(
+                          fontSize: 20,
+                          color: AppColors.textPrimary,
+                          fontWeight: FontWeight.bold,
+                        ),
+                      ),
+                      const SizedBox(height: 8),
+                      Text(
+                        widget.isAuthenticated
+                            ? 'Subscribe to communities to see '
+                                'posts in your feed'
+                            : 'Check back later for new posts',
+                        style: const TextStyle(
+                          fontSize: 14,
+                          color: AppColors.textSecondary,
+                        ),
+                        textAlign: TextAlign.center,
+                      ),
+                    ],
+                  ),
+                ),
+              ),
+            ),
+          ],
+        ),
+      );
+    }
+
+    // Posts list
+    return RefreshIndicator(
+      onRefresh: widget.onRefresh,
+      color: AppColors.primary,
+      child: ListView.builder(
+        controller: widget.scrollController,
+        // Smooth bouncy scroll physics (iOS-style) with always-scrollable
+        // for pull-to-refresh support
+        physics: const BouncingScrollPhysics(
+          parent: AlwaysScrollableScrollPhysics(),
+        ),
+        // Pre-render items 800px above/below viewport for smoother scrolling
+        cacheExtent: 800,
+        // Add top padding so content isn't hidden behind transparent header
+        padding: const EdgeInsets.only(top: 44),
+        // Add extra item for loading indicator or pagination error
+        itemCount:
+            widget.posts.length +
+            (widget.isLoadingMore || widget.error != null ? 1 : 0),
+        itemBuilder: (context, index) {
+          // Footer: loading indicator or error message
+          if (index == widget.posts.length) {
+            // Show loading indicator for pagination
+            if (widget.isLoadingMore) {
+              return const Center(
+                child: Padding(
+                  padding: EdgeInsets.all(16),
+                  child: CircularProgressIndicator(color: AppColors.primary),
+                ),
+              );
+            }
+            // Show error message for pagination failures
+            if (widget.error != null) {
+              return Container(
+                margin: const EdgeInsets.all(16),
+                padding: const EdgeInsets.all(16),
+                decoration: BoxDecoration(
+                  color: AppColors.background,
+                  borderRadius: BorderRadius.circular(8),
+                  border: Border.all(color: AppColors.primary),
+                ),
+                child: Column(
+                  children: [
+                    const Icon(
+                      Icons.error_outline,
+                      color: AppColors.primary,
+                      size: 32,
+                    ),
+                    const SizedBox(height: 8),
+                    Text(
+                      _getUserFriendlyError(widget.error!),
+                      style: const TextStyle(
+                        color: AppColors.textSecondary,
+                        fontSize: 14,
+                      ),
+                      textAlign: TextAlign.center,
+                    ),
+                    const SizedBox(height: 12),
+                    TextButton(
+                      onPressed: widget.onClearErrorAndLoadMore,
+                      style: TextButton.styleFrom(
+                        foregroundColor: AppColors.primary,
+                      ),
+                      child: const Text('Retry'),
+                    ),
+                  ],
+                ),
+              );
+            }
+          }
+
+          final post = widget.posts[index];
+          // RepaintBoundary isolates each post card to prevent unnecessary
+          // repaints of other items during scrolling
+          return RepaintBoundary(
+            child: Semantics(
+              label:
+                  'Feed post in ${post.post.community.name} by '
+                  '${post.post.author.displayName ?? post.post.author.handle}. '
+                  '${post.post.title ?? ""}',
+              button: true,
+              child: PostCard(post: post, currentTime: widget.currentTime),
+            ),
+          );
+        },
+      ),
+    );
+  }
+
+  /// Transform technical error messages into user-friendly ones
+  String _getUserFriendlyError(String error) {
+    final lowerError = error.toLowerCase();
+
+    if (lowerError.contains('socketexception') ||
+        lowerError.contains('network') ||
+        lowerError.contains('connection refused')) {
+      return 'Please check your internet connection';
+    } else if (lowerError.contains('timeoutexception') ||
+        lowerError.contains('timeout')) {
+      return 'Request timed out. Please try again';
+    } else if (lowerError.contains('401') ||
+        lowerError.contains('unauthorized')) {
+      return 'Authentication failed. Please sign in again';
+    } else if (lowerError.contains('404') || lowerError.contains('not found')) {
+      return 'Content not found';
+    } else if (lowerError.contains('500') ||
+        lowerError.contains('internal server')) {
+      return 'Server error. Please try again later';
+    }
+
+    // Fallback to generic message for unknown errors
+    return 'Something went wrong. Please try again';
+  }
+}

pubspec.lock

···
     dependency: transitive
     description:
       name: meta
-      sha256: "23f08335362185a5ea2ad3a4e597f1375e78bce8a040df5c600c8d3552ef2394"
+      sha256: e3641ec5d63ebf0d9b41bd43201a66e3fc79a65db5f61fc181f04cd27aab950c
       url: "https://pub.dev"
     source: hosted
-    version: "1.17.0"
+    version: "1.16.0"
   mime:
     dependency: transitive
     description:
···
     dependency: transitive
     description:
       name: test_api
-      sha256: ab2726c1a94d3176a45960b6234466ec367179b87dd74f1611adb1f3b5fb9d55
+      sha256: "522f00f556e73044315fa4585ec3270f1808a4b186c936e612cab0b565ff1e00"
       url: "https://pub.dev"
     source: hosted
-    version: "0.7.7"
+    version: "0.7.6"
   typed_data:
     dependency: transitive
     description:

test/providers/feed_provider_test.dart

···
-import 'package:coves_flutter/models/post.dart';
-import 'package:coves_flutter/providers/auth_provider.dart';
-import 'package:coves_flutter/providers/feed_provider.dart';
-import 'package:coves_flutter/providers/vote_provider.dart';
-import 'package:coves_flutter/services/coves_api_service.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:mockito/annotations.dart';
-import 'package:mockito/mockito.dart';
-
-import 'feed_provider_test.mocks.dart';
-
-// Generate mocks
-@GenerateMocks([AuthProvider, CovesApiService, VoteProvider])
-void main() {
-  group('FeedProvider', () {
-    late FeedProvider feedProvider;
-    late MockAuthProvider mockAuthProvider;
-    late MockCovesApiService mockApiService;
-
-    setUp(() {
-      mockAuthProvider = MockAuthProvider();
-      mockApiService = MockCovesApiService();
-
-      // Mock default auth state
-      when(mockAuthProvider.isAuthenticated).thenReturn(false);
-
-      // Mock the token getter
-      when(
-        mockAuthProvider.getAccessToken(),
-      ).thenAnswer((_) async => 'test-token');
-
-      // Create feed provider with injected mock service
-      feedProvider = FeedProvider(mockAuthProvider, apiService: mockApiService);
-    });
-
-    tearDown(() {
-      feedProvider.dispose();
-    });
-
-    group('loadFeed', () {
-      test('should load discover feed when authenticated by default', () async {
-        when(mockAuthProvider.isAuthenticated).thenReturn(true);
-
-        final mockResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'next-cursor',
-        );
-
-        when(
-          mockApiService.getDiscover(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => mockResponse);
-
-        await feedProvider.loadFeed(refresh: true);
-
-        expect(feedProvider.posts.length, 1);
-        expect(feedProvider.error, null);
-        expect(feedProvider.isLoading, false);
-      });
-
-      test('should load timeline when feed type is For You', () async {
-        when(mockAuthProvider.isAuthenticated).thenReturn(true);
-
-        final mockResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'next-cursor',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => mockResponse);
-
-        await feedProvider.setFeedType(FeedType.forYou);
-
-        expect(feedProvider.posts.length, 1);
-        expect(feedProvider.error, null);
-        expect(feedProvider.isLoading, false);
-      });
-
-      test('should load discover feed when not authenticated', () async {
-        when(mockAuthProvider.isAuthenticated).thenReturn(false);
-
-        final mockResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'next-cursor',
-        );
-
-        when(
-          mockApiService.getDiscover(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => mockResponse);
-
-        await feedProvider.loadFeed(refresh: true);
-
-        expect(feedProvider.posts.length, 1);
-        expect(feedProvider.error, null);
-      });
-    });
-
-    group('fetchTimeline', () {
-      test('should fetch timeline successfully', () async {
-        final mockResponse = TimelineResponse(
-          feed: [_createMockPost(), _createMockPost()],
-          cursor: 'next-cursor',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => mockResponse);
-
-        await feedProvider.fetchTimeline(refresh: true);
-
-        expect(feedProvider.posts.length, 2);
-        expect(feedProvider.hasMore, true);
-        expect(feedProvider.error, null);
-      });
-
-      test('should handle network errors', () async {
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenThrow(Exception('Network error'));
-
-        await feedProvider.fetchTimeline(refresh: true);
-
-        expect(feedProvider.error, isNotNull);
-        expect(feedProvider.isLoading, false);
-      });
-
-      test('should append posts when not refreshing', () async {
-        // First load
-        final firstResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'cursor-1',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => firstResponse);
-
-        await feedProvider.fetchTimeline(refresh: true);
-        expect(feedProvider.posts.length, 1);
-
-        // Second load (pagination)
-        final secondResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'cursor-2',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: 'cursor-1',
-          ),
-        ).thenAnswer((_) async => secondResponse);
-
-        await feedProvider.fetchTimeline();
-        expect(feedProvider.posts.length, 2);
-      });
-
-      test('should replace posts when refreshing', () async {
-        // First load
-        final firstResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'cursor-1',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => firstResponse);
-
-        await feedProvider.fetchTimeline(refresh: true);
-        expect(feedProvider.posts.length, 1);
-
-        // Refresh
-        final refreshResponse = TimelineResponse(
-          feed: [_createMockPost(), _createMockPost()],
-          cursor: 'cursor-2',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-          ),
-        ).thenAnswer((_) async => refreshResponse);
-
-        await feedProvider.fetchTimeline(refresh: true);
-        expect(feedProvider.posts.length, 2);
-      });
-
-      test('should set hasMore to false when no cursor', () async {
-        final response = TimelineResponse(feed: [_createMockPost()]);
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => response);
-
-        await feedProvider.fetchTimeline(refresh: true);
-
-        expect(feedProvider.hasMore, false);
-      });
-    });
-
-    group('fetchDiscover', () {
-      test('should fetch discover feed successfully', () async {
-        final mockResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'next-cursor',
-        );
-
-        when(
-          mockApiService.getDiscover(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => mockResponse);
-
-        await feedProvider.fetchDiscover(refresh: true);
-
-        expect(feedProvider.posts.length, 1);
-        expect(feedProvider.error, null);
-      });
-
-      test('should handle empty feed', () async {
-        final emptyResponse = TimelineResponse(feed: []);
-
-        when(
-          mockApiService.getDiscover(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => emptyResponse);
-
-        await feedProvider.fetchDiscover(refresh: true);
-
-        expect(feedProvider.posts.isEmpty, true);
-        expect(feedProvider.hasMore, false);
-      });
-    });
-
-    group('loadMore', () {
-      test('should load more posts', () async {
-        when(mockAuthProvider.isAuthenticated).thenReturn(true);
-
-        // Initial load
-        final firstResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'cursor-1',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => firstResponse);
-
-        await feedProvider.setFeedType(FeedType.forYou);
-
-        // Load more
-        final secondResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'cursor-2',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: 'cursor-1',
-          ),
-        ).thenAnswer((_) async => secondResponse);
-
-        await feedProvider.loadMore();
-
-        expect(feedProvider.posts.length, 2);
-      });
-
-      test('should not load more if already loading', () async {
-        when(mockAuthProvider.isAuthenticated).thenReturn(true);
-
-        final response = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'cursor-1',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => response);
-
-        await feedProvider.setFeedType(FeedType.forYou);
-        await feedProvider.loadMore();
-
-        // Should not make additional calls while loading
-      });
-
-      test('should not load more if hasMore is false', () async {
-        final response = TimelineResponse(feed: [_createMockPost()]);
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => response);
-
-        await feedProvider.fetchTimeline(refresh: true);
-        expect(feedProvider.hasMore, false);
-
-        await feedProvider.loadMore();
-        // Should not attempt to load more
-      });
-    });
-
-    group('retry', () {
-      test('should retry after error', () async {
-        when(mockAuthProvider.isAuthenticated).thenReturn(true);
-
-        // Simulate error
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenThrow(Exception('Network error'));
-
-        await feedProvider.setFeedType(FeedType.forYou);
-        expect(feedProvider.error, isNotNull);
-
-        // Retry
-        final successResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'cursor',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => successResponse);
-
-        await feedProvider.retry();
-
-        expect(feedProvider.error, null);
-        expect(feedProvider.posts.length, 1);
-      });
-    });
-
-    group('State Management', () {
-      test('should notify listeners on state change', () async {
-        var notificationCount = 0;
-        feedProvider.addListener(() {
-          notificationCount++;
-        });
-
-        final mockResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'cursor',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => mockResponse);
-
-        await feedProvider.fetchTimeline(refresh: true);
-
-        expect(notificationCount, greaterThan(0));
-      });
-
-      test('should manage loading states correctly', () async {
-        final mockResponse = TimelineResponse(
-          feed: [_createMockPost()],
-          cursor: 'cursor',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async {
-          await Future.delayed(const Duration(milliseconds: 100));
-          return mockResponse;
-        });
-
-        final loadFuture = feedProvider.fetchTimeline(refresh: true);
-
-        // Should be loading
-        expect(feedProvider.isLoading, true);
-
-        await loadFuture;
-
-        // Should not be loading anymore
-        expect(feedProvider.isLoading, false);
-      });
-    });
-
-    group('Vote state initialization from viewer data', () {
-      late MockVoteProvider mockVoteProvider;
-      late FeedProvider feedProviderWithVotes;
-
-      setUp(() {
-        mockVoteProvider = MockVoteProvider();
-        feedProviderWithVotes = FeedProvider(
-          mockAuthProvider,
-          apiService: mockApiService,
-          voteProvider: mockVoteProvider,
-        );
-      });
-
-      tearDown(() {
-        feedProviderWithVotes.dispose();
-      });
-
-      test('should initialize vote state when viewer.vote is "up"', () async {
-        when(mockAuthProvider.isAuthenticated).thenReturn(true);
-
-        final mockResponse = TimelineResponse(
-          feed: [
-            _createMockPostWithViewer(
-              uri: 'at://did:plc:test/social.coves.post.record/1',
-              vote: 'up',
-              voteUri: 'at://did:plc:test/social.coves.feed.vote/vote1',
-            ),
-          ],
-          cursor: 'cursor',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => mockResponse);
-
-        await feedProviderWithVotes.fetchTimeline(refresh: true);
-
-        verify(
-          mockVoteProvider.setInitialVoteState(
-            postUri: 'at://did:plc:test/social.coves.post.record/1',
-            voteDirection: 'up',
-            voteUri: 'at://did:plc:test/social.coves.feed.vote/vote1',
-          ),
-        ).called(1);
-      });
-
-      test('should initialize vote state when viewer.vote is "down"', () async {
-        when(mockAuthProvider.isAuthenticated).thenReturn(true);
-
-        final mockResponse = TimelineResponse(
-          feed: [
-            _createMockPostWithViewer(
-              uri: 'at://did:plc:test/social.coves.post.record/1',
-              vote: 'down',
-              voteUri: 'at://did:plc:test/social.coves.feed.vote/vote1',
-            ),
-          ],
-          cursor: 'cursor',
-        );
-
-        when(
-          mockApiService.getTimeline(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => mockResponse);
-
-        await feedProviderWithVotes.fetchTimeline(refresh: true);
-
-        verify(
-          mockVoteProvider.setInitialVoteState(
-            postUri: 'at://did:plc:test/social.coves.post.record/1',
-            voteDirection: 'down',
-            voteUri: 'at://did:plc:test/social.coves.feed.vote/vote1',
-          ),
-        ).called(1);
-      });
-
-      test(
-        'should clear stale vote state when viewer.vote is null on refresh',
-        () async {
-          when(mockAuthProvider.isAuthenticated).thenReturn(true);
-
-          // Feed item with null vote (user removed vote on another device)
-          final mockResponse = TimelineResponse(
-            feed: [
-              _createMockPostWithViewer(
-                uri: 'at://did:plc:test/social.coves.post.record/1',
-                vote: null,
-                voteUri: null,
-              ),
-            ],
-            cursor: 'cursor',
-          );
-
-          when(
-            mockApiService.getTimeline(
-              sort: anyNamed('sort'),
-              timeframe: anyNamed('timeframe'),
-              limit: anyNamed('limit'),
-              cursor: anyNamed('cursor'),
-            ),
-          ).thenAnswer((_) async => mockResponse);
-
-          await feedProviderWithVotes.fetchTimeline(refresh: true);
-
-          // Should call setInitialVoteState with null to clear stale state
-          verify(
-            mockVoteProvider.setInitialVoteState(
-              postUri: 'at://did:plc:test/social.coves.post.record/1',
-              voteDirection: null,
-              voteUri: null,
-            ),
-          ).called(1);
-        },
-      );
-
-      test(
-        'should initialize vote state for all feed items including no viewer',
-        () async {
-          when(mockAuthProvider.isAuthenticated).thenReturn(true);
-
-          final mockResponse = TimelineResponse(
-            feed: [
-              _createMockPostWithViewer(
-                uri: 'at://did:plc:test/social.coves.post.record/1',
-                vote: 'up',
-                voteUri: 'at://did:plc:test/social.coves.feed.vote/vote1',
-              ),
-              _createMockPost(), // No viewer state
-            ],
-            cursor: 'cursor',
-          );
-
-          when(
-            mockApiService.getTimeline(
-              sort: anyNamed('sort'),
-              timeframe: anyNamed('timeframe'),
-              limit: anyNamed('limit'),
-              cursor: anyNamed('cursor'),
-            ),
-          ).thenAnswer((_) async => mockResponse);
-
-          await feedProviderWithVotes.fetchTimeline(refresh: true);
-
-          // Should be called for both posts
-          verify(
-            mockVoteProvider.setInitialVoteState(
-              postUri: anyNamed('postUri'),
-              voteDirection: anyNamed('voteDirection'),
-              voteUri: anyNamed('voteUri'),
-            ),
-          ).called(2);
-        },
-      );
-
-      test('should not initialize vote state when not authenticated', () async {
-        when(mockAuthProvider.isAuthenticated).thenReturn(false);
-
-        final mockResponse = TimelineResponse(
-          feed: [
-            _createMockPostWithViewer(
-              uri: 'at://did:plc:test/social.coves.post.record/1',
-              vote: 'up',
-              voteUri: 'at://did:plc:test/social.coves.feed.vote/vote1',
-            ),
-          ],
-          cursor: 'cursor',
-        );
-
-        when(
-          mockApiService.getDiscover(
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => mockResponse);
-
-        await feedProviderWithVotes.fetchDiscover(refresh: true);
-
-        // Should NOT call setInitialVoteState when not authenticated
-        verifyNever(
-          mockVoteProvider.setInitialVoteState(
-            postUri: anyNamed('postUri'),
-            voteDirection: anyNamed('voteDirection'),
-            voteUri: anyNamed('voteUri'),
-          ),
-        );
-      });
-    });
-  });
-}
-
-// Helper function to create mock posts
-FeedViewPost _createMockPost() {
-  return FeedViewPost(
-    post: PostView(
-      uri: 'at://did:plc:test/app.bsky.feed.post/test',
-      cid: 'test-cid',
-      rkey: 'test-rkey',
-      author: AuthorView(
-        did: 'did:plc:author',
-        handle: 'test.user',
-        displayName: 'Test User',
-      ),
-      community: CommunityRef(did: 'did:plc:community', name: 'test-community'),
-      createdAt: DateTime.parse('2025-01-01T12:00:00Z'),
-      indexedAt: DateTime.parse('2025-01-01T12:00:00Z'),
-      text: 'Test body',
-      title: 'Test Post',
-      stats: PostStats(score: 42, upvotes: 50, downvotes: 8, commentCount: 5),
-      facets: [],
-    ),
-  );
-}
-
-// Helper function to create mock posts with viewer state
-FeedViewPost _createMockPostWithViewer({
-  required String uri,
-  String? vote,
-  String? voteUri,
-}) {
-  return FeedViewPost(
-    post: PostView(
-      uri: uri,
-      cid: 'test-cid',
-      rkey: 'test-rkey',
-      author: AuthorView(
-        did: 'did:plc:author',
-        handle: 'test.user',
-        displayName: 'Test User',
-      ),
-      community: CommunityRef(did: 'did:plc:community', name: 'test-community'),
-      createdAt: DateTime.parse('2025-01-01T12:00:00Z'),
-      indexedAt: DateTime.parse('2025-01-01T12:00:00Z'),
-      text: 'Test body',
-      title: 'Test Post',
-      stats: PostStats(score: 42, upvotes: 50, downvotes: 8, commentCount: 5),
-      facets: [],
-      viewer: ViewerState(vote: vote, voteUri: voteUri),
-    ),
-  );
-}

test/widget_test.dart

···
 import 'package:coves_flutter/main.dart';
 import 'package:coves_flutter/providers/auth_provider.dart';
-import 'package:coves_flutter/providers/feed_provider.dart';
+import 'package:coves_flutter/providers/multi_feed_provider.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:provider/provider.dart';
···
       MultiProvider(
         providers: [
           ChangeNotifierProvider.value(value: authProvider),
-          ChangeNotifierProvider(create: (_) => FeedProvider(authProvider)),
+          ChangeNotifierProvider(
+            create: (_) => MultiFeedProvider(authProvider),
+          ),
         ],
         child: const CovesApp(),
       ),

test/widgets/feed_screen_test.dart

···
+import 'package:coves_flutter/models/feed_state.dart';
 import 'package:coves_flutter/models/post.dart';
 import 'package:coves_flutter/providers/auth_provider.dart';
-import 'package:coves_flutter/providers/feed_provider.dart';
+import 'package:coves_flutter/providers/multi_feed_provider.dart';
 import 'package:coves_flutter/providers/vote_provider.dart';
 import 'package:coves_flutter/screens/home/feed_screen.dart';
 import 'package:coves_flutter/services/vote_service.dart';
···
   }
 }
 
-// Fake FeedProvider for testing
-class FakeFeedProvider extends FeedProvider {
-  FakeFeedProvider() : super(FakeAuthProvider());
+// Fake MultiFeedProvider for testing
+class FakeMultiFeedProvider extends MultiFeedProvider {
+  FakeMultiFeedProvider() : super(FakeAuthProvider());
 
-  List<FeedViewPost> _posts = [];
-  bool _isLoading = false;
-  bool _isLoadingMore = false;
-  String? _error;
-  bool _hasMore = true;
+  final Map<FeedType, FeedState> _states = {
+    FeedType.discover: FeedState.initial(),
+    FeedType.forYou: FeedState.initial(),
+  };
+
   int _loadFeedCallCount = 0;
   int _retryCallCount = 0;
 
-  @override
-  List<FeedViewPost> get posts => _posts;
-
-  @override
-  bool get isLoading => _isLoading;
-
-  @override
-  bool get isLoadingMore => _isLoadingMore;
-
-  @override
-  String? get error => _error;
+  int get loadFeedCallCount => _loadFeedCallCount;
+  int get retryCallCount => _retryCallCount;
 
   @override
-  bool get hasMore => _hasMore;
+  FeedState getState(FeedType type) => _states[type] ?? FeedState.initial();
 
-  int get loadFeedCallCount => _loadFeedCallCount;
-  int get retryCallCount => _retryCallCount;
+  void setStateForType(FeedType type, FeedState state) {
+    _states[type] = state;
+    notifyListeners();
+  }
 
-  void setPosts(List<FeedViewPost> value) {
-    _posts = value;
+  void setPosts(FeedType type, List<FeedViewPost> posts) {
+    _states[type] = _states[type]!.copyWith(posts: posts);
     notifyListeners();
   }
 
-  void setLoading({required bool value}) {
-    _isLoading = value;
+  void setLoading(FeedType type, {required bool value}) {
+    _states[type] = _states[type]!.copyWith(isLoading: value);
     notifyListeners();
   }
 
-  void setLoadingMore({required bool value}) {
-    _isLoadingMore = value;
+  void setLoadingMore(FeedType type, {required bool value}) {
+    _states[type] = _states[type]!.copyWith(isLoadingMore: value);
     notifyListeners();
   }
 
-  void setError(String? value) {
-    _error = value;
+  void setError(FeedType type, String? value) {
+    _states[type] = _states[type]!.copyWith(error: value);
     notifyListeners();
   }
 
-  void setHasMore({required bool value}) {
-    _hasMore = value;
+  void setHasMore(FeedType type, {required bool value}) {
+    _states[type] = _states[type]!.copyWith(hasMore: value);
     notifyListeners();
   }
 
   @override
-  Future<void> loadFeed({bool refresh = false}) async {
+  Future<void> loadFeed(FeedType type, {bool refresh = false}) async {
     _loadFeedCallCount++;
   }
 
   @override
-  Future<void> retry() async {
+  Future<void> retry(FeedType type) async {
     _retryCallCount++;
   }
 
   @override
-  Future<void> loadMore() async {
+  Future<void> loadMore(FeedType type) async {
+    // No-op for testing
+  }
+
+  @override
+  void saveScrollPosition(FeedType type, double position) {
     // No-op for testing
   }
 }
···
 void main() {
   group('FeedScreen Widget Tests', () {
     late FakeAuthProvider fakeAuthProvider;
-    late FakeFeedProvider fakeFeedProvider;
+    late FakeMultiFeedProvider fakeFeedProvider;
     late FakeVoteProvider fakeVoteProvider;
 
     setUp(() {
       fakeAuthProvider = FakeAuthProvider();
-      fakeFeedProvider = FakeFeedProvider();
+      fakeFeedProvider = FakeMultiFeedProvider();
       fakeVoteProvider = FakeVoteProvider();
     });
 
···
       return MultiProvider(
         providers: [
           ChangeNotifierProvider<AuthProvider>.value(value: fakeAuthProvider),
-          ChangeNotifierProvider<FeedProvider>.value(value: fakeFeedProvider),
+          ChangeNotifierProvider<MultiFeedProvider>.value(
+            value: fakeFeedProvider,
+          ),
           ChangeNotifierProvider<VoteProvider>.value(value: fakeVoteProvider),
         ],
         child: const MaterialApp(home: FeedScreen()),
···
     testWidgets('should display loading indicator when loading', (
       tester,
     ) async {
-      fakeFeedProvider.setLoading(value: true);
+      fakeFeedProvider.setLoading(FeedType.discover, value: true);
 
       await tester.pumpWidget(createTestWidget());
 
···
     });
 
     testWidgets('should display error state with retry button', (tester) async {
-      fakeFeedProvider.setError('Network error');
+      fakeFeedProvider.setError(FeedType.discover, 'Network error');
 
       await tester.pumpWidget(createTestWidget());
 
···
     });
 
     testWidgets('should display empty state when no posts', (tester) async {
-      fakeFeedProvider.setPosts([]);
+      fakeFeedProvider.setPosts(FeedType.discover, []);
       fakeAuthProvider.setAuthenticated(value: false);
 
       await tester.pumpWidget(createTestWidget());
···
     testWidgets('should display different empty state when authenticated', (
       tester,
     ) async {
-      fakeFeedProvider.setPosts([]);
+      fakeFeedProvider.setPosts(FeedType.discover, []);
       fakeAuthProvider.setAuthenticated(value: true);
 
       await tester.pumpWidget(createTestWidget());
···
         _createMockPost('Test Post 2'),
       ];
 
-      fakeFeedProvider.setPosts(mockPosts);
+      fakeFeedProvider.setPosts(FeedType.discover, mockPosts);
 
       await tester.pumpWidget(createTestWidget());
 
···
 
     testWidgets('should handle pull-to-refresh', (tester) async {
       final mockPosts = [_createMockPost('Test Post')];
-      fakeFeedProvider.setPosts(mockPosts);
+      fakeFeedProvider.setPosts(FeedType.discover, mockPosts);
 
       await tester.pumpWidget(createTestWidget());
       await tester.pumpAndSettle();
···
       // Verify RefreshIndicator exists
       expect(find.byType(RefreshIndicator), findsOneWidget);
 
-      // The loadFeed is called once on init
-      expect(fakeFeedProvider.loadFeedCallCount, 1);
+      // loadFeed is called once for initial load (or twice if authenticated)
+      expect(fakeFeedProvider.loadFeedCallCount, greaterThanOrEqualTo(1));
     });
 
     testWidgets('should show loading indicator at bottom when loading more', (
···
     ) async {
       final mockPosts = [_createMockPost('Test Post')];
       fakeFeedProvider
-        ..setPosts(mockPosts)
-        ..setLoadingMore(value: true);
+        ..setPosts(FeedType.discover, mockPosts)
+        ..setLoadingMore(FeedType.discover, value: true);
 
       await tester.pumpWidget(createTestWidget());
 
···
         ),
       );
 
-      fakeFeedProvider.setPosts([mockPost]);
+      fakeFeedProvider.setPosts(FeedType.discover, [mockPost]);
 
       await tester.pumpWidget(createTestWidget());
 
···
 
     testWidgets('should display community and author info', (tester) async {
       final mockPost = _createMockPost('Test Post');
-      fakeFeedProvider.setPosts([mockPost]);
+      fakeFeedProvider.setPosts(FeedType.discover, [mockPost]);
 
       await tester.pumpWidget(createTestWidget());
 
-      // Check for community handle parts (displayed as ![e-mail])
+      // Check for community handle parts (displayed as !test-community@...)
       expect(find.textContaining('!test-community'), findsOneWidget);
       expect(find.text('@test.user'), findsOneWidget);
     });
···
       await tester.pumpWidget(createTestWidget());
       await tester.pumpAndSettle();
 
-      expect(fakeFeedProvider.loadFeedCallCount, 1);
+      expect(fakeFeedProvider.loadFeedCallCount, greaterThanOrEqualTo(1));
     });
 
     testWidgets('should have proper accessibility semantics', (tester) async {
       final mockPost = _createMockPost('Accessible Post');
-      fakeFeedProvider.setPosts([mockPost]);
+      fakeFeedProvider.setPosts(FeedType.discover, [mockPost]);
 
       await tester.pumpWidget(createTestWidget());
       await tester.pumpAndSettle();
···
 
       // Verify post card exists (which contains Semantics wrapper)
       expect(find.text('Accessible Post'), findsOneWidget);
-      // Check for community handle parts (displayed as ![e-mail])
+      // Check for community handle parts
       expect(find.textContaining('!test-community'), findsOneWidget);
       expect(find.textContaining('@coves.social'), findsOneWidget);
     });
···
 
       // If we get here without errors, dispose was called properly
       expect(true, true);
+    });
+
+    testWidgets('should support swipe navigation when authenticated', (
+      tester,
+    ) async {
+      fakeAuthProvider.setAuthenticated(value: true);
+      fakeFeedProvider
+        ..setPosts(FeedType.discover, [_createMockPost('Post 1')])
+        ..setPosts(FeedType.forYou, [_createMockPost('Post 2')]);
+
+      await tester.pumpWidget(createTestWidget());
+      await tester.pumpAndSettle();
+
+      // PageView should exist for authenticated users
+      expect(find.byType(PageView), findsOneWidget);
+    });
+
+    testWidgets('should not have PageView when not authenticated', (
+      tester,
+    ) async {
+      fakeAuthProvider.setAuthenticated(value: false);
+      fakeFeedProvider.setPosts(FeedType.discover, [_createMockPost('Post 1')]);
+
+      await tester.pumpWidget(createTestWidget());
+      await tester.pumpAndSettle();
+
+      // PageView should not exist for unauthenticated users
+      expect(find.byType(PageView), findsNothing);
     });
   });
 }