Merge branch 'feat/comments-provider-cache'

Add per-post CommentsProvider caching with LRU eviction for instant
back-navigation, scroll position restoration, and draft text preservation.

lib/main.dart

···
 import 'constants/app_colors.dart';
 import 'models/post.dart';
 import 'providers/auth_provider.dart';
-import 'providers/comments_provider.dart';
 import 'providers/feed_provider.dart';
 import 'providers/vote_provider.dart';
 import 'screens/auth/login_screen.dart';
···
 import 'screens/home/post_detail_screen.dart';
 import 'screens/landing_screen.dart';
 import 'services/comment_service.dart';
+import 'services/comments_provider_cache.dart';
 import 'services/streamable_service.dart';
 import 'services/vote_service.dart';
 import 'widgets/loading_error_states.dart';
···
             return previous ?? FeedProvider(auth, voteProvider: vote);
           },
         ),
-        ChangeNotifierProxyProvider2<
-          AuthProvider,
-          VoteProvider,
-          CommentsProvider
-        >(
-          create:
-              (context) => CommentsProvider(
-                authProvider,
-                voteProvider: context.read<VoteProvider>(),
-                commentService: commentService,
-              ),
+        // 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,
+          ),
           update: (context, auth, vote, previous) {
-            // Reuse existing provider to maintain state across rebuilds
-            return previous ??
-                CommentsProvider(
-                  auth,
-                  voteProvider: vote,
-                  commentService: commentService,
-                );
+            // Reuse existing cache
+            return previous ?? CommentsProviderCache(
+              authProvider: auth,
+              voteProvider: vote,
+              commentService: commentService,
+            );
           },
+          dispose: (_, cache) => cache.dispose(),
         ),
         // StreamableService for video embeds
         Provider<StreamableService>(create: (_) => StreamableService()),

lib/providers/comments_provider.dart

···
 /// Comments Provider
 ///
 /// Manages comment state and fetching logic for a specific post.
-/// Supports sorting (hot/top/new), pagination, and vote integration.
+/// Each provider instance is bound to a single post (immutable postUri/postCid).
+/// Supports sorting (hot/top/new), pagination, vote integration, scroll position,
+/// and draft text preservation.
+///
+/// IMPORTANT: Provider instances are managed by CommentsProviderCache which
+/// handles LRU eviction and sign-out cleanup. Do not create directly in widgets.
 ///
 /// IMPORTANT: Accepts AuthProvider reference to fetch fresh access
 /// tokens before each authenticated request (critical for atProto OAuth
···
 class CommentsProvider with ChangeNotifier {
   CommentsProvider(
     this._authProvider, {
+    required String postUri,
+    required String postCid,
     CovesApiService? apiService,
     VoteProvider? voteProvider,
     CommentService? commentService,
-  }) : _voteProvider = voteProvider,
+  }) : _postUri = postUri,
+       _postCid = postCid,
+       _voteProvider = voteProvider,
        _commentService = commentService {
     // Use injected service (for testing) or create new one (for production)
     // Pass token getter, refresh handler, and sign out handler to API service
···
           tokenRefresher: _authProvider.refreshToken,
           signOutHandler: _authProvider.signOut,
         );
-
-    // Track initial auth state
-    _wasAuthenticated = _authProvider.isAuthenticated;
-
-    // Listen to auth state changes and clear comments on sign-out
-    _authProvider.addListener(_onAuthChanged);
   }
 
   /// Maximum comment length in characters (matches backend limit)
   /// Note: This counts Unicode grapheme clusters, so emojis count correctly
   static const int maxCommentLength = 10000;
 
-  /// Handle authentication state changes
-  ///
-  /// Clears comment state when user signs out to prevent privacy issues.
-  void _onAuthChanged() {
-    final isAuthenticated = _authProvider.isAuthenticated;
-
-    // Only clear if transitioning from authenticated → unauthenticated
-    if (_wasAuthenticated && !isAuthenticated && _comments.isNotEmpty) {
-      if (kDebugMode) {
-        debugPrint('🔒 User signed out - clearing comments');
-      }
-      reset();
-    }
-
-    // Update tracked state
-    _wasAuthenticated = isAuthenticated;
-  }
+  /// Default staleness threshold for background refresh
+  static const Duration stalenessThreshold = Duration(minutes: 5);
 
   final AuthProvider _authProvider;
   late final CovesApiService _apiService;
   final VoteProvider? _voteProvider;
   final CommentService? _commentService;
 
-  // Track previous auth state to detect transitions
-  bool _wasAuthenticated = false;
+  // Post context - immutable per provider instance
+  final String _postUri;
+  final String _postCid;
 
   // Comment state
   List<ThreadViewComment> _comments = [];
···
   // Collapsed thread state - stores URIs of collapsed comments
   final Set<String> _collapsedComments = {};
 
-  // Current post being viewed
-  String? _postUri;
-  String? _postCid;
+  // Scroll position state (replaces ScrollStateService for this post)
+  double _scrollPosition = 0;
+
+  // Draft reply text - stored per-parent-URI (null key = top-level reply to post)
+  // This allows users to have separate drafts for different comments within the same post
+  final Map<String?, String> _drafts = {};
+
+  // Staleness tracking for background refresh
+  DateTime? _lastRefreshTime;
 
   // Comment configuration
   String _sort = 'hot';
···
   Timer? _timeUpdateTimer;
   final ValueNotifier<DateTime?> _currentTimeNotifier = ValueNotifier(null);
 
+  bool _isDisposed = false;
+
+  void _safeNotifyListeners() {
+    if (_isDisposed) return;
+    notifyListeners();
+  }
+
   // Getters
+  String get postUri => _postUri;
+  String get postCid => _postCid;
   List<ThreadViewComment> get comments => _comments;
   bool get isLoading => _isLoading;
   bool get isLoadingMore => _isLoadingMore;
···
   String? get timeframe => _timeframe;
   ValueNotifier<DateTime?> get currentTimeNotifier => _currentTimeNotifier;
   Set<String> get collapsedComments => Set.unmodifiable(_collapsedComments);
+  double get scrollPosition => _scrollPosition;
+  DateTime? get lastRefreshTime => _lastRefreshTime;
+
+  /// Get draft text for a specific parent URI
+  ///
+  /// [parentUri] - URI of parent comment (null for top-level post reply)
+  /// Returns the draft text, or empty string if no draft exists
+  String getDraft({String? parentUri}) => _drafts[parentUri] ?? '';
+
+  /// Legacy getters for backward compatibility
+  /// @deprecated Use getDraft(parentUri: ...) instead
+  String get draftText => _drafts.values.firstOrNull ?? '';
+  String? get draftParentUri => _drafts.keys.firstOrNull;
+
+  /// Check if cached data is stale and should be refreshed in background
+  bool get isStale {
+    if (_lastRefreshTime == null) {
+      return true;
+    }
+    return DateTime.now().difference(_lastRefreshTime!) > stalenessThreshold;
+  }
+
+  /// Save scroll position (called on every scroll event)
+  void saveScrollPosition(double position) {
+    _scrollPosition = position;
+    // No notifyListeners - this is passive state save
+  }
+
+  /// Save draft reply text
+  ///
+  /// [text] - The draft text content
+  /// [parentUri] - URI of parent comment (null for top-level post reply)
+  ///
+  /// Each parent URI gets its own draft, so switching between replies
+  /// preserves drafts for each context.
+  void saveDraft(String text, {String? parentUri}) {
+    if (text.trim().isEmpty) {
+      // Remove empty drafts to avoid clutter
+      _drafts.remove(parentUri);
+    } else {
+      _drafts[parentUri] = text;
+    }
+    // No notifyListeners - this is passive state save
+  }
+
+  /// Clear draft text for a specific parent (call after successful submission)
+  ///
+  /// [parentUri] - URI of parent comment (null for top-level post reply)
+  void clearDraft({String? parentUri}) {
+    _drafts.remove(parentUri);
+  }
 
   /// Toggle collapsed state for a comment thread
   ///
···
     } else {
       _collapsedComments.add(uri);
     }
-    notifyListeners();
+    _safeNotifyListeners();
   }
 
   /// Check if a specific comment is collapsed
···
     }
   }
 
-  /// Load comments for a specific post
+  /// Load comments for this provider's post
   ///
   /// Parameters:
-  /// - [postUri]: AT-URI of the post
-  /// - [postCid]: CID of the post (needed for creating comments)
-  /// - [refresh]: Whether to refresh from the beginning
-  Future<void> loadComments({
-    required String postUri,
-    required String postCid,
-    bool refresh = false,
-  }) async {
-    // If loading for a different post, reset state
-    if (postUri != _postUri) {
-      reset();
-      _postUri = postUri;
-      _postCid = postCid;
-    }
-
+  /// - [refresh]: Whether to refresh from the beginning (true) or paginate (false)
+  Future<void> loadComments({bool refresh = false}) async {
     // If already loading, schedule a refresh to happen after current load
     if (_isLoading || _isLoadingMore) {
       if (refresh) {
···
       } else {
         _isLoadingMore = true;
       }
-      notifyListeners();
+      _safeNotifyListeners();
 
       if (kDebugMode) {
-        debugPrint('📡 Fetching comments: sort=$_sort, postUri=$postUri');
+        debugPrint('📡 Fetching comments: sort=$_sort, postUri=$_postUri');
       }
 
       final response = await _apiService.getComments(
-        postUri: postUri,
+        postUri: _postUri,
         sort: _sort,
         timeframe: _timeframe,
         cursor: refresh ? null : _cursor,
       );
 
+      if (_isDisposed) return;
+
       // Only update state after successful fetch
       if (refresh) {
         _comments = response.comments;
+        _lastRefreshTime = DateTime.now();
       } else {
         // Create new list instance to trigger rebuilds
         _comments = [..._comments, ...response.comments];
···
         startTimeUpdates();
       }
     } on Exception catch (e) {
+      if (_isDisposed) return;
       _error = e.toString();
       if (kDebugMode) {
         debugPrint('❌ Failed to fetch comments: $e');
       }
     } finally {
+      if (_isDisposed) return;
       _isLoading = false;
       _isLoadingMore = false;
-      notifyListeners();
+      _safeNotifyListeners();
 
       // If a refresh was scheduled during this load, execute it now
-      if (_pendingRefresh && _postUri != null) {
+      if (_pendingRefresh) {
         if (kDebugMode) {
           debugPrint('🔄 Executing pending refresh');
         }
         _pendingRefresh = false;
         // Schedule refresh without awaiting to avoid blocking
         // This is intentional - we want the refresh to happen asynchronously
-        unawaited(
-          loadComments(postUri: _postUri!, postCid: _postCid!, refresh: true),
-        );
+        unawaited(loadComments(refresh: true));
       }
     }
   }
···
   ///
   /// Reloads comments from the beginning for the current post.
   Future<void> refreshComments() async {
-    if (_postUri == null || _postCid == null) {
-      if (kDebugMode) {
-        debugPrint('⚠️ Cannot refresh - no post loaded');
-      }
-      return;
-    }
-    await loadComments(postUri: _postUri!, postCid: _postCid!, refresh: true);
+    await loadComments(refresh: true);
   }
 
   /// Load more comments (pagination)
   Future<void> loadMoreComments() async {
-    if (!_hasMore || _isLoadingMore || _postUri == null || _postCid == null) {
+    if (!_hasMore || _isLoadingMore) {
       return;
     }
-    await loadComments(postUri: _postUri!, postCid: _postCid!);
+    await loadComments();
   }
 
   /// Change sort order
···
 
     final previousSort = _sort;
     _sort = newSort;
-    notifyListeners();
+    _safeNotifyListeners();
 
     // Reload comments with new sort
-    if (_postUri != null && _postCid != null) {
-      try {
-        await loadComments(
-          postUri: _postUri!,
-          postCid: _postCid!,
-          refresh: true,
-        );
-        return true;
-      } on Exception catch (e) {
-        // Revert to previous sort option on failure
-        _sort = previousSort;
-        notifyListeners();
+    try {
+      await loadComments(refresh: true);
+      return true;
+    } on Exception catch (e) {
+      if (_isDisposed) return false;
+      // Revert to previous sort option on failure
+      _sort = previousSort;
+      _safeNotifyListeners();
 
-        if (kDebugMode) {
-          debugPrint('Failed to apply sort option: $e');
-        }
-
-        return false;
+      if (kDebugMode) {
+        debugPrint('Failed to apply sort option: $e');
       }
-    }
 
-    return true;
+      return false;
+    }
   }
 
   /// Vote on a comment
···
 
     if (_commentService == null) {
       throw ApiException('CommentService not available');
-    }
-
-    if (_postUri == null || _postCid == null) {
-      throw ApiException('No post loaded - cannot create comment');
     }
 
     // Root is always the original post
-    final rootUri = _postUri!;
-    final rootCid = _postCid!;
+    final rootUri = _postUri;
+    final rootCid = _postCid;
 
     // Parent depends on whether this is a top-level or nested reply
     final String parentUri;
···
   /// Retry loading after error
   Future<void> retry() async {
     _error = null;
-    if (_postUri != null && _postCid != null) {
-      await loadComments(postUri: _postUri!, postCid: _postCid!, refresh: true);
-    }
+    await loadComments(refresh: true);
   }
 
   /// Clear error
   void clearError() {
     _error = null;
-    notifyListeners();
-  }
-
-  /// Reset comment state
-  void reset() {
-    _comments = [];
-    _cursor = null;
-    _hasMore = true;
-    _error = null;
-    _isLoading = false;
-    _isLoadingMore = false;
-    _postUri = null;
-    _postCid = null;
-    _pendingRefresh = false;
-    _collapsedComments.clear();
-    notifyListeners();
+    _safeNotifyListeners();
   }
 
   @override
   void dispose() {
+    _isDisposed = true;
     // Stop time updates and cancel timer (also sets value to null)
     stopTimeUpdates();
-    // Remove auth listener to prevent memory leaks
-    _authProvider.removeListener(_onAuthChanged);
+    // Dispose API service
     _apiService.dispose();
     // Dispose the ValueNotifier last
     _currentTimeNotifier.dispose();

lib/screens/compose/reply_screen.dart

···
 import 'dart:async';
 import 'dart:math' as math;
 
+import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:provider/provider.dart';
···
 import '../../constants/app_colors.dart';
 import '../../models/comment.dart';
 import '../../models/post.dart';
+import '../../providers/auth_provider.dart';
 import '../../providers/comments_provider.dart';
 import '../../widgets/comment_thread.dart';
 import '../../widgets/post_card.dart';
···
     this.post,
     this.comment,
     required this.onSubmit,
+    required this.commentsProvider,
     super.key,
   }) : assert(
          (post != null) != (comment != null),
···
   /// Callback when user submits reply
   final Future<void> Function(String content) onSubmit;
 
+  /// CommentsProvider for draft save/restore and time updates
+  final CommentsProvider commentsProvider;
+
   @override
   State<ReplyScreen> createState() => _ReplyScreenState();
 }
···
   bool _hasText = false;
   bool _isKeyboardOpening = false;
   bool _isSubmitting = false;
+  bool _authInvalidated = false;
   double _lastKeyboardHeight = 0;
   Timer? _bannerDismissTimer;
 
···
     _textController.addListener(_onTextChanged);
     _focusNode.addListener(_onFocusChanged);
 
-    // Autofocus with delay (Thunder approach - let screen render first)
-    Future.delayed(const Duration(milliseconds: 300), () {
+    // Restore draft and autofocus after frame is built
+    WidgetsBinding.instance.addPostFrameCallback((_) {
       if (mounted) {
-        _isKeyboardOpening = true;
-        _focusNode.requestFocus();
+        _setupAuthListener();
+        _restoreDraft();
+
+        // Autofocus with delay (Thunder approach - let screen render first)
+        Future.delayed(const Duration(milliseconds: 300), () {
+          if (mounted) {
+            _isKeyboardOpening = true;
+            _focusNode.requestFocus();
+          }
+        });
       }
     });
   }
 
+  void _setupAuthListener() {
+    try {
+      context.read<AuthProvider>().addListener(_onAuthChanged);
+    } on Exception {
+      // AuthProvider may not be available (e.g., tests)
+    }
+  }
+
+  void _onAuthChanged() {
+    if (!mounted || _authInvalidated) return;
+
+    try {
+      final authProvider = context.read<AuthProvider>();
+      if (!authProvider.isAuthenticated) {
+        _authInvalidated = true;
+        if (mounted) {
+          Navigator.of(context).pop();
+        }
+      }
+    } on Exception {
+      // AuthProvider may not be available
+    }
+  }
+
+  /// Restore draft text if available for this reply context
+  void _restoreDraft() {
+    try {
+      final commentsProvider = context.read<CommentsProvider>();
+      final ourParentUri = widget.comment?.comment.uri;
+
+      // Get draft for this specific parent URI
+      final draft = commentsProvider.getDraft(parentUri: ourParentUri);
+
+      if (draft.isNotEmpty) {
+        _textController.text = draft;
+        setState(() {
+          _hasText = true;
+        });
+      }
+    } on Exception catch (e) {
+      // CommentsProvider might not be available (e.g., during testing)
+      if (kDebugMode) {
+        debugPrint('📝 Draft not restored: $e');
+      }
+    }
+  }
+
   void _onFocusChanged() {
     // When text field gains focus, scroll to bottom as keyboard opens
     if (_focusNode.hasFocus) {
···
   @override
   void didChangeMetrics() {
     super.didChangeMetrics();
+    // Guard against being called after widget is deactivated
+    // (can happen during keyboard animation while navigating away)
+    if (!mounted) return;
+
     final keyboardHeight = View.of(context).viewInsets.bottom;
 
     // Detect keyboard closing and unfocus text field
···
   @override
   void dispose() {
     _bannerDismissTimer?.cancel();
+    try {
+      context.read<AuthProvider>().removeListener(_onAuthChanged);
+    } on Exception {
+      // AuthProvider may not be available
+    }
     WidgetsBinding.instance.removeObserver(this);
     _textController.dispose();
     _focusNode.dispose();
···
   }
 
   Future<void> _handleSubmit() async {
+    if (_authInvalidated) {
+      return;
+    }
+
     final content = _textController.text.trim();
     if (content.isEmpty) {
       return;
···
 
     try {
       await widget.onSubmit(content);
+      // Clear draft on success
+      try {
+        if (mounted) {
+          final parentUri = widget.comment?.comment.uri;
+          context.read<CommentsProvider>().clearDraft(parentUri: parentUri);
+        }
+      } on Exception catch (e) {
+        // CommentsProvider might not be available
+        if (kDebugMode) {
+          debugPrint('📝 Draft not cleared: $e');
+        }
+      }
       // Pop screen after successful submission
       if (mounted) {
         Navigator.of(context).pop();
···
   }
 
   void _handleCancel() {
+    // Save draft before closing (if text is not empty)
+    _saveDraft();
     Navigator.of(context).pop();
   }
 
+  /// Save current text as draft
+  void _saveDraft() {
+    try {
+      final commentsProvider = context.read<CommentsProvider>();
+      commentsProvider.saveDraft(
+        _textController.text,
+        parentUri: widget.comment?.comment.uri,
+      );
+    } on Exception catch (e) {
+      // CommentsProvider might not be available
+      if (kDebugMode) {
+        debugPrint('📝 Draft not saved: $e');
+      }
+    }
+  }
+
   @override
   Widget build(BuildContext context) {
-    return GestureDetector(
-      onTap: () {
-        // Dismiss keyboard when tapping outside
-        FocusManager.instance.primaryFocus?.unfocus();
-      },
-      child: Scaffold(
+    // Provide CommentsProvider to descendant widgets (Consumer in _ContextPreview)
+    return ChangeNotifierProvider.value(
+      value: widget.commentsProvider,
+      child: GestureDetector(
+        onTap: () {
+          // Dismiss keyboard when tapping outside
+          FocusManager.instance.primaryFocus?.unfocus();
+        },
+        child: Scaffold(
         backgroundColor: AppColors.background,
         resizeToAvoidBottomInset: false, // Thunder approach
         appBar: AppBar(
···
             ),
           ],
         ),
+      ),
       ),
     );
   }

lib/screens/home/focused_thread_screen.dart

···
 import '../../constants/app_colors.dart';
 import '../../models/comment.dart';
 import '../../providers/auth_provider.dart';
+import '../../providers/comments_provider.dart';
 import '../../widgets/comment_card.dart';
 import '../../widgets/comment_thread.dart';
 import '../../widgets/status_bar_overlay.dart';
···
 /// any collapsed state is reset. This is by design - it allows users to
 /// explore deep threads without their collapse choices persisting across
 /// navigation, keeping the focused view clean and predictable.
+///
+/// ## Provider Sharing
+/// Receives the parent's CommentsProvider for draft text preservation and
+/// consistent vote state display.
 class FocusedThreadScreen extends StatelessWidget {
   const FocusedThreadScreen({
     required this.thread,
     required this.ancestors,
     required this.onReply,
+    required this.commentsProvider,
     super.key,
   });
 
···
   /// Callback when user replies to a comment
   final Future<void> Function(String content, ThreadViewComment parent) onReply;
 
+  /// Parent's CommentsProvider for draft preservation and vote state
+  final CommentsProvider commentsProvider;
+
   @override
   Widget build(BuildContext context) {
-    return Scaffold(
-      backgroundColor: AppColors.background,
-      body: _FocusedThreadBody(
-        thread: thread,
-        ancestors: ancestors,
-        onReply: onReply,
+    // Expose parent's CommentsProvider for ReplyScreen draft access
+    return ChangeNotifierProvider.value(
+      value: commentsProvider,
+      child: Scaffold(
+        backgroundColor: AppColors.background,
+        body: _FocusedThreadBody(
+          thread: thread,
+          ancestors: ancestors,
+          onReply: onReply,
+        ),
       ),
     );
   }
···
 
     Navigator.of(context).push(
       MaterialPageRoute<void>(
-        builder: (context) => ReplyScreen(
+        builder: (navigatorContext) => ReplyScreen(
           comment: comment,
           onSubmit: (content) => widget.onReply(content, comment),
+          commentsProvider: context.read<CommentsProvider>(),
         ),
       ),
     );
···
   ) {
     Navigator.of(context).push(
       MaterialPageRoute<void>(
-        builder: (context) => FocusedThreadScreen(
+        builder: (navigatorContext) => FocusedThreadScreen(
           thread: thread,
           ancestors: ancestors,
           onReply: widget.onReply,
+          commentsProvider: context.read<CommentsProvider>(),
         ),
       ),
     );

lib/screens/home/post_detail_screen.dart

···
 import 'package:cached_network_image/cached_network_image.dart';
+import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:provider/provider.dart';
···
 import '../../providers/auth_provider.dart';
 import '../../providers/comments_provider.dart';
 import '../../providers/vote_provider.dart';
+import '../../services/comments_provider_cache.dart';
 import '../../utils/community_handle_utils.dart';
 import '../../utils/error_messages.dart';
 import '../../widgets/comment_thread.dart';
···
   final ScrollController _scrollController = ScrollController();
   final GlobalKey _commentsHeaderKey = GlobalKey();
 
-  // Current sort option
-  String _currentSort = 'hot';
+  // Cached provider from CommentsProviderCache
+  late CommentsProvider _commentsProvider;
+  CommentsProviderCache? _commentsCache;
+
+  // Track initialization state
+  bool _isInitialized = false;
+
+  // Track if provider has been invalidated (e.g., by sign-out)
+  bool _providerInvalidated = false;
 
   @override
   void initState() {
     super.initState();
-
-    // Initialize scroll controller for pagination
     _scrollController.addListener(_onScroll);
 
-    // Load comments after frame is built using provider from tree
+    // Initialize provider after frame is built
     WidgetsBinding.instance.addPostFrameCallback((_) {
       if (mounted) {
-        _loadComments();
+        _initializeProvider();
+        _setupAuthListener();
+      }
+    });
+  }
+
+  /// Listen for auth state changes to handle sign-out
+  void _setupAuthListener() {
+    final authProvider = context.read<AuthProvider>();
+    authProvider.addListener(_onAuthChanged);
+  }
+
+  /// Handle auth state changes (specifically sign-out)
+  void _onAuthChanged() {
+    if (!mounted) return;
+
+    final authProvider = context.read<AuthProvider>();
+
+    // If user signed out while viewing this screen, navigate back
+    // The CommentsProviderCache has already disposed our provider
+    if (!authProvider.isAuthenticated && _isInitialized && !_providerInvalidated) {
+      _providerInvalidated = true;
+
+      if (kDebugMode) {
+        debugPrint('🚪 User signed out - cleaning up PostDetailScreen');
+      }
+
+      // Remove listener from provider (it's disposed but this is safe)
+      try {
+        _commentsProvider.removeListener(_onProviderChanged);
+      } on Exception {
+        // Provider already disposed - expected
+      }
+
+      // Navigate back to feed
+      if (mounted) {
+        Navigator.of(context).popUntil((route) => route.isFirst);
+      }
+    }
+  }
+
+  /// Initialize provider from cache and restore state
+  void _initializeProvider() {
+    // Get or create provider from cache
+    final cache = context.read<CommentsProviderCache>();
+    _commentsCache = cache;
+    _commentsProvider = cache.acquireProvider(
+      postUri: widget.post.post.uri,
+      postCid: widget.post.post.cid,
+    );
+
+    // Listen for changes to trigger rebuilds
+    _commentsProvider.addListener(_onProviderChanged);
+
+    // Check if we already have cached data
+    if (_commentsProvider.comments.isNotEmpty) {
+      // Already have data - restore scroll position immediately
+      if (kDebugMode) {
+        debugPrint(
+          '📦 Using cached comments (${_commentsProvider.comments.length})',
+        );
+      }
+      _restoreScrollPosition();
+
+      // Background refresh if data is stale
+      if (_commentsProvider.isStale) {
+        if (kDebugMode) {
+          debugPrint('🔄 Data stale, refreshing in background');
+        }
+        _commentsProvider.loadComments(refresh: true);
       }
+    } else {
+      // No cached data - load fresh
+      _commentsProvider.loadComments(refresh: true);
+    }
+
+    setState(() {
+      _isInitialized = true;
     });
   }
 
   @override
   void dispose() {
+    // Remove auth listener
+    try {
+      context.read<AuthProvider>().removeListener(_onAuthChanged);
+    } on Exception {
+      // Context may not be valid during dispose
+    }
+
+    // Release provider pin in cache (prevents LRU eviction disposing an active
+    // provider while this screen is in the navigation stack).
+    if (_isInitialized) {
+      try {
+        _commentsCache?.releaseProvider(widget.post.post.uri);
+      } on Exception {
+        // Cache may already be disposed
+      }
+    }
+
+    // Remove provider listener if not already invalidated
+    if (_isInitialized && !_providerInvalidated) {
+      try {
+        _commentsProvider.removeListener(_onProviderChanged);
+      } on Exception {
+        // Provider may already be disposed
+      }
+    }
     _scrollController.dispose();
     super.dispose();
   }
 
-  /// Load comments for the current post
-  void _loadComments() {
-    context.read<CommentsProvider>().loadComments(
-      postUri: widget.post.post.uri,
-      postCid: widget.post.post.cid,
-      refresh: true,
-    );
+  /// Handle provider changes
+  void _onProviderChanged() {
+    if (mounted) {
+      setState(() {});
+    }
   }
 
-  /// Handle sort changes from dropdown
-  Future<void> _onSortChanged(String newSort) async {
-    final previousSort = _currentSort;
+  /// Restore scroll position from provider
+  void _restoreScrollPosition() {
+    final savedPosition = _commentsProvider.scrollPosition;
+    if (savedPosition <= 0) {
+      return;
+    }
+
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (!mounted || !_scrollController.hasClients) {
+        return;
+      }
 
-    setState(() {
-      _currentSort = newSort;
+      final maxExtent = _scrollController.position.maxScrollExtent;
+      final targetPosition = savedPosition.clamp(0.0, maxExtent);
+
+      if (targetPosition > 0) {
+        _scrollController.jumpTo(targetPosition);
+        if (kDebugMode) {
+          debugPrint('📍 Restored scroll to $targetPosition (max: $maxExtent)');
+        }
+      }
     });
+  }
 
-    final commentsProvider = context.read<CommentsProvider>();
-    final success = await commentsProvider.setSortOption(newSort);
+  /// Handle sort changes from dropdown
+  Future<void> _onSortChanged(String newSort) async {
+    final success = await _commentsProvider.setSortOption(newSort);
 
-    // Show error snackbar and revert UI if sort change failed
+    // Show error snackbar if sort change failed
     if (!success && mounted) {
-      setState(() {
-        _currentSort = previousSort;
-      });
-
       ScaffoldMessenger.of(context).showSnackBar(
         SnackBar(
           content: const Text('Failed to change sort order. Please try again.'),
···
 
   /// Handle scroll for pagination
   void _onScroll() {
+    // Don't interact with disposed provider
+    if (_providerInvalidated) return;
+
+    // Save scroll position to provider on every scroll event
+    if (_scrollController.hasClients) {
+      _commentsProvider.saveScrollPosition(_scrollController.position.pixels);
+    }
+
+    // Load more comments when near bottom
     if (_scrollController.position.pixels >=
         _scrollController.position.maxScrollExtent - 200) {
-      context.read<CommentsProvider>().loadMoreComments();
+      _commentsProvider.loadMoreComments();
     }
   }
 
   /// Handle pull-to-refresh
   Future<void> _onRefresh() async {
-    final commentsProvider = context.read<CommentsProvider>();
-    await commentsProvider.refreshComments();
+    // Don't interact with disposed provider
+    if (_providerInvalidated) return;
+
+    await _commentsProvider.refreshComments();
   }
 
   @override
   Widget build(BuildContext context) {
-    return Scaffold(
-      backgroundColor: AppColors.background,
-      body: _buildContent(),
-      bottomNavigationBar: _buildActionBar(),
+    // Show loading until provider is initialized
+    if (!_isInitialized) {
+      return const Scaffold(
+        backgroundColor: AppColors.background,
+        body: FullScreenLoading(),
+      );
+    }
+
+    // If provider was invalidated (sign-out), show loading while navigating away
+    if (_providerInvalidated) {
+      return const Scaffold(
+        backgroundColor: AppColors.background,
+        body: FullScreenLoading(),
+      );
+    }
+
+    // Provide the cached CommentsProvider to descendant widgets
+    return ChangeNotifierProvider.value(
+      value: _commentsProvider,
+      child: Scaffold(
+        backgroundColor: AppColors.background,
+        body: _buildContent(),
+        bottomNavigationBar: _buildActionBar(),
+      ),
     );
   }
 
···
     Navigator.of(context).push(
       MaterialPageRoute<void>(
         builder:
-            (context) =>
-                ReplyScreen(post: widget.post, onSubmit: _handleCommentSubmit),
+            (context) => ReplyScreen(
+              post: widget.post,
+              onSubmit: _handleCommentSubmit,
+              commentsProvider: _commentsProvider,
+            ),
       ),
     );
   }
 
   /// Handle comment submission (reply to post)
   Future<void> _handleCommentSubmit(String content) async {
-    final commentsProvider = context.read<CommentsProvider>();
     final messenger = ScaffoldMessenger.of(context);
 
     try {
-      await commentsProvider.createComment(content: content);
+      await _commentsProvider.createComment(content: content);
 
       if (mounted) {
         messenger.showSnackBar(
···
     String content,
     ThreadViewComment parentComment,
   ) async {
-    final commentsProvider = context.read<CommentsProvider>();
     final messenger = ScaffoldMessenger.of(context);
 
     try {
-      await commentsProvider.createComment(
+      await _commentsProvider.createComment(
         content: content,
         parentComment: parentComment,
       );
···
             (context) => ReplyScreen(
               comment: comment,
               onSubmit: (content) => _handleCommentReply(content, comment),
+              commentsProvider: _commentsProvider,
             ),
       ),
     );
···
   ) {
     Navigator.of(context).push(
       MaterialPageRoute<void>(
-        builder: (context) => FocusedThreadScreen(
-          thread: thread,
-          ancestors: ancestors,
-          onReply: _handleCommentReply,
-        ),
+        builder:
+            (context) => FocusedThreadScreen(
+              thread: thread,
+              ancestors: ancestors,
+              onReply: _handleCommentReply,
+              commentsProvider: _commentsProvider,
+            ),
       ),
     );
   }
···
                   SliverSafeArea(
                     top: false,
                     sliver: SliverList(
-                  delegate: SliverChildBuilderDelegate(
-                    (context, index) {
-                      // Post card (index 0)
-                      if (index == 0) {
-                        return Column(
-                          children: [
-                            // Reuse PostCard (hide comment button in
-                            // detail view)
-                            // Use ValueListenableBuilder to only rebuild
-                            // when time changes
-                            _PostHeader(
-                              post: widget.post,
-                              currentTimeNotifier:
-                                  commentsProvider.currentTimeNotifier,
-                            ),
+                      delegate: SliverChildBuilderDelegate(
+                        (context, index) {
+                          // Post card (index 0)
+                          if (index == 0) {
+                            return Column(
+                              children: [
+                                // Reuse PostCard (hide comment button in
+                                // detail view)
+                                // Use ValueListenableBuilder to only rebuild
+                                // when time changes
+                                _PostHeader(
+                                  post: widget.post,
+                                  currentTimeNotifier:
+                                      commentsProvider.currentTimeNotifier,
+                                ),
+
+                                // Visual divider before comments section
+                                Container(
+                                  margin: const EdgeInsets.symmetric(
+                                    vertical: 16,
+                                  ),
+                                  height: 1,
+                                  color: AppColors.border,
+                                ),
 
-                            // Visual divider before comments section
-                            Container(
-                              margin: const EdgeInsets.symmetric(vertical: 16),
-                              height: 1,
-                              color: AppColors.border,
-                            ),
+                                // Comments header with sort dropdown
+                                CommentsHeader(
+                                  key: _commentsHeaderKey,
+                                  commentCount: comments.length,
+                                  currentSort: commentsProvider.sort,
+                                  onSortChanged: _onSortChanged,
+                                ),
+                              ],
+                            );
+                          }
 
-                            // Comments header with sort dropdown
-                            CommentsHeader(
-                              key: _commentsHeaderKey,
-                              commentCount: comments.length,
-                              currentSort: _currentSort,
-                              onSortChanged: _onSortChanged,
-                            ),
-                          ],
-                        );
-                      }
+                          // Loading indicator or error at the end
+                          if (index == comments.length + 1) {
+                            if (isLoadingMore) {
+                              return const InlineLoading();
+                            }
+                            if (error != null) {
+                              return InlineError(
+                                message: ErrorMessages.getUserFriendly(error),
+                                onRetry: () {
+                                  commentsProvider
+                                    ..clearError()
+                                    ..loadMoreComments();
+                                },
+                              );
+                            }
+                          }
 
-                      // Loading indicator or error at the end
-                      if (index == comments.length + 1) {
-                        if (isLoadingMore) {
-                          return const InlineLoading();
-                        }
-                        if (error != null) {
-                          return InlineError(
-                            message: ErrorMessages.getUserFriendly(error),
-                            onRetry: () {
-                              commentsProvider
-                                ..clearError()
-                                ..loadMoreComments();
-                            },
+                          // Comment item - use existing CommentThread widget
+                          final comment = comments[index - 1];
+                          return _CommentItem(
+                            comment: comment,
+                            currentTimeNotifier:
+                                commentsProvider.currentTimeNotifier,
+                            onCommentTap: _openReplyToComment,
+                            collapsedComments:
+                                commentsProvider.collapsedComments,
+                            onCollapseToggle: commentsProvider.toggleCollapsed,
+                            onContinueThread: _onContinueThread,
                           );
-                        }
-                      }
-
-                      // Comment item - use existing CommentThread widget
-                      final comment = comments[index - 1];
-                      return _CommentItem(
-                        comment: comment,
-                        currentTimeNotifier:
-                            commentsProvider.currentTimeNotifier,
-                        onCommentTap: _openReplyToComment,
-                        collapsedComments: commentsProvider.collapsedComments,
-                        onCollapseToggle: commentsProvider.toggleCollapsed,
-                        onContinueThread: _onContinueThread,
-                      );
-                    },
-                    childCount:
-                        1 +
-                        comments.length +
-                        (isLoadingMore || error != null ? 1 : 0),
+                        },
+                        childCount:
+                            1 +
+                            comments.length +
+                            (isLoadingMore || error != null ? 1 : 0),
+                      ),
+                    ),
                   ),
-                ),
+                ],
               ),
-            ],
-          ),
-        ),
+            ),
             // Prevents content showing through transparent status bar
             const StatusBarOverlay(),
           ],
···
   final Set<String> collapsedComments;
   final void Function(String uri)? onCollapseToggle;
   final void Function(ThreadViewComment, List<ThreadViewComment>)?
-      onContinueThread;
+  onContinueThread;
 
   @override
   Widget build(BuildContext context) {

lib/services/comments_provider_cache.dart

···
+import 'dart:collection';
+
+import 'package:flutter/foundation.dart';
+import '../providers/auth_provider.dart';
+import '../providers/comments_provider.dart';
+import '../providers/vote_provider.dart';
+import 'comment_service.dart';
+
+/// Comments Provider Cache
+///
+/// Manages cached CommentsProvider instances per post URI using LRU eviction.
+/// Inspired by Thunder app's architecture for instant back navigation.
+///
+/// Key features:
+/// - One CommentsProvider per post URI
+/// - LRU eviction (default: 15 most recent posts)
+/// - Sign-out cleanup via AuthProvider listener
+///
+/// Usage:
+/// ```dart
+/// final cache = context.read<CommentsProviderCache>();
+/// final provider = cache.getProvider(
+///   postUri: post.uri,
+///   postCid: post.cid,
+/// );
+/// ```
+class CommentsProviderCache {
+  CommentsProviderCache({
+    required AuthProvider authProvider,
+    required VoteProvider voteProvider,
+    required CommentService commentService,
+    this.maxSize = 15,
+  }) : _authProvider = authProvider,
+       _voteProvider = voteProvider,
+       _commentService = commentService {
+    _wasAuthenticated = _authProvider.isAuthenticated;
+    _authProvider.addListener(_onAuthChanged);
+  }
+
+  final AuthProvider _authProvider;
+  final VoteProvider _voteProvider;
+  final CommentService _commentService;
+
+  /// Maximum number of providers to cache
+  final int maxSize;
+
+  /// LRU cache - LinkedHashMap maintains insertion order
+  /// Most recently accessed items are at the end
+  final LinkedHashMap<String, CommentsProvider> _cache = LinkedHashMap();
+
+  /// Reference counts for "in-use" providers.
+  ///
+  /// Screens that hold onto a provider instance should call [acquireProvider]
+  /// and later [releaseProvider] to prevent LRU eviction from disposing a
+  /// provider that is still mounted in the navigation stack.
+  final Map<String, int> _refCounts = {};
+
+  /// Track auth state for sign-out detection
+  bool _wasAuthenticated = false;
+
+  /// Acquire (get or create) a CommentsProvider for a post.
+  ///
+  /// This "pins" the provider to avoid LRU eviction while in use.
+  /// Call [releaseProvider] when the consumer unmounts.
+  ///
+  /// If provider exists in cache, moves it to end (LRU touch).
+  /// If cache is full, evicts the oldest *unreferenced* provider before
+  /// creating a new one. If all providers are currently referenced, the cache
+  /// may temporarily exceed [maxSize] to avoid disposing active providers.
+  CommentsProvider acquireProvider({
+    required String postUri,
+    required String postCid,
+  }) {
+    final provider = _getOrCreateProvider(postUri: postUri, postCid: postCid);
+    _refCounts[postUri] = (_refCounts[postUri] ?? 0) + 1;
+    return provider;
+  }
+
+  /// Release a previously acquired provider for a post.
+  ///
+  /// Once released, the provider becomes eligible for LRU eviction.
+  void releaseProvider(String postUri) {
+    final current = _refCounts[postUri];
+    if (current == null) {
+      return;
+    }
+
+    if (current <= 1) {
+      _refCounts.remove(postUri);
+    } else {
+      _refCounts[postUri] = current - 1;
+    }
+
+    _evictIfNeeded();
+  }
+
+  /// Legacy name kept for compatibility: prefer [acquireProvider].
+  CommentsProvider getProvider({
+    required String postUri,
+    required String postCid,
+  }) => acquireProvider(postUri: postUri, postCid: postCid);
+
+  CommentsProvider _getOrCreateProvider({
+    required String postUri,
+    required String postCid,
+  }) {
+    // Check if already cached
+    if (_cache.containsKey(postUri)) {
+      // Move to end (most recently used)
+      final provider = _cache.remove(postUri)!;
+      _cache[postUri] = provider;
+
+      if (kDebugMode) {
+        debugPrint('📦 Cache hit: $postUri (${_cache.length}/$maxSize)');
+      }
+
+      return provider;
+    }
+
+    // Evict unreferenced providers if at capacity.
+    if (_cache.length >= maxSize) {
+      _evictIfNeeded(includingOne: true);
+    }
+
+    // Create new provider
+    final provider = CommentsProvider(
+      _authProvider,
+      voteProvider: _voteProvider,
+      commentService: _commentService,
+      postUri: postUri,
+      postCid: postCid,
+    );
+
+    _cache[postUri] = provider;
+
+    if (kDebugMode) {
+      debugPrint('📦 Cache miss: $postUri (${_cache.length}/$maxSize)');
+      if (_cache.length > maxSize) {
+        debugPrint(
+          '📌 Cache exceeded maxSize because active providers are pinned',
+        );
+      }
+    }
+
+    return provider;
+  }
+
+  void _evictIfNeeded({bool includingOne = false}) {
+    final targetSize = includingOne ? maxSize - 1 : maxSize;
+    while (_cache.length > targetSize) {
+      String? oldestUnreferencedKey;
+      for (final key in _cache.keys) {
+        if ((_refCounts[key] ?? 0) == 0) {
+          oldestUnreferencedKey = key;
+          break;
+        }
+      }
+
+      if (oldestUnreferencedKey == null) {
+        break;
+      }
+
+      final evicted = _cache.remove(oldestUnreferencedKey);
+      evicted?.dispose();
+
+      if (kDebugMode) {
+        debugPrint('🗑️ Cache evict: $oldestUnreferencedKey');
+      }
+    }
+  }
+
+  /// Check if provider exists without creating
+  bool hasProvider(String postUri) => _cache.containsKey(postUri);
+
+  /// Get existing provider without creating (for checking state)
+  CommentsProvider? peekProvider(String postUri) => _cache[postUri];
+
+  /// Remove specific provider (e.g., after post deletion)
+  void removeProvider(String postUri) {
+    final provider = _cache.remove(postUri);
+    _refCounts.remove(postUri);
+    provider?.dispose();
+  }
+
+  /// Handle auth state changes - clear all on sign-out
+  void _onAuthChanged() {
+    final isAuthenticated = _authProvider.isAuthenticated;
+
+    // Clear all cached providers on sign-out
+    if (_wasAuthenticated && !isAuthenticated) {
+      if (kDebugMode) {
+        debugPrint('🔒 User signed out - clearing ${_cache.length} cached comment providers');
+      }
+      clearAll();
+    }
+
+    _wasAuthenticated = isAuthenticated;
+  }
+
+  /// Clear all cached providers
+  void clearAll() {
+    for (final provider in _cache.values) {
+      provider.dispose();
+    }
+    _cache.clear();
+    _refCounts.clear();
+  }
+
+  /// Current cache size
+  int get size => _cache.length;
+
+  /// Dispose and cleanup
+  void dispose() {
+    _authProvider.removeListener(_onAuthChanged);
+    clearAll();
+  }
+}

test/providers/comments_provider_test.dart

···
 
       commentsProvider = CommentsProvider(
         mockAuthProvider,
+        postUri: testPostUri,
+        postCid: testPostCid,
         apiService: mockApiService,
         voteProvider: mockVoteProvider,
       );
···
           ),
         ).thenAnswer((_) async => mockResponse);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.comments.length, 2);
         expect(commentsProvider.hasMore, true);
···
           ),
         ).thenAnswer((_) async => mockResponse);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.comments.isEmpty, true);
         expect(commentsProvider.hasMore, false);
···
           ),
         ).thenThrow(Exception('Network error'));
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.error, isNotNull);
         expect(commentsProvider.error, contains('Network error'));
···
           ),
         ).thenThrow(Exception('TimeoutException: Request timed out'));
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.error, isNotNull);
         expect(commentsProvider.isLoading, false);
···
           ),
         ).thenAnswer((_) async => firstResponse);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.comments.length, 1);
 
···
           ),
         ).thenAnswer((_) async => secondResponse);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-        );
+        await commentsProvider.loadComments();
 
         expect(commentsProvider.comments.length, 2);
         expect(commentsProvider.comments[0].comment.uri, 'comment1');
···
           ),
         ).thenAnswer((_) async => firstResponse);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.comments.length, 1);
 
···
           ),
         ).thenAnswer((_) async => refreshResponse);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.comments.length, 2);
         expect(commentsProvider.comments[0].comment.uri, 'comment2');
···
           ),
         ).thenAnswer((_) async => response);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.hasMore, false);
       });
 
-      test('should reset state when loading different post', () async {
-        // Load first post
-        final firstResponse = CommentsResponse(
-          post: {},
-          comments: [_createMockThreadComment('comment1')],
-          cursor: 'cursor-1',
-        );
-
-        when(
-          mockApiService.getComments(
-            postUri: anyNamed('postUri'),
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            depth: anyNamed('depth'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => firstResponse);
-
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
-
-        expect(commentsProvider.comments.length, 1);
-
-        // Load different post
-        const differentPostUri =
-            'at://did:plc:test/social.coves.post.record/456';
-        const differentPostCid = 'different-post-cid';
-        final secondResponse = CommentsResponse(
-          post: {},
-          comments: [_createMockThreadComment('comment2')],
-        );
-
-        when(
-          mockApiService.getComments(
-            postUri: differentPostUri,
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            depth: anyNamed('depth'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => secondResponse);
-
-        await commentsProvider.loadComments(
-          postUri: differentPostUri,
-          postCid: differentPostCid,
-          refresh: true,
-        );
-
-        // Should have reset and loaded new comments
-        expect(commentsProvider.comments.length, 1);
-        expect(commentsProvider.comments[0].comment.uri, 'comment2');
-      });
+      // Note: "reset state when loading different post" test removed
+      // Providers are now immutable per post - use CommentsProviderCache
+      // to get separate providers for different posts
 
       test('should not load when already loading', () async {
         final response = CommentsResponse(
···
         });
 
         // Start first load
-        final firstFuture = commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        final firstFuture = commentsProvider.loadComments(refresh: true);
 
         // Try to load again while still loading - should schedule a refresh
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         await firstFuture;
         // Wait a bit for the pending refresh to execute
···
             ),
           ).thenAnswer((_) async => mockResponse);
 
-          await commentsProvider.loadComments(
-            postUri: testPostUri,
-            postCid: testPostCid,
-            refresh: true,
-          );
+          await commentsProvider.loadComments(refresh: true);
 
           expect(commentsProvider.comments.length, 1);
           expect(commentsProvider.error, null);
···
           ),
         ).thenAnswer((_) async => mockResponse);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.comments.length, 1);
         expect(commentsProvider.error, null);
···
           ),
         ).thenAnswer((_) async => initialResponse);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.sort, 'hot');
 
···
           ),
         ).thenAnswer((_) async => response);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         // Try to set same sort option
         await commentsProvider.setSortOption('hot');
···
           ),
         ).thenAnswer((_) async => initialResponse);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.comments.length, 1);
 
···
         expect(commentsProvider.comments.length, 2);
       });
 
-      test('should not refresh if no post loaded', () async {
-        await commentsProvider.refreshComments();
-
-        verifyNever(
-          mockApiService.getComments(
-            postUri: anyNamed('postUri'),
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            depth: anyNamed('depth'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        );
-      });
+      // Note: "should not refresh if no post loaded" test removed
+      // Providers now always have a post URI at construction time
     });
 
     group('loadMoreComments', () {
···
           ),
         ).thenAnswer((_) async => initialResponse);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.hasMore, true);
 
···
           ),
         ).thenAnswer((_) async => response);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.hasMore, false);
 
···
         ).called(1);
       });
 
-      test('should not load more if no post loaded', () async {
-        await commentsProvider.loadMoreComments();
-
-        verifyNever(
-          mockApiService.getComments(
-            postUri: anyNamed('postUri'),
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            depth: anyNamed('depth'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        );
-      });
+      // Note: "should not load more if no post loaded" test removed
+      // Providers now always have a post URI at construction time
     });
 
     group('retry', () {
···
           ),
         ).thenThrow(Exception('Network error'));
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.error, isNotNull);
 
···
       });
     });
 
-    group('Auth state changes', () {
-      const testPostUri = 'at://did:plc:test/social.coves.post.record/123';
-
-      test('should clear comments on sign-out', () async {
-        final response = CommentsResponse(
-          post: {},
-          comments: [_createMockThreadComment('comment1')],
-        );
-
-        when(
-          mockApiService.getComments(
-            postUri: anyNamed('postUri'),
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            depth: anyNamed('depth'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => response);
-
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
-
-        expect(commentsProvider.comments.length, 1);
-
-        // Simulate sign-out
-        when(mockAuthProvider.isAuthenticated).thenReturn(false);
-        // Trigger listener manually since we're using a mock
-        commentsProvider.reset();
-
-        expect(commentsProvider.comments.isEmpty, true);
-      });
-    });
+    // Note: "Auth state changes" group removed
+    // Sign-out cleanup is now handled by CommentsProviderCache which disposes
+    // all cached providers when the user signs out. Individual providers no
+    // longer have a reset() method.
 
     group('Time updates', () {
       test('should start time updates when comments are loaded', () async {
···
 
         expect(commentsProvider.currentTimeNotifier.value, null);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.currentTimeNotifier.value, isNotNull);
       });
···
           ),
         ).thenAnswer((_) async => response);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(commentsProvider.currentTimeNotifier.value, isNotNull);
 
···
           ),
         ).thenAnswer((_) async => response);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         expect(notificationCount, greaterThan(0));
       });
···
           return response;
         });
 
-        final loadFuture = commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        final loadFuture = commentsProvider.loadComments(refresh: true);
 
         // Should be loading
         expect(commentsProvider.isLoading, true);
···
           ),
         ).thenAnswer((_) async => response);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         verify(
           mockVoteProvider.setInitialVoteState(
···
           ),
         ).thenAnswer((_) async => response);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         verify(
           mockVoteProvider.setInitialVoteState(
···
             ),
           ).thenAnswer((_) async => response);
 
-          await commentsProvider.loadComments(
-            postUri: testPostUri,
-            postCid: testPostCid,
-            refresh: true,
-          );
+          await commentsProvider.loadComments(refresh: true);
 
           // Should call setInitialVoteState with null to clear stale state
           verify(
···
             ),
           ).thenAnswer((_) async => response);
 
-          await commentsProvider.loadComments(
-            postUri: testPostUri,
-            postCid: testPostCid,
-            refresh: true,
-          );
+          await commentsProvider.loadComments(refresh: true);
 
           // Should initialize vote state for both parent and reply
           verify(
···
           ),
         ).thenAnswer((_) async => response);
 
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await commentsProvider.loadComments(refresh: true);
 
         // Should initialize vote state for all 3 levels
         verify(
···
           ).thenAnswer((_) async => page2Response);
 
           // Load first page (refresh)
-          await commentsProvider.loadComments(
-            postUri: testPostUri,
-            postCid: testPostCid,
-            refresh: true,
-          );
+          await commentsProvider.loadComments(refresh: true);
 
           // Verify comment1 vote initialized
           verify(
···
         expect(notificationCount, 2);
       });
 
-      test('should clear collapsed state on reset', () async {
-        // Collapse some comments
-        commentsProvider
-          ..toggleCollapsed('at://did:plc:test/comment/1')
-          ..toggleCollapsed('at://did:plc:test/comment/2');
-
-        expect(commentsProvider.collapsedComments.length, 2);
-
-        // Reset should clear collapsed state
-        commentsProvider.reset();
-
-        expect(commentsProvider.collapsedComments.isEmpty, true);
-        expect(
-          commentsProvider.isCollapsed('at://did:plc:test/comment/1'),
-          false,
-        );
-        expect(
-          commentsProvider.isCollapsed('at://did:plc:test/comment/2'),
-          false,
-        );
-      });
+      // Note: "clear collapsed state on reset" test removed
+      // Providers no longer have a reset() method - they are disposed entirely
+      // when evicted from cache or on sign-out
 
       test('collapsedComments getter returns unmodifiable set', () {
         commentsProvider.toggleCollapsed('at://did:plc:test/comment/1');
···
         );
       });
 
-      test('should clear collapsed state on post change', () async {
-        // Setup mock response
-        final response = CommentsResponse(
-          post: {},
-          comments: [_createMockThreadComment('comment1')],
-        );
-
-        when(
-          mockApiService.getComments(
-            postUri: anyNamed('postUri'),
-            sort: anyNamed('sort'),
-            timeframe: anyNamed('timeframe'),
-            depth: anyNamed('depth'),
-            limit: anyNamed('limit'),
-            cursor: anyNamed('cursor'),
-          ),
-        ).thenAnswer((_) async => response);
-
-        // Load first post
-        await commentsProvider.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
-
-        // Collapse a comment
-        commentsProvider.toggleCollapsed('at://did:plc:test/comment/1');
-        expect(commentsProvider.collapsedComments.length, 1);
-
-        // Load different post
-        await commentsProvider.loadComments(
-          postUri: 'at://did:plc:test/social.coves.post.record/456',
-          postCid: 'different-cid',
-          refresh: true,
-        );
-
-        // Collapsed state should be cleared
-        expect(commentsProvider.collapsedComments.isEmpty, true);
-      });
+      // Note: "clear collapsed state on post change" test removed
+      // Providers are now immutable per post - each post gets its own provider
+      // with its own collapsed state. Use CommentsProviderCache to get different
+      // providers for different posts.
     });
 
     group('createComment', () {
···
 
         providerWithCommentService = CommentsProvider(
           mockAuthProvider,
+          postUri: testPostUri,
+          postCid: testPostCid,
           apiService: mockApiService,
           voteProvider: mockVoteProvider,
           commentService: mockCommentService,
···
 
       test('should throw ValidationException for empty content', () async {
         // First load comments to set up post context
-        await providerWithCommentService.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await providerWithCommentService.loadComments(refresh: true);
 
         expect(
           () => providerWithCommentService.createComment(content: ''),
···
       test(
         'should throw ValidationException for whitespace-only content',
         () async {
-          await providerWithCommentService.loadComments(
-            postUri: testPostUri,
-            postCid: testPostCid,
-            refresh: true,
-          );
+          await providerWithCommentService.loadComments(refresh: true);
 
           expect(
             () =>
···
       test(
         'should throw ValidationException for content exceeding limit',
         () async {
-          await providerWithCommentService.loadComments(
-            postUri: testPostUri,
-            postCid: testPostCid,
-            refresh: true,
-          );
+          await providerWithCommentService.loadComments(refresh: true);
 
           // Create a string longer than 10000 characters
           final longContent = 'a' * 10001;
···
       );
 
       test('should count emoji correctly in character limit', () async {
-        await providerWithCommentService.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await providerWithCommentService.loadComments(refresh: true);
 
         // Each emoji should count as 1 character, not 2-4 bytes
         // 9999 'a' chars + 1 emoji = 10000 chars (should pass)
···
         ).called(1);
       });
 
-      test('should throw ApiException when no post loaded', () async {
-        // Don't call loadComments first - no post context
-
-        expect(
-          () =>
-              providerWithCommentService.createComment(content: 'Test comment'),
-          throwsA(
-            isA<ApiException>().having(
-              (e) => e.message,
-              'message',
-              contains('No post loaded'),
-            ),
-          ),
-        );
-      });
+      // Note: "should throw ApiException when no post loaded" test removed
+      // Post context is now always provided via constructor - this case can't occur
 
       test('should throw ApiException when no CommentService', () async {
         // Create provider without CommentService
         final providerWithoutService = CommentsProvider(
           mockAuthProvider,
+          postUri: testPostUri,
+          postCid: testPostCid,
           apiService: mockApiService,
           voteProvider: mockVoteProvider,
         );
 
-        await providerWithoutService.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
-
         expect(
           () => providerWithoutService.createComment(content: 'Test comment'),
           throwsA(
···
       });
 
       test('should create top-level comment (reply to post)', () async {
-        await providerWithCommentService.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await providerWithCommentService.loadComments(refresh: true);
 
         when(
           mockCommentService.createComment(
···
       });
 
       test('should create nested comment (reply to comment)', () async {
-        await providerWithCommentService.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await providerWithCommentService.loadComments(refresh: true);
 
         when(
           mockCommentService.createComment(
···
       });
 
       test('should trim content before sending', () async {
-        await providerWithCommentService.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await providerWithCommentService.loadComments(refresh: true);
 
         when(
           mockCommentService.createComment(
···
       });
 
       test('should refresh comments after successful creation', () async {
-        await providerWithCommentService.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await providerWithCommentService.loadComments(refresh: true);
 
         when(
           mockCommentService.createComment(
···
       });
 
       test('should rethrow exception from CommentService', () async {
-        await providerWithCommentService.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await providerWithCommentService.loadComments(refresh: true);
 
         when(
           mockCommentService.createComment(
···
       });
 
       test('should accept content at exactly max length', () async {
-        await providerWithCommentService.loadComments(
-          postUri: testPostUri,
-          postCid: testPostCid,
-          refresh: true,
-        );
+        await providerWithCommentService.loadComments(refresh: true);
 
         final contentAtLimit = 'a' * CommentsProvider.maxCommentLength;
 

test/providers/feed_provider_test.dart

···
     });
 
     group('loadFeed', () {
-      test('should load timeline when authenticated', () async {
+      test('should load discover feed when authenticated by default', () async {
         when(mockAuthProvider.isAuthenticated).thenReturn(true);
 
         final mockResponse = TimelineResponse(
···
         );
 
         when(
-          mockApiService.getTimeline(
+          mockApiService.getDiscover(
             sort: anyNamed('sort'),
             timeframe: anyNamed('timeframe'),
             limit: anyNamed('limit'),
···
         ).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);
···
             sort: anyNamed('sort'),
             timeframe: anyNamed('timeframe'),
             limit: anyNamed('limit'),
+            cursor: anyNamed('cursor'),
           ),
         ).thenAnswer((_) async => firstResponse);
 
-        await feedProvider.loadFeed(refresh: true);
+        await feedProvider.setFeedType(FeedType.forYou);
 
         // Load more
         final secondResponse = TimelineResponse(
···
           ),
         ).thenAnswer((_) async => response);
 
-        await feedProvider.fetchTimeline(refresh: true);
+        await feedProvider.setFeedType(FeedType.forYou);
         await feedProvider.loadMore();
 
         // Should not make additional calls while loading
···
           ),
         ).thenThrow(Exception('Network error'));
 
-        await feedProvider.loadFeed(refresh: true);
+        await feedProvider.setFeedType(FeedType.forYou);
         expect(feedProvider.error, isNotNull);
 
         // Retry

test/test_helpers/mock_providers.dart

···
 import 'package:coves_flutter/providers/vote_provider.dart';
 import 'package:flutter/foundation.dart';
 
+/// Mock CommentsProvider for testing
+class MockCommentsProvider extends ChangeNotifier {
+  final String postUri;
+  final String postCid;
+
+  MockCommentsProvider({
+    required this.postUri,
+    required this.postCid,
+  });
+
+  final ValueNotifier<DateTime?> currentTimeNotifier = ValueNotifier(null);
+
+  @override
+  void dispose() {
+    currentTimeNotifier.dispose();
+    super.dispose();
+  }
+}
+
 /// Mock AuthProvider for testing
 class MockAuthProvider extends ChangeNotifier {
   bool _isAuthenticated = false;

test/widgets/feed_screen_test.dart

···
       expect(find.text('Test Post 2'), findsOneWidget);
     });
 
-    testWidgets('should display "Feed" title when authenticated', (
+    testWidgets('should display feed type tabs when authenticated', (
       tester,
     ) async {
       fakeAuthProvider.setAuthenticated(value: true);
 
       await tester.pumpWidget(createTestWidget());
 
-      expect(find.text('Feed'), findsOneWidget);
+      expect(find.text('Discover'), findsOneWidget);
+      expect(find.text('For You'), findsOneWidget);
     });
 
-    testWidgets('should display "Explore" title when not authenticated', (
+    testWidgets('should display only Discover tab when not authenticated', (
       tester,
     ) async {
       fakeAuthProvider.setAuthenticated(value: false);
 
       await tester.pumpWidget(createTestWidget());
 
-      expect(find.text('Explore'), findsOneWidget);
+      expect(find.text('Discover'), findsOneWidget);
+      expect(find.text('For You'), findsNothing);
     });
 
     testWidgets('should handle pull-to-refresh', (tester) async {

test/widgets/focused_thread_screen_test.dart

···
 import 'package:coves_flutter/models/comment.dart';
 import 'package:coves_flutter/models/post.dart';
+import 'package:coves_flutter/providers/comments_provider.dart';
 import 'package:coves_flutter/screens/home/focused_thread_screen.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
···
 void main() {
   late MockAuthProvider mockAuthProvider;
   late MockVoteProvider mockVoteProvider;
+  late MockCommentsProvider mockCommentsProvider;
 
   setUp(() {
     mockAuthProvider = MockAuthProvider();
     mockVoteProvider = MockVoteProvider();
+    mockCommentsProvider = MockCommentsProvider(
+      postUri: 'at://did:plc:test/post/123',
+      postCid: 'post-cid',
+    );
+  });
+
+  tearDown(() {
+    mockCommentsProvider.dispose();
   });
 
   /// Helper to create a test comment
···
           thread: thread,
           ancestors: ancestors,
           onReply: onReply ?? (content, parent) async {},
+          // Note: Using mock cast - tests are skipped so this won't actually run
+          commentsProvider: mockCommentsProvider as CommentsProvider,
         ),
       ),
     );