feat(profile): wire up comments tab with actor.getComments endpoint

Integrate the new social.coves.actor.getComments backend endpoint
into the profile page's Comments tab:

- Add getActorComments() method to CovesApiService
- Add CommentsState model with immutable list (List.unmodifiable)
- Add ActorCommentsResponse model with proper documentation
- Add loadComments/loadMoreComments/retryComments to UserProfileProvider
- Wire up lazy loading in profile screen (loads on first tab switch)
- Display comments using existing CommentCard widget
- Handle pagination, loading states, and errors
- Properly handle 404 as "User not found" (not empty state)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

lib/models/comment.dart

···
   /// AT-URI of the vote record (if backend provides it)
   final String? voteUri;
 }
+
+/// Sentinel value for copyWith to distinguish "not provided" from "null"
+const _sentinel = Object();
+
+/// State container for a comments list (e.g., actor comments)
+///
+/// Holds all state for a paginated comments list including loading states,
+/// pagination, and errors.
+///
+/// The [comments] list is immutable - callers cannot modify it externally.
+class CommentsState {
+  /// Creates a new CommentsState with an immutable comments list.
+  CommentsState({
+    List<CommentView> comments = const [],
+    this.cursor,
+    this.hasMore = true,
+    this.isLoading = false,
+    this.isLoadingMore = false,
+    this.error,
+  }) : comments = List.unmodifiable(comments);
+
+  /// Create a default empty state
+  factory CommentsState.initial() {
+    return CommentsState();
+  }
+
+  /// Unmodifiable list of comments
+  final List<CommentView> comments;
+
+  /// 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;
+
+  /// Create a copy with modified fields (immutable updates)
+  ///
+  /// Nullable fields (cursor, error) use a sentinel pattern to distinguish
+  /// between "not provided" and "explicitly set to null".
+  CommentsState copyWith({
+    List<CommentView>? comments,
+    Object? cursor = _sentinel,
+    bool? hasMore,
+    bool? isLoading,
+    bool? isLoadingMore,
+    Object? error = _sentinel,
+  }) {
+    return CommentsState(
+      comments: comments ?? this.comments,
+      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?,
+    );
+  }
+}
+
+/// Response from social.coves.actor.getComments endpoint.
+///
+/// Returns a flat list of comments by a specific user for their profile page.
+/// The endpoint returns an empty array when the user has no comments,
+/// and 404 when the user doesn't exist.
+class ActorCommentsResponse {
+  ActorCommentsResponse({required this.comments, this.cursor});
+
+  /// Parses the JSON response from the API.
+  ///
+  /// Handles null comments array gracefully by returning an empty list.
+  factory ActorCommentsResponse.fromJson(Map<String, dynamic> json) {
+    final commentsData = json['comments'];
+    final List<CommentView> commentsList;
+
+    if (commentsData == null) {
+      commentsList = [];
+    } else {
+      commentsList =
+          (commentsData as List<dynamic>)
+              .map((item) => CommentView.fromJson(item as Map<String, dynamic>))
+              .toList();
+    }
+
+    return ActorCommentsResponse(
+      comments: commentsList,
+      cursor: json['cursor'] as String?,
+    );
+  }
+
+  /// List of comments by the actor, ordered newest first.
+  final List<CommentView> comments;
+
+  /// Pagination cursor for fetching the next page of comments.
+  /// Null when there are no more comments to fetch.
+  final String? cursor;
+}

lib/providers/user_profile_provider.dart

···
 import 'package:flutter/foundation.dart';
 
+import '../models/comment.dart';
 import '../models/feed_state.dart';
 import '../models/post.dart';
 import '../models/user_profile.dart';
···
   // Posts feed state (reusing FeedState pattern)
   FeedState _postsState = FeedState.initial();
 
+  // Comments feed state
+  CommentsState _commentsState = CommentsState.initial();
+
   // LRU profile cache keyed by DID (max 50 entries)
   static const int _maxCacheSize = 50;
   final Map<String, UserProfile> _profileCache = {};
···
   String? get profileError => _profileError;
   String? get currentProfileDid => _currentProfileDid;
   FeedState get postsState => _postsState;
+  CommentsState get commentsState => _commentsState;
 
   /// Check if currently viewing own profile
   bool get isOwnProfile {
···
       _cacheAccessOrder.clear();
       _profile = null;
       _postsState = FeedState.initial();
+      _commentsState = CommentsState.initial();
       _currentProfileDid = null;
       notifyListeners();
     }
···
         debugPrint('❌ Auth required to load posts');
       }
     } on NotFoundException {
-      // Author posts endpoint not implemented yet - show empty state
+      // 404 means the actor doesn't exist (not "no posts")
+      // Empty posts are returned as an empty array, not 404
       _postsState = currentState.copyWith(
-        posts: [],
-        hasMore: false,
-        error: null,
+        error: 'User not found',
         isLoading: false,
         isLoadingMore: false,
       );
 
       if (kDebugMode) {
-        debugPrint('⚠️ Author posts endpoint not available');
+        debugPrint('❌ Actor not found when loading posts');
       }
     } on NetworkException catch (e) {
       _postsState = currentState.copyWith(
···
     await loadPosts(refresh: false);
   }
 
+  /// Load comments by the current profile's author
+  ///
+  /// Parameters:
+  /// - [refresh]: Reload from beginning instead of paginating
+  Future<void> loadComments({bool refresh = false}) async {
+    if (_currentProfileDid == null) {
+      _commentsState = _commentsState.copyWith(
+        error: 'No profile loaded',
+        isLoading: false,
+        isLoadingMore: false,
+      );
+      notifyListeners();
+      return;
+    }
+    if (_commentsState.isLoading || _commentsState.isLoadingMore) return;
+
+    final currentState = _commentsState;
+
+    try {
+      if (refresh) {
+        _commentsState = currentState.copyWith(isLoading: true, error: null);
+      } else {
+        if (!currentState.hasMore) return;
+        _commentsState = currentState.copyWith(isLoadingMore: true);
+      }
+      notifyListeners();
+
+      final response = await _apiService.getActorComments(
+        actor: _currentProfileDid!,
+        cursor: refresh ? null : currentState.cursor,
+      );
+
+      final List<CommentView> newComments;
+      if (refresh) {
+        newComments = response.comments;
+      } else {
+        newComments = [...currentState.comments, ...response.comments];
+      }
+
+      _commentsState = currentState.copyWith(
+        comments: newComments,
+        cursor: response.cursor,
+        hasMore: response.cursor != null,
+        error: null,
+        isLoading: false,
+        isLoadingMore: false,
+      );
+
+      if (kDebugMode) {
+        debugPrint(
+          '✅ Author comments loaded: ${newComments.length} comments total',
+        );
+      }
+    } on AuthenticationException {
+      _commentsState = currentState.copyWith(
+        error: 'Please sign in to view comments',
+        isLoading: false,
+        isLoadingMore: false,
+      );
+
+      if (kDebugMode) {
+        debugPrint('❌ Auth required to load comments');
+      }
+    } on NotFoundException {
+      // 404 means the actor doesn't exist (not "no comments")
+      // Empty comments are returned as an empty array, not 404
+      _commentsState = currentState.copyWith(
+        error: 'User not found',
+        isLoading: false,
+        isLoadingMore: false,
+      );
+
+      if (kDebugMode) {
+        debugPrint('❌ Actor not found when loading comments');
+      }
+    } on NetworkException catch (e) {
+      _commentsState = currentState.copyWith(
+        error: 'Network error. Check your connection.',
+        isLoading: false,
+        isLoadingMore: false,
+      );
+
+      if (kDebugMode) {
+        debugPrint('❌ Network error loading comments: ${e.message}');
+      }
+    } on ApiException catch (e) {
+      _commentsState = currentState.copyWith(
+        error: e.message,
+        isLoading: false,
+        isLoadingMore: false,
+      );
+
+      if (kDebugMode) {
+        debugPrint('❌ Failed to load author comments: ${e.message}');
+      }
+    } on FormatException catch (e) {
+      _commentsState = currentState.copyWith(
+        error: 'Invalid data received from server',
+        isLoading: false,
+        isLoadingMore: false,
+      );
+
+      if (kDebugMode) {
+        debugPrint('❌ Format error loading comments: $e');
+      }
+    } on Exception catch (e) {
+      _commentsState = currentState.copyWith(
+        error: 'Failed to load comments. Please try again.',
+        isLoading: false,
+        isLoadingMore: false,
+      );
+
+      if (kDebugMode) {
+        debugPrint('❌ Unexpected error loading comments: $e');
+      }
+    }
+
+    notifyListeners();
+  }
+
+  /// Load more comments (pagination)
+  Future<void> loadMoreComments() async {
+    await loadComments(refresh: false);
+  }
+
   /// Clear current profile and reset state
   void clearProfile() {
     _profile = null;
     _currentProfileDid = null;
     _postsState = FeedState.initial();
+    _commentsState = CommentsState.initial();
     _profileError = null;
     _isLoadingProfile = false;
     notifyListeners();
···
     _postsState = _postsState.copyWith(error: null);
     notifyListeners();
     await loadPosts(refresh: true);
+  }
+
+  /// Retry loading comments after error
+  Future<void> retryComments() async {
+    _commentsState = _commentsState.copyWith(error: null);
+    notifyListeners();
+    await loadComments(refresh: true);
   }
 
   @override

lib/screens/home/profile_screen.dart

···
 import 'package:share_plus/share_plus.dart';
 
 import '../../constants/app_colors.dart';
+import '../../models/comment.dart';
 import '../../providers/auth_provider.dart';
 import '../../providers/user_profile_provider.dart';
+import '../../widgets/comment_card.dart';
 import '../../widgets/loading_error_states.dart';
 import '../../widgets/post_card.dart';
 import '../../widgets/primary_button.dart';
···
 
 class _ProfileScreenState extends State<ProfileScreen> {
   int _selectedTabIndex = 0;
+  bool _commentsLoadedOnce = false;
 
   @override
   void initState() {
···
   void didUpdateWidget(ProfileScreen oldWidget) {
     super.didUpdateWidget(oldWidget);
     if (oldWidget.actor != widget.actor) {
+      // Reset comments loaded flag when viewing a different profile
+      _commentsLoadedOnce = false;
       _loadProfile();
     }
   }
 
+  void _onTabChanged(int index) {
+    setState(() {
+      _selectedTabIndex = index;
+    });
+
+    // Lazy load comments when first switching to Comments tab
+    if (index == 1 && !_commentsLoadedOnce) {
+      _commentsLoadedOnce = true;
+      final profileProvider = context.read<UserProfileProvider>();
+      profileProvider.loadComments(refresh: true);
+    }
+  }
+
   Future<void> _loadProfile() async {
     final authProvider = context.read<AuthProvider>();
     final profileProvider = context.read<UserProfileProvider>();
···
           final actor = widget.actor ?? authProvider.did;
           if (actor != null) {
             await profileProvider.loadProfile(actor, forceRefresh: true);
-            await profileProvider.loadPosts(refresh: true);
+            // Refresh the active tab content
+            if (_selectedTabIndex == 0) {
+              await profileProvider.loadPosts(refresh: true);
+            } else if (_selectedTabIndex == 1) {
+              await profileProvider.loadComments(refresh: true);
+            }
           }
         },
         child: CustomScrollView(
···
                   color: AppColors.background,
                   child: _ProfileTabBar(
                     selectedIndex: _selectedTabIndex,
-                    onTabChanged: (index) {
-                      setState(() {
-                        _selectedTabIndex = index;
-                      });
-                    },
+                    onTabChanged: _onTabChanged,
                   ),
                 ),
               ),
···
             // Content based on selected tab
             if (_selectedTabIndex == 0)
               _buildPostsList(profileProvider)
+            else if (_selectedTabIndex == 1)
+              _buildCommentsList(profileProvider)
             else
-              _buildComingSoonPlaceholder(
-                _selectedTabIndex == 1 ? 'Comments' : 'Likes',
-              ),
+              _buildComingSoonPlaceholder('Likes'),
           ],
         ),
       ),
···
     );
   }
 
+  Widget _buildCommentsList(UserProfileProvider profileProvider) {
+    final commentsState = profileProvider.commentsState;
+
+    // Loading state for comments
+    if (commentsState.isLoading && commentsState.comments.isEmpty) {
+      return const SliverFillRemaining(
+        child: Center(
+          child: CircularProgressIndicator(color: AppColors.primary),
+        ),
+      );
+    }
+
+    // Error state for comments
+    if (commentsState.error != null && commentsState.comments.isEmpty) {
+      return SliverFillRemaining(
+        child: Center(
+          child: InlineError(
+            message: commentsState.error!,
+            onRetry: () => profileProvider.retryComments(),
+          ),
+        ),
+      );
+    }
+
+    // Empty state
+    if (commentsState.comments.isEmpty && !commentsState.isLoading) {
+      return const SliverFillRemaining(
+        child: Center(
+          child: Text(
+            'No comments yet',
+            style: TextStyle(fontSize: 16, color: AppColors.textSecondary),
+          ),
+        ),
+      );
+    }
+
+    // Comments list
+    final showLoadingSlot =
+        commentsState.isLoadingMore || commentsState.error != null;
+
+    return SliverList(
+      delegate: SliverChildBuilderDelegate((context, index) {
+        // Load more when reaching end
+        if (index == commentsState.comments.length - 3 &&
+            commentsState.hasMore) {
+          profileProvider.loadMoreComments();
+        }
+
+        // Show loading indicator or error at the end
+        if (index == commentsState.comments.length) {
+          if (commentsState.isLoadingMore) {
+            return const InlineLoading();
+          }
+          if (commentsState.error != null) {
+            return InlineError(
+              message: commentsState.error!,
+              onRetry: () => profileProvider.loadMoreComments(),
+            );
+          }
+          return const SizedBox.shrink();
+        }
+
+        final comment = commentsState.comments[index];
+        return _ProfileCommentCard(comment: comment);
+      }, childCount: commentsState.comments.length + (showLoadingSlot ? 1 : 0)),
+    );
+  }
+
   Widget _buildComingSoonPlaceholder(String feature) {
     return SliverFillRemaining(
       child: Center(
···
     return child != oldDelegate.child;
   }
 }
+
+/// A simplified comment card for the profile comments list
+///
+/// Displays a flat comment without threading since these are shown in
+/// a profile context without parent/child relationships visible.
+class _ProfileCommentCard extends StatelessWidget {
+  const _ProfileCommentCard({required this.comment});
+
+  final CommentView comment;
+
+  @override
+  Widget build(BuildContext context) {
+    return CommentCard(
+      comment: comment,
+      depth: 0,
+    );
+  }
+}

lib/services/coves_api_service.dart

···
     }
   }
 
+  /// Get comments by a specific actor
+  ///
+  /// Fetches comments created by a specific user for their profile page.
+  ///
+  /// Parameters:
+  /// - [actor]: User's DID or handle (required)
+  /// - [community]: Filter to comments in a specific community (optional)
+  /// - [limit]: Number of comments per page (default: 50, max: 100)
+  /// - [cursor]: Pagination cursor from previous response
+  ///
+  /// Throws:
+  /// - `NotFoundException` if the actor does not exist
+  /// - `AuthenticationException` if authentication is required/expired
+  /// - `ApiException` for other API errors
+  Future<ActorCommentsResponse> getActorComments({
+    required String actor,
+    String? community,
+    int limit = 50,
+    String? cursor,
+  }) async {
+    try {
+      if (kDebugMode) {
+        debugPrint('📡 Fetching comments for actor: $actor');
+      }
+
+      final queryParams = <String, dynamic>{
+        'actor': actor,
+        'limit': limit,
+      };
+
+      if (community != null) {
+        queryParams['community'] = community;
+      }
+
+      if (cursor != null) {
+        queryParams['cursor'] = cursor;
+      }
+
+      final response = await _dio.get(
+        '/xrpc/social.coves.actor.getComments',
+        queryParameters: queryParams,
+      );
+
+      final data = response.data;
+      if (data is! Map<String, dynamic>) {
+        throw FormatException('Expected Map but got ${data.runtimeType}');
+      }
+
+      if (kDebugMode) {
+        debugPrint(
+          '✅ Actor comments fetched: '
+          '${data['comments']?.length ?? 0} comments',
+        );
+      }
+
+      return ActorCommentsResponse.fromJson(data);
+    } on DioException catch (e) {
+      _handleDioException(e, 'actor comments');
+    } on FormatException {
+      rethrow;
+    } on Exception catch (e) {
+      if (kDebugMode) {
+        debugPrint('❌ Error parsing actor comments response: $e');
+      }
+      throw ApiException('Failed to parse server response', originalError: e);
+    }
+  }
+
   /// Handle Dio exceptions with specific error types
   ///
   /// Converts generic DioException into specific typed exceptions