feat: get pinned post from profile data

* change fab icon

lib/src/app/theme.dart

···
 
   /// Builds the text theme with custom fonts.
   /// - Crimson Pro for display styles
-  /// - Atkinson Hyperlegible for body/label styles
+  /// - Merriweather Sans for body/label styles
   /// - Fira Code for code (available via bodySmall)
   static TextTheme _buildTextTheme(Color color) {
     final displayStyle = GoogleFonts.crimsonPro(color: color);
-    final bodyStyle = GoogleFonts.atkinsonHyperlegible(color: color);
+    final bodyStyle = GoogleFonts.merriweatherSans(color: color);
     final monoStyle = GoogleFonts.firaCode(color: color);
 
     return TextTheme(

lib/src/app/theming/theme_factory.dart

···
   /// Builds the text theme with custom fonts.
   ///
   /// - Crimson Pro for display styles
-  /// - Atkinson Hyperlegible for body/label styles
+  /// - Merriweather Sans for body/label styles
   /// - Fira Code for code (available via bodySmall)
   static TextTheme _buildTextTheme(Color color) {
     final displayStyle = GoogleFonts.crimsonPro(color: color);
-    final bodyStyle = GoogleFonts.atkinsonHyperlegible(color: color);
+    final bodyStyle = GoogleFonts.merriweatherSans(color: color);
     final monoStyle = GoogleFonts.firaCode(color: color);
 
     return TextTheme(

lib/src/core/widgets/feed_post_card.dart

···
     this.likeCount = 0,
     this.onTap,
     this.onAvatarTap,
-    this.showDivider = true,
     super.key,
   });
 
···
   final int likeCount;
   final VoidCallback? onTap;
   final VoidCallback? onAvatarTap;
-  final bool showDivider;
 
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
 
-    return Column(
-      children: [
-        InkWell(
-          onTap: onTap,
-          child: Padding(
-            padding: const EdgeInsets.symmetric(vertical: 12, horizontal: 16),
-            child: Column(
-              crossAxisAlignment: CrossAxisAlignment.start,
-              children: [
-                _buildHeader(theme),
-                const SizedBox(height: 8),
-                _buildBody(theme),
-                const SizedBox(height: 8),
-                _buildActions(theme),
-              ],
-            ),
+    return Card(
+      clipBehavior: Clip.antiAlias,
+      margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+      elevation: 2,
+      child: InkWell(
+        onTap: onTap,
+        child: Padding(
+          padding: const EdgeInsets.symmetric(vertical: 12, horizontal: 16),
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              _buildHeader(theme),
+              const SizedBox(height: 8),
+              _buildBody(theme),
+              const SizedBox(height: 8),
+              _buildActions(theme),
+            ],
           ),
         ),
-        if (showDivider) const Divider(height: 1),
-      ],
+      ),
     );
   }
 

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

···
+import 'package:flutter/cupertino.dart';
 import 'package:flutter/material.dart';
 import 'package:go_router/go_router.dart';
 import 'package:lazurite/src/app/routes.dart';
···
 ///
 /// Displays an extended FAB with "Post" label and edit icon.
 /// Navigates to the composer screen when tapped.
-/// Should be shown on main screens (Home, Search, Notifications, Profile)
-/// and hidden on screens like Composer, Login, Drafts, and Settings.
+///
+/// Should be shown on main screens (Home, Search, Notifications, Profile) and hidden on screens
+/// like Composer, Login, Drafts, and Settings.
 class GlobalComposeFab extends StatelessWidget {
   const GlobalComposeFab({super.key});
 
···
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
 
-    return FloatingActionButton.extended(
+    return FloatingActionButton(
       onPressed: () => context.push(AppRoutes.compose),
-      label: const Icon(Icons.edit_outlined),
       backgroundColor: theme.colorScheme.primary,
       foregroundColor: theme.colorScheme.onPrimary,
-      elevation: 6,
+      elevation: 4,
+      child: const Icon(CupertinoIcons.pencil_ellipsis_rectangle),
     );
   }
 }

lib/src/features/feeds/presentation/screens/feed_screen.dart

···
     final authState = ref.watch(authProvider);
     final isAuthenticated = authState is AuthStateAuthenticated;
 
-    // For authenticated users, wait for pinned feeds to load before showing content
-    // This prevents briefly showing the wrong feed during initialization
     if (isAuthenticated) {
       final pinnedFeedsAsync = ref.watch(pinnedFeedsProvider);
       if (pinnedFeedsAsync.isLoading) {
···
                   else
                     SliverList(
                       delegate: SliverChildBuilderDelegate((context, index) {
-                        if (index.isOdd) {
-                          return const Divider(height: 1);
-                        }
-                        final itemIndex = index ~/ 2;
                         return AnimatedItem(
-                          index: itemIndex,
-                          child: FeedPostCard(item: items[itemIndex]),
+                          index: index,
+                          child: FeedPostCard(item: items[index]),
                         );
-                      }, childCount: items.length * 2 - 1),
+                      }, childCount: items.length),
                     ),
                 ],
               ),

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

···
       );
     }
 
-    return InkWell(
-      onTap:
-          onTap ??
-          () {
-            final encodedUri = Uri.encodeComponent(item.post.uri);
-            GoRouter.of(context).push('/home/t/$encodedUri');
-          },
-      child: Padding(
-        padding: const EdgeInsets.symmetric(vertical: 12.0, horizontal: 16.0),
-        child: Column(
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            if (isRepost && reposter != null)
-              Padding(
-                padding: const EdgeInsets.only(bottom: 4.0, left: 28.0),
-                child: Row(
-                  children: [
-                    Icon(
-                      Icons.repeat,
-                      size: 12,
-                      color: Theme.of(context).colorScheme.onSurfaceVariant,
-                    ),
-                    const SizedBox(width: 4),
-                    Text(
-                      'Reposted by ${reposter['displayName'] as String? ?? reposter['handle'] as String? ?? 'someone'}',
-                      style: Theme.of(context).textTheme.bodySmall?.copyWith(
+    return Card(
+      clipBehavior: Clip.antiAlias,
+      margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+      elevation: 2,
+      child: InkWell(
+        onTap:
+            onTap ??
+            () {
+              final encodedUri = Uri.encodeComponent(item.post.uri);
+              GoRouter.of(context).push('/home/t/$encodedUri');
+            },
+        child: Padding(
+          padding: const EdgeInsets.symmetric(vertical: 12.0, horizontal: 16.0),
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              if (isRepost && reposter != null)
+                Padding(
+                  padding: const EdgeInsets.only(bottom: 4.0, left: 28.0),
+                  child: Row(
+                    children: [
+                      Icon(
+                        Icons.repeat,
+                        size: 12,
                         color: Theme.of(context).colorScheme.onSurfaceVariant,
-                        fontWeight: FontWeight.bold,
+                      ),
+                      const SizedBox(width: 4),
+                      Text(
+                        'Reposted by ${reposter['displayName'] as String? ?? reposter['handle'] as String? ?? 'someone'}',
+                        style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                          color: Theme.of(context).colorScheme.onSurfaceVariant,
+                          fontWeight: FontWeight.bold,
+                        ),
                       ),
-                    ),
-                  ],
+                    ],
+                  ),
                 ),
+              PostHeader(
+                author: item.author,
+                indexedAt: createdAt,
+                onAvatarTap: () {
+                  final encodedDid = Uri.encodeComponent(item.author.did);
+                  GoRouter.of(context).push('/home/u/$encodedDid');
+                },
               ),
-            PostHeader(
-              author: item.author,
-              indexedAt: createdAt,
-              onAvatarTap: () {
-                final encodedDid = Uri.encodeComponent(item.author.did);
-                GoRouter.of(context).push('/home/u/$encodedDid');
-              },
-            ),
-            Padding(padding: const EdgeInsets.only(left: 52.0), child: postContent),
-          ],
+              Padding(padding: const EdgeInsets.only(left: 52.0), child: postContent),
+            ],
+          ),
         ),
       ),
     );

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

···
           height: 48,
           child: Row(
             children: [
-              // Scrollable feed chips
               Expanded(
                 child: ListView.separated(
                   padding: const EdgeInsets.only(left: 16),
···
                   },
                 ),
               ),
-
-              // Persistent manage feeds button
               Stack(
                 alignment: Alignment.center,
                 children: [

lib/src/features/profile/infrastructure/profile_repository.dart

···
     _logger.info('Fetching profile', {'actor': actor});
     try {
       final response = await _api.call('app.bsky.actor.getProfile', params: {'actor': actor});
+
+      final pinnedRaw = response['pinnedPost'];
+      if (pinnedRaw != null) {
+        _logger.info('Received pinnedPost', {
+          'type': pinnedRaw.runtimeType.toString(),
+          'value': pinnedRaw.toString(),
+        });
+      } else {
+        _logger.info('No pinnedPost in response');
+      }
+
       final profile = ProfileData.fromJson(response);
 
       await _dao.upsertProfile(
···
       final posts = response['posts'] as List?;
       if (posts == null || posts.isEmpty) return null;
 
-      return FeedItem.fromJson(posts.first as Map<String, dynamic>);
+      return FeedItem.fromPostView(posts.first as Map<String, dynamic>);
     } catch (e, stack) {
       _logger.error('Failed to fetch post', e, stack);
       rethrow;
···
 
 /// Represents a single feed item from author feed.
 class FeedItem {
+  factory FeedItem.fromPostView(Map<String, dynamic> json) {
+    final author = json['author'] as Map<String, dynamic>;
+    final record = json['record'] as Map<String, dynamic>;
+    final embed = json['embed'] as Map<String, dynamic>?;
+    final embedType = embed?[r'$type'] as String?;
+    final hasImages =
+        embedType == 'app.bsky.embed.images#view' ||
+        embedType == 'app.bsky.embed.recordWithMedia#view' &&
+            (embed?['media'] as Map<String, dynamic>?)?[r'$type'] == 'app.bsky.embed.images#view';
+    final hasVideo = embedType == 'app.bsky.embed.video#view';
+    final viewer = json['viewer'] as Map<String, dynamic>?;
+
+    return FeedItem(
+      uri: json['uri'] as String,
+      cid: json['cid'] as String,
+      authorDid: author['did'] as String,
+      authorHandle: author['handle'] as String,
+      authorDisplayName: author['displayName'] as String?,
+      authorAvatar: author['avatar'] as String?,
+      text: record['text'] as String? ?? '',
+      indexedAt: DateTime.tryParse(json['indexedAt'] as String? ?? ''),
+      replyCount: json['replyCount'] as int? ?? 0,
+      repostCount: json['repostCount'] as int? ?? 0,
+      likeCount: json['likeCount'] as int? ?? 0,
+      isReply: record['reply'] != null,
+      hasImages: hasImages,
+      hasVideo: hasVideo,
+      embedType: embedType,
+      record: record,
+      embed: embed,
+      viewerLikeUri: viewer?['like'] as String?,
+      viewerRepostUri: viewer?['repost'] as String?,
+      viewerBookmarked: viewer?['bookmarked'] as bool? ?? false,
+    );
+  }
+
   factory FeedItem.fromJson(Map<String, dynamic> json) {
     final post = json['post'] as Map<String, dynamic>;
     final author = post['author'] as Map<String, dynamic>;

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

···
             padding: EdgeInsets.all(16.0),
             child: Center(child: CircularProgressIndicator()),
           ),
-          error: (error, stack) => const SizedBox.shrink(),
+          error: (error, stack) => Padding(
+            padding: const EdgeInsets.all(16.0),
+            child: Text(
+              'Error loading pinned post: $error',
+              style: TextStyle(color: Theme.of(context).colorScheme.error),
+            ),
+          ),
         ),
       ],
     );

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

···
     final requiresAuth = options.extra[requiresAuthKey] == true;
     var session = await getSession();
 
-    // Proactively refresh if token is near expiration
     if (session != null && session.isNearExpiration && !session.isExpired) {
       _logger.debug('Token near expiration, proactively refreshing');
       final refreshed = await _performRefresh();
···
       }
     }
 
-    // Attach auth headers if session is available
-    // (required for requiresAuth endpoints, optional otherwise)
     if (session != null) {
       final token = session.accessJwt;
       options.headers['Authorization'] = 'DPoP $token';
···
         _logger.warning('Failed to create DPoP proof for request', e);
       }
     } else if (requiresAuth) {
-      // Fail early if auth is required but no session exists
       _logger.warning('Request requires auth but no session available');
     }
 

test/src/core/widgets/feed_post_card_test.dart

···
     int likeCount = 0,
     VoidCallback? onTap,
     VoidCallback? onAvatarTap,
-    bool showDivider = true,
   }) {
     return MaterialApp(
       home: Scaffold(
···
           likeCount: likeCount,
           onTap: onTap,
           onAvatarTap: onAvatarTap,
-          showDivider: showDivider,
         ),
       ),
     );
···
       await tester.pump();
 
       expect(avatarTapped, true);
-    });
-
-    testWidgets('shows divider by default', (tester) async {
-      await tester.pumpWidget(createSubject(showDivider: true));
-      expect(find.byType(Divider), findsOneWidget);
-    });
-
-    testWidgets('hides divider when showDivider is false', (tester) async {
-      await tester.pumpWidget(createSubject(showDivider: false));
-      expect(find.byType(Divider), findsNothing);
     });
 
     testWidgets('renders relative time', (tester) async {

test/src/features/composer/presentation/widgets/global_compose_fab_test.dart

···
+import 'package:flutter/cupertino.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:go_router/go_router.dart';
···
     testWidgets('renders extended FAB with Post label', (tester) async {
       await tester.pumpApp(const GlobalComposeFab());
 
-      expect(find.text('Post'), findsOneWidget);
       expect(find.byType(FloatingActionButton), findsOneWidget);
     });
 
     testWidgets('renders with edit icon', (tester) async {
       await tester.pumpApp(const GlobalComposeFab());
-
-      expect(find.byIcon(Icons.edit_outlined), findsOneWidget);
+      expect(find.byIcon(CupertinoIcons.pencil_ellipsis_rectangle), findsOneWidget);
     });
 
     testWidgets('navigates to compose route when tapped', (tester) async {

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

···
     expect(homeChipAfter.selected, isFalse);
   });
 
-  testWidgets('FeedSelectorTab shows only Discover for unauthenticated users', (tester) async {
+  testWidgets('FeedSelectorTab is hidden for unauthenticated users', (tester) async {
     final mockDatabase = MockAppDatabase();
 
     await tester.pumpWidget(
···
 
     await tester.pump();
 
-    expect(find.text('Discover'), findsOneWidget);
+    expect(find.text('Discover'), findsNothing);
     expect(find.text('Home'), findsNothing);
     expect(find.byIcon(Icons.tune), findsNothing);
   });

test/src/features/profile/infrastructure/profile_repository_pinned_post_test.dart

···
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lazurite/src/features/profile/infrastructure/profile_repository.dart';
+import 'package:lazurite/src/infrastructure/db/app_database.dart';
+import 'package:mocktail/mocktail.dart';
+
+import '../../../../helpers/mocks.dart';
+
+void main() {
+  late MockXrpcClient mockApi;
+  late AppDatabase db;
+  late MockLogger mockLogger;
+  late ProfileRepository repository;
+
+  setUp(() {
+    mockApi = MockXrpcClient();
+    db = AppDatabase(NativeDatabase.memory());
+    mockLogger = MockLogger();
+    repository = ProfileRepository(
+      mockApi,
+      db.profileDao,
+      db.followsDao,
+      db.profileRelationshipDao,
+      mockLogger,
+    );
+  });
+
+  tearDown(() async {
+    await db.close();
+  });
+
+  group('ProfileRepository Pinned Post', () {
+    test('parses pinnedPost URI from API response', () async {
+      when(() => mockApi.call(any(), params: any(named: 'params'))).thenAnswer(
+        (_) async => {
+          'did': 'did:plc:test123',
+          'handle': 'test.bsky.social',
+          'pinnedPost': {
+            'uri': 'at://did:plc:test123/app.bsky.feed.post/pinned123',
+            'cid': 'bafybeicid123',
+          },
+        },
+      );
+
+      final profile = await repository.getProfile('test.bsky.social');
+
+      expect(profile.pinnedPostUri, 'at://did:plc:test123/app.bsky.feed.post/pinned123');
+
+      final cached = await db.profileDao.getProfile('did:plc:test123');
+      expect(cached?.pinnedPostUri, 'at://did:plc:test123/app.bsky.feed.post/pinned123');
+    });
+
+    test('handles missing pinnedPost', () async {
+      when(
+        () => mockApi.call(any(), params: any(named: 'params')),
+      ).thenAnswer((_) async => {'did': 'did:plc:test123', 'handle': 'test.bsky.social'});
+
+      final profile = await repository.getProfile('test.bsky.social');
+
+      expect(profile.pinnedPostUri, isNull);
+    });
+  });
+}

test/src/features/profile/infrastructure/profile_repository_test.dart

···
         expect(profile.pronouns, 'they/them');
         expect(profile.website, 'https://example.com');
         expect(profile.verificationStatus, 'verified');
+        expect(profile.pinnedPostUri, 'at://did:plc:test123/app.bsky.feed.post/pinned123');
         expect(profile.viewerFollowing, true);
 
         verify(
···
         expect(rel!.blocked, isTrue);
       });
     });
+
+    group('getPost', () {
+      test('fetches post and parses it correctly', () async {
+        when(
+          () => mockApi.call(any(), params: any(named: 'params')),
+        ).thenAnswer((_) async => _mockGetPostsResponse());
+
+        final post = await repository.getPost('at://did:plc:test123/app.bsky.feed.post/1');
+
+        expect(post, isNotNull);
+        expect(post!.uri, 'at://did:plc:test123/app.bsky.feed.post/1');
+        expect(post.text, 'Hello world');
+        expect(post.authorDid, 'did:plc:test123');
+        expect(post.replyCount, 5);
+      });
+
+      test('returns null if no posts found', () async {
+        when(
+          () => mockApi.call(any(), params: any(named: 'params')),
+        ).thenAnswer((_) async => {'posts': <dynamic>[]});
+
+        final post = await repository.getPost('at://did:plc:test123/app.bsky.feed.post/1');
+
+        expect(post, isNull);
+      });
+    });
   });
 }
 
+Map<String, dynamic> _mockGetPostsResponse() => {
+  'posts': [
+    {
+      'uri': 'at://did:plc:test123/app.bsky.feed.post/1',
+      'cid': 'cid1',
+      'author': {
+        'did': 'did:plc:test123',
+        'handle': 'testuser.bsky.social',
+        'displayName': 'Test User',
+        'avatar': 'https://example.com/avatar.jpg',
+      },
+      'record': {'text': 'Hello world', 'createdAt': '2024-01-01T12:00:00.000Z'},
+      'indexedAt': '2024-01-01T12:00:00.000Z',
+      'replyCount': 5,
+      'repostCount': 3,
+      'likeCount': 10,
+      'viewer': {'like': 'at://did:plc:viewer/app.bsky.feed.like/123'},
+    },
+  ],
+};
+
 Map<String, dynamic> _mockProfileResponse({bool withViewer = false}) => {
   'did': 'did:plc:test123',
   'handle': 'testuser.bsky.social',
···
   'pronouns': 'they/them',
   'website': 'https://example.com',
   'verification': {'type': 'verified'},
+  'pinnedPost': {'uri': 'at://did:plc:test123/app.bsky.feed.post/pinned123', 'cid': 'cid123'},
   if (withViewer)
     'viewer': {
       'following': 'at://did:plc:viewer/app.bsky.graph.follow/abc123',

test/src/features/profile/profile_screen_test.dart

···
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/profile/application/profile_providers.dart';
+import 'package:lazurite/src/features/profile/infrastructure/profile_repository.dart';
 import 'package:lazurite/src/features/profile/presentation/profile_screen.dart';
 import 'package:mocktail/mocktail.dart';
 
···
 
 void main() {
   late MockSessionStorage mockSessionStorage;
+  late MockProfileRepository mockProfileRepository;
 
   setUp(() {
     mockSessionStorage = MockSessionStorage();
+    mockProfileRepository = MockProfileRepository();
   });
 
-  Widget createSubject() {
+  Widget createSubject({
+    required String did,
+    bool isCurrentUser = false,
+    List overrides = const [],
+  }) {
     return ProviderScope(
-      overrides: [sessionStorageProvider.overrideWithValue(mockSessionStorage)],
-      child: const MaterialApp(home: ProfileScreen()),
+      overrides: [
+        sessionStorageProvider.overrideWithValue(mockSessionStorage),
+        profileRepositoryProvider.overrideWithValue(mockProfileRepository),
+        ...overrides,
+      ],
+      child: MaterialApp(home: ProfilePage(did: did)),
     );
   }
 
···
     testWidgets('renders app bar with profile title', (tester) async {
       when(() => mockSessionStorage.getSession()).thenAnswer((_) async => null);
 
-      await tester.pumpWidget(createSubject());
+      await tester.pumpWidget(createSubject(did: 'did:plc:test'));
       await tester.pump();
 
       expect(find.text('Profile'), findsWidgets);
···
     testWidgets('shows sign in message when not authenticated', (tester) async {
       when(() => mockSessionStorage.getSession()).thenAnswer((_) async => null);
 
-      await tester.pumpWidget(createSubject());
+      await tester.pumpWidget(
+        ProviderScope(
+          overrides: [sessionStorageProvider.overrideWithValue(mockSessionStorage)],
+          child: const MaterialApp(home: ProfileScreen()),
+        ),
+      );
+
       await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
 
       expect(find.text('Sign in to view your profile'), findsOneWidget);
     });
+
+    testWidgets('displays pinned post when present', (tester) async {
+      final profile = ProfileData(
+        did: 'did:plc:test',
+        handle: 'test.bsky.social',
+        displayName: 'Test User',
+        pinnedPostUri: 'at://did:plc:test/app.bsky.feed.post/pinned',
+      );
+
+      final pinnedPost = FeedItem(
+        uri: 'at://did:plc:test/app.bsky.feed.post/pinned',
+        cid: 'cid1',
+        authorDid: 'did:plc:test',
+        authorHandle: 'test.bsky.social',
+        text: 'This is a pinned post',
+        indexedAt: DateTime.now(),
+      );
+
+      final feedItems = [
+        FeedItem(
+          uri: 'at://did:plc:test/app.bsky.feed.post/1',
+          cid: 'cid2',
+          authorDid: 'did:plc:test',
+          authorHandle: 'test.bsky.social',
+          text: 'Regular post',
+          indexedAt: DateTime.now(),
+        ),
+      ];
+
+      when(() => mockSessionStorage.getSession()).thenAnswer((_) async => null);
+
+      await tester.pumpWidget(
+        createSubject(
+          did: 'did:plc:test',
+          overrides: [
+            profileProvider('did:plc:test').overrideWith(() => MockProfileNotifier(profile)),
+            authorFeedProvider(
+              'did:plc:test',
+            ).overrideWith(() => MockAuthorFeedNotifier(feedItems)),
+            pinnedPostProvider(
+              'at://did:plc:test/app.bsky.feed.post/pinned',
+            ).overrideWith((ref) => Future.value(pinnedPost)),
+          ],
+        ),
+      );
+
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      expect(find.text('Pinned Post'), findsOneWidget);
+      expect(find.text('This is a pinned post'), findsOneWidget);
+      expect(find.text('Regular post'), findsOneWidget);
+    });
+
+    testWidgets('does not duplicate pinned post in feed', (tester) async {
+      final profile = ProfileData(
+        did: 'did:plc:test',
+        handle: 'test.bsky.social',
+        displayName: 'Test User',
+        pinnedPostUri: 'at://did:plc:test/app.bsky.feed.post/pinned',
+      );
+
+      final pinnedPost = FeedItem(
+        uri: 'at://did:plc:test/app.bsky.feed.post/pinned',
+        cid: 'cid1',
+        authorDid: 'did:plc:test',
+        authorHandle: 'test.bsky.social',
+        text: 'This is a pinned post',
+        indexedAt: DateTime.now(),
+      );
+
+      final feedItems = [
+        pinnedPost,
+        FeedItem(
+          uri: 'at://did:plc:test/app.bsky.feed.post/1',
+          cid: 'cid2',
+          authorDid: 'did:plc:test',
+          authorHandle: 'test.bsky.social',
+          text: 'Regular post',
+          indexedAt: DateTime.now(),
+        ),
+      ];
+
+      when(() => mockSessionStorage.getSession()).thenAnswer((_) async => null);
+
+      await tester.pumpWidget(
+        createSubject(
+          did: 'did:plc:test',
+          overrides: [
+            profileProvider('did:plc:test').overrideWith(() => MockProfileNotifier(profile)),
+            authorFeedProvider(
+              'did:plc:test',
+            ).overrideWith(() => MockAuthorFeedNotifier(feedItems)),
+            pinnedPostProvider(
+              'at://did:plc:test/app.bsky.feed.post/pinned',
+            ).overrideWith((ref) => Future.value(pinnedPost)),
+          ],
+        ),
+      );
+
+      await tester.pump();
+      await tester.pump(const Duration(milliseconds: 100));
+      await tester.pump(const Duration(milliseconds: 100));
+
+      expect(find.text('Pinned Post'), findsOneWidget);
+      expect(find.text('This is a pinned post'), findsOneWidget);
+      expect(find.text('Regular post'), findsOneWidget);
+    });
   });
 }
+
+class MockProfileRepository extends Mock implements ProfileRepository {}
+
+class MockProfileNotifier extends ProfileNotifier {
+  MockProfileNotifier(this._data);
+  final ProfileData _data;
+
+  @override
+  Future<ProfileData> build(String actor) async => _data;
+}
+
+class MockAuthorFeedNotifier extends AuthorFeedNotifier {
+  MockAuthorFeedNotifier(this._items);
+  final List<FeedItem> _items;
+
+  @override
+  Future<List<FeedItem>> build(String actor) async => _items;
+
+  @override
+  Future<void> loadMore() async {}
+
+  @override
+  Future<void> refresh() async {}
+
+  @override
+  bool get hasMore => false;
+}