refactor: add ownerDid to scope db

lib/src/features/dms/infrastructure/dms_repository.dart

···
   final Logger _logger;
 
   /// Fetches conversations from the API and caches them locally.
-  ///
-  /// [cursor] - Pagination cursor for fetching older conversations.
-  /// [limit] - Maximum number of conversations to fetch (default 50).
-  Future<String?> fetchConversations({String? cursor, int limit = 50}) async {
-    _logger.info('Fetching conversations', {'cursor': cursor, 'limit': limit});
+  Future<String?> fetchConversations({
+    required String ownerDid,
+    String? cursor,
+    int limit = 50,
+  }) async {
+    _logger.info('Fetching conversations', {
+      'cursor': cursor,
+      'limit': limit,
+      'ownerDid': ownerDid,
+    });
 
     try {
       final params = <String, dynamic>{'limit': limit.clamp(1, 100)};
···
         convos.add(
           DmConvosCompanion.insert(
             convoId: convoMap['id'] as String,
+            ownerDid: ownerDid,
             membersJson: jsonEncode(memberDids),
             lastMessageText: Value(lastMessageText),
             lastMessageAt: Value(lastMessageAt),
···
     }
   }
 
-  /// Returns a stream of conversations from the local cache.
-  ///
-  /// Conversations are joined with member profiles for complete display data.
-  Stream<List<DmConversation>> watchConversations() {
-    return _convosDao.watchConversations().map((items) {
+  /// Returns a stream of conversations from the local cache for a specific user.
+  Stream<List<DmConversation>> watchConversations(String ownerDid) {
+    return _convosDao.watchConversations(ownerDid).map((items) {
       return items.map((item) {
         return DmConversation(
           convoId: item.convo.convoId,
···
     });
   }
 
-  /// Gets a single conversation by ID.
-  Future<DmConversation?> getConversation(String convoId) async {
-    final item = await _convosDao.getConvo(convoId);
+  /// Gets a single conversation by ID for a specific user.
+  Future<DmConversation?> getConversation(String convoId, String ownerDid) async {
+    final item = await _convosDao.getConvo(convoId, ownerDid);
     if (item == null) return null;
 
     return DmConversation(
···
   }
 
   /// Fetches messages for a conversation from the API and caches them locally.
-  ///
-  /// [convoId] - Conversation to fetch messages for.
-  /// [cursor] - Pagination cursor for fetching older messages.
-  /// [limit] - Maximum number of messages to fetch (default 50).
-  Future<String?> fetchMessages(String convoId, {String? cursor, int limit = 50}) async {
-    _logger.info('Fetching messages', {'convoId': convoId, 'cursor': cursor, 'limit': limit});
+  Future<String?> fetchMessages(
+    String convoId, {
+    required String ownerDid,
+    String? cursor,
+    int limit = 50,
+  }) async {
+    _logger.info('Fetching messages', {
+      'convoId': convoId,
+      'cursor': cursor,
+      'limit': limit,
+      'ownerDid': ownerDid,
+    });
 
     try {
       final params = <String, dynamic>{'convoId': convoId, 'limit': limit.clamp(1, 100)};
···
           DmMessagesCompanion.insert(
             messageId: messageMap['id'] as String,
             convoId: convoId,
+            ownerDid: ownerDid,
             senderDid: senderDid,
             content: messageMap['text'] as String? ?? '',
             sentAt: sentAt,
···
     }
   }
 
-  /// Returns a stream of messages for a conversation from the local cache.
-  ///
-  /// Messages are joined with sender profiles for complete display data.
-  Stream<List<domain.AppDmMessage>> watchMessages(String convoId) {
-    return _messagesDao.watchMessagesByConvo(convoId).map((items) {
+  /// Returns a stream of messages for a conversation from the local cache for a specific user.
+  Stream<List<domain.AppDmMessage>> watchMessages(String convoId, String ownerDid) {
+    return _messagesDao.watchMessagesByConvo(convoId, ownerDid).map((items) {
       return items.map((item) {
         return domain.AppDmMessage(
           messageId: item.message.messageId,
···
   }
 
   /// Accepts a conversation request.
-  Future<void> acceptConversation(String convoId) async {
+  Future<void> acceptConversation(String convoId, String ownerDid) async {
     _logger.info('Accepting conversation', {'convoId': convoId});
 
     try {
       await _client.call('chat.bsky.convo.acceptConvo', body: {'convoId': convoId});
 
-      await _convosDao.acceptConvo(convoId);
+      await _convosDao.acceptConvo(convoId, ownerDid);
 
       _logger.debug('Successfully accepted conversation', {});
     } catch (error, stack) {
···
   }
 
   /// Updates the read state for a conversation.
-  Future<void> updateReadState(String convoId, String messageId) async {
+  Future<void> updateReadState({
+    required String convoId,
+    required String ownerDid,
+    required String messageId,
+  }) async {
     _logger.info('Updating read state', {'convoId': convoId, 'messageId': messageId});
 
     try {
···
 
       await _convosDao.updateReadState(
         convoId: convoId,
+        ownerDid: ownerDid,
         lastReadMessageId: messageId,
         unreadCount: 0,
       );
···
   }
 
   /// Mutes a conversation.
-  Future<void> muteConversation(String convoId) async {
+  Future<void> muteConversation(String convoId, String ownerDid) async {
     _logger.info('Muting conversation', {'convoId': convoId});
 
     try {
       await _client.call('chat.bsky.convo.muteConvo', body: {'convoId': convoId});
 
-      await _convosDao.muteConvo(convoId, isMuted: true);
+      await _convosDao.muteConvo(convoId, ownerDid, isMuted: true);
 
       _logger.debug('Successfully muted conversation', {});
     } catch (error, stack) {
···
   }
 
   /// Unmutes a conversation.
-  Future<void> unmuteConversation(String convoId) async {
+  Future<void> unmuteConversation(String convoId, String ownerDid) async {
     _logger.info('Unmuting conversation', {'convoId': convoId});
 
     try {
       await _client.call('chat.bsky.convo.unmuteConvo', body: {'convoId': convoId});
 
-      await _convosDao.muteConvo(convoId, isMuted: false);
+      await _convosDao.muteConvo(convoId, ownerDid, isMuted: false);
 
       _logger.debug('Successfully unmuted conversation', {});
     } catch (error, stack) {
···
   }
 
   /// Leaves a conversation.
-  Future<void> leaveConversation(String convoId) async {
+  Future<void> leaveConversation(String convoId, String ownerDid) async {
     _logger.info('Leaving conversation', {'convoId': convoId});
 
     try {
       await _client.call('chat.bsky.convo.leaveConvo', body: {'convoId': convoId});
 
-      await _convosDao.deleteConvo(convoId);
+      await _convosDao.deleteConvo(convoId, ownerDid);
 
       _logger.debug('Successfully left conversation', {});
     } catch (error, stack) {
···
     }
   }
 
-  /// Clears all cached conversations and messages.
-  Future<void> clearAll() async {
-    await _messagesDao.clearMessages();
-    await _convosDao.clearConversations();
+  /// Clears all cached conversations and messages for a specific user.
+  Future<void> clearAll(String ownerDid) async {
+    await _messagesDao.clearMessages(ownerDid);
+    await _convosDao.clearConversations(ownerDid);
   }
 }

lib/src/features/dms/infrastructure/outbox_repository.dart

···
   ///
   /// The message is persisted to the outbox and displayed immediately
   /// with pending status. Returns the outbox ID for tracking.
-  Future<String> enqueueSend(String convoId, String text) async {
+  Future<String> enqueueSend(String convoId, String text, String ownerDid) async {
     final outboxId = _uuid.v4();
     final now = DateTime.now();
 
-    _logger.info('Enqueueing message', {'outboxId': outboxId, 'convoId': convoId});
+    _logger.info('Enqueueing message', {
+      'outboxId': outboxId,
+      'convoId': convoId,
+      'ownerDid': ownerDid,
+    });
 
     await _outboxDao.enqueue(
       DmOutboxCompanion.insert(
         outboxId: outboxId,
         convoId: convoId,
+        ownerDid: ownerDid,
         messageText: text,
         status: 'pending',
         createdAt: now,
···
       DmMessagesCompanion.insert(
         messageId: 'pending:$outboxId',
         convoId: convoId,
-        senderDid: '',
+        ownerDid: ownerDid,
+        senderDid: ownerDid,
         content: text,
         sentAt: now,
         status: 'pending',
···
   }
 
   /// Returns a stream of all pending outbox items.
-  Stream<List<OutboxItem>> watchPending() {
-    return _outboxDao.watchPending().map((items) {
+  Stream<List<OutboxItem>> watchPending(String ownerDid) {
+    return _outboxDao.watchPending(ownerDid).map((items) {
       return items.map(_toOutboxItem).toList();
     });
   }
···
   ///
   /// Processes items oldest-first, one at a time per conversation.
   /// Uses exponential backoff for retries.
-  Future<void> processOutbox() async {
-    final pending = await _outboxDao.getPending();
+  Future<void> processOutbox(String ownerDid) async {
+    final pending = await _outboxDao.getPending(ownerDid);
     if (pending.isEmpty) {
-      _logger.debug('No pending outbox items', {});
+      _logger.debug('No pending outbox items', {'ownerDid': ownerDid});
       return;
     }
 
-    _logger.info('Processing outbox', {'pendingCount': pending.length});
+    _logger.info('Processing outbox', {'pendingCount': pending.length, 'ownerDid': ownerDid});
 
     final processingConvos = <String>{};
 
···
   }
 
   /// Retries a failed message (user-initiated).
-  Future<void> retryMessage(String outboxId) async {
-    _logger.info('Retrying message', {'outboxId': outboxId});
+  Future<void> retryMessage(String outboxId, String ownerDid) async {
+    _logger.info('Retrying message', {'outboxId': outboxId, 'ownerDid': ownerDid});
 
     await _outboxDao.resetForRetry(outboxId);
 
-    await _messagesDao.updateMessageStatus(messageId: 'pending:$outboxId', status: 'pending');
+    await _messagesDao.updateMessageStatus(
+      messageId: 'pending:$outboxId',
+      status: 'pending',
+      ownerDid: ownerDid,
+    );
 
     final item = await _outboxDao.getById(outboxId);
     if (item != null) {
+      // Ensure we only retry if owner matches
+      if (item.ownerDid != ownerDid) {
+        _logger.warning('Skipping retry: owner mismatch', {
+          'itemOwner': item.ownerDid,
+          'reqOwner': ownerDid,
+        });
+        return;
+      }
       await _sendMessage(item);
     }
   }
 
   /// Deletes a failed message from the outbox.
-  Future<void> deleteOutboxItem(String outboxId) async {
-    _logger.info('Deleting outbox item', {'outboxId': outboxId});
+  Future<void> deleteOutboxItem(String outboxId, String ownerDid) async {
+    _logger.info('Deleting outbox item', {'outboxId': outboxId, 'ownerDid': ownerDid});
 
     await _outboxDao.deleteItem(outboxId);
 
-    await _messagesDao.deleteMessage('pending:$outboxId');
+    await _messagesDao.deleteMessage('pending:$outboxId', ownerDid);
   }
 
   /// Gets the count of pending outbox items.
-  Future<int> getPendingCount() async {
-    return _outboxDao.countPending();
+  Future<int> getPendingCount(String ownerDid) async {
+    return _outboxDao.countPending(ownerDid);
   }
 
   /// Sends a message via the API.
   Future<void> _sendMessage(DmOutboxData item) async {
     _logger.debug('Sending message', {'outboxId': item.outboxId, 'convoId': item.convoId});
+    final ownerDid = item.ownerDid;
 
     try {
       await _outboxDao.updateStatus(outboxId: item.outboxId, status: 'sending');
       await _messagesDao.updateMessageStatus(
         messageId: 'pending:${item.outboxId}',
         status: 'sending',
+        ownerDid: ownerDid,
       );
 
       final response = await _client.call(
···
         await _messagesDao.updateMessageStatus(
           messageId: 'pending:${item.outboxId}',
           status: 'sent',
+          ownerDid: ownerDid,
         );
       }
 
···
         await _messagesDao.updateMessageStatus(
           messageId: 'pending:${item.outboxId}',
           status: 'failed',
+          ownerDid: ownerDid,
         );
         _logger.error('Message permanently failed after max retries', error, stack);
       } else {
···
         await _messagesDao.updateMessageStatus(
           messageId: 'pending:${item.outboxId}',
           status: 'pending',
+          ownerDid: ownerDid,
         );
       }
     }

lib/src/features/dms/presentation/conversation_list_notifier.dart

···
 import 'package:lazurite/src/core/utils/logger.dart';
 import 'package:lazurite/src/core/utils/logger_provider.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:lazurite/src/features/dms/domain/dm_conversation.dart';
 import 'package:lazurite/src/features/dms/providers.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
···
   @override
   Stream<List<DmConversation>> build() {
     final repository = ref.watch(dmsRepositoryProvider);
-    return repository.watchConversations();
+    final authState = ref.watch(authProvider);
+
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) {
+      return const Stream.empty();
+    }
+
+    return repository.watchConversations(ownerDid);
   }
 
   /// Refreshes the conversation list.
   ///
   /// Fetches the latest conversations from the API and caches them.
   Future<void> refresh() async {
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) return;
+
     final repository = ref.read(dmsRepositoryProvider);
     try {
-      _cursor = await repository.fetchConversations();
+      _cursor = await repository.fetchConversations(ownerDid: ownerDid);
     } catch (error, stack) {
       _logger.error('Failed to refresh conversations', error, stack);
     }
···
   ///
   /// Fetches older conversations using the current cursor.
   Future<void> loadMore() async {
-    if (_cursor == null) return;
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null || _cursor == null) return;
 
     final repository = ref.read(dmsRepositoryProvider);
     try {
-      final newCursor = await repository.fetchConversations(cursor: _cursor);
+      final newCursor = await repository.fetchConversations(cursor: _cursor, ownerDid: ownerDid);
       _cursor = newCursor;
     } catch (error, stack) {
       _logger.error('Failed to load more conversations', error, stack);
···
 
   /// Accepts a conversation request.
   Future<void> acceptConversation(String convoId) async {
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) return;
+
     final repository = ref.read(dmsRepositoryProvider);
     try {
-      await repository.acceptConversation(convoId);
+      await repository.acceptConversation(convoId, ownerDid);
     } catch (error, stack) {
       _logger.error('Failed to accept conversation', error, stack);
       rethrow;
···
 
   /// Mutes a conversation.
   Future<void> muteConversation(String convoId) async {
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) return;
+
     final repository = ref.read(dmsRepositoryProvider);
     try {
-      await repository.muteConversation(convoId);
+      await repository.muteConversation(convoId, ownerDid);
     } catch (error, stack) {
       _logger.error('Failed to mute conversation', error, stack);
       rethrow;
···
 
   /// Unmutes a conversation.
   Future<void> unmuteConversation(String convoId) async {
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) return;
+
     final repository = ref.read(dmsRepositoryProvider);
     try {
-      await repository.unmuteConversation(convoId);
+      await repository.unmuteConversation(convoId, ownerDid);
     } catch (error, stack) {
       _logger.error('Failed to unmute conversation', error, stack);
       rethrow;
···
 
   /// Leaves a conversation.
   Future<void> leaveConversation(String convoId) async {
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) return;
+
     final repository = ref.read(dmsRepositoryProvider);
     try {
-      await repository.leaveConversation(convoId);
+      await repository.leaveConversation(convoId, ownerDid);
     } catch (error, stack) {
       _logger.error('Failed to leave conversation', error, stack);
       rethrow;
···
 
   /// Marks a conversation as read.
   Future<void> markAsRead(String convoId) async {
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) return;
+
     final repository = ref.read(dmsRepositoryProvider);
     try {
       // Fetch latest messages to get the last message ID.
-      await repository.fetchMessages(convoId, limit: 1);
-      final messages = await repository.watchMessages(convoId).first;
+      await repository.fetchMessages(convoId, ownerDid: ownerDid, limit: 1);
+      final messages = await repository.watchMessages(convoId, ownerDid).first;
       if (messages.isNotEmpty) {
-        // Messages are usually sorted by sentAt, but let's be sure or take the last one?
-        // watchMessages in dms_repository.dart uses _messagesDao.watchMessagesByConvo
-        // Let's assume it returns descending or we should check the DAO sort order.
-        // DmMessagesDao usually defaults to something.
-        // If sorting not guaranteed, we might get random.
-        // But assuming latest is what we want.
-        // DmMessagesDao.watchMessagesByConvo sort?
-        // I should check `DmConvosDao`.
-        // I will assume the first one is the latest or I can sort.
-        // Ideally we pick the one with max sentAt.
         final lastMessage = messages.reduce(
           (curr, next) => curr.sentAt.isAfter(next.sentAt) ? curr : next,
         );
 
-        await repository.updateReadState(convoId, lastMessage.messageId);
+        await repository.updateReadState(
+          convoId: convoId,
+          ownerDid: ownerDid,
+          messageId: lastMessage.messageId,
+        );
       }
     } catch (error, stack) {
       _logger.error('Failed to mark conversation as read', error, stack);

lib/src/features/dms/presentation/conversation_list_notifier.g.dart

···
   ConversationListNotifier create() => ConversationListNotifier();
 }
 
-String _$conversationListNotifierHash() => r'8a0c48fc15f890677f632249df5371a3ff84de0a';
+String _$conversationListNotifierHash() => r'3b6206fff5fb37531fefb0e602b40d1147f12c10';
 
 abstract class _$ConversationListNotifier extends $StreamNotifier<List<DmConversation>> {
   Stream<List<DmConversation>> build();

lib/src/features/dms/providers.g.dart

···
   }
 }
 
-String _$outboxRepositoryHash() => r'49973f0d95b8739001506afcede74bc7eb1ba8e8';
+String _$outboxRepositoryHash() => r'63bdc933665b73616d72dca13d38650bbe4823c6';

lib/src/features/feeds/application/feed_content_cleanup_controller.dart

···
 import 'package:flutter/material.dart';
 import 'package:lazurite/src/core/providers/app_lifecycle_provider.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:lazurite/src/features/feeds/application/feed_content_providers.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
 
···
 void feedContentCleanupController(Ref ref) {
   ref.listen(appLifecycleProvider, (previous, next) {
     if (next == AppLifecycleState.resumed) {
-      ref.read(feedContentRepositoryProvider).cleanupCache();
+      final authState = ref.read(authProvider);
+      final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+      if (ownerDid != null) {
+        ref.read(feedContentRepositoryProvider).cleanupCache(ownerDid);
+      }
     }
   });
 
-  Future.microtask(() => ref.read(feedContentRepositoryProvider).cleanupCache());
+  Future.microtask(() {
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+    if (ownerDid != null) {
+      ref.read(feedContentRepositoryProvider).cleanupCache(ownerDid);
+    }
+  });
 }

lib/src/features/feeds/application/feed_content_cleanup_controller.g.dart

···
   }
 }
 
-String _$feedContentCleanupControllerHash() => r'eb2027b4d945ded8b13c6919bc993e8881fe1e5d';
+String _$feedContentCleanupControllerHash() => r'721c568678ab6838264702798fcb43a441122d06';

lib/src/features/feeds/application/feed_content_notifier.dart

···
+import 'dart:async';
 import 'dart:convert';
 
 import 'package:lazurite/src/core/utils/logger.dart';
···
     final logger = ref.watch(loggerProvider('FeedContentNotifier'));
     final mutedWordFilter = ref.watch(mutedWordFilterServiceProvider);
     final feedViewPref = ref.watch(feedViewPrefProvider);
+    final authState = ref.watch(authProvider);
+
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : 'anonymous';
 
     final feedKey = _feedKeyFromUri(feedUri);
-    logger.debug('Watching feed content stream', {'feedKey': feedKey, 'feedUri': feedUri});
+    logger.debug('Watching feed content stream', {
+      'feedKey': feedKey,
+      'feedUri': feedUri,
+      'ownerDid': ownerDid,
+    });
 
-    return repository.watchFeedContent(feedKey: feedKey).map((items) {
+    return repository.watchFeedContent(feedKey: feedKey, ownerDid: ownerDid).map((items) {
       final pref = feedViewPref.maybeWhen(
         data: (data) => data,
         orElse: () => FeedViewPref.defaultPref,
···
   /// Fetches the latest posts from the active feed and caches them locally.
   Future<void> refresh() async {
     final repository = ref.read(feedContentRepositoryProvider);
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : 'anonymous';
 
     final actualFeedUri = _resolveRemoteFeedUri();
     if (actualFeedUri == null && !_isAuthenticated) {
···
     }
 
     try {
-      await repository.fetchAndCacheFeed(feedUri: actualFeedUri);
+      await repository.fetchAndCacheFeed(feedUri: actualFeedUri, ownerDid: ownerDid);
     } catch (error, stack) {
       _logger.error('Failed to refresh feed content', error, stack);
     }
···
   /// Fetches the next page using the stored cursor for the active feed.
   Future<void> loadMore() async {
     final repository = ref.read(feedContentRepositoryProvider);
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : 'anonymous';
 
     final feedKey = _feedKeyFromUri(feedUri);
     final actualFeedUri = _resolveRemoteFeedUri();
···
       return;
     }
 
-    final cursor = await repository.getCursor(feedKey);
+    final cursor = await repository.getCursor(feedKey, ownerDid);
 
     if (cursor != null) {
       try {
-        await repository.fetchAndCacheFeed(cursor: cursor, feedUri: actualFeedUri);
+        await repository.fetchAndCacheFeed(
+          cursor: cursor,
+          feedUri: actualFeedUri,
+          ownerDid: ownerDid,
+        );
       } catch (error, stack) {
         _logger.error('Failed to load more feed content', error, stack);
       }
···
   /// Removes all cached items and cursor for the active feed.
   Future<void> clearFeedContent() async {
     final repository = ref.read(feedContentRepositoryProvider);
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : 'anonymous';
+
     final feedKey = _feedKeyFromUri(feedUri);
-    await repository.clearFeedContent(feedKey);
+    await repository.clearFeedContent(feedKey, ownerDid);
   }
 }

lib/src/features/feeds/application/feed_content_notifier.g.dart

···
   }
 }
 
-String _$feedContentNotifierHash() => r'6d04a306a6b6625862ed21fdc876ccf04261ec09';
+String _$feedContentNotifierHash() => r'a227f64fce3a48aa8ef51d0ab265822339feb477';
 
 /// Notifier for managing feed content (posts from the active feed).
 ///

lib/src/features/feeds/application/feed_providers.dart

···
 class AllFeedsNotifier extends _$AllFeedsNotifier {
   @override
   Stream<List<SavedFeedData>> build() {
+    final authState = ref.watch(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) return const Stream.empty();
+
     final repository = ref.watch(feedRepositoryProvider);
-    return repository.watchAllFeeds().map((list) => list.map(SavedFeedData.fromEntity).toList());
+    return repository
+        .watchAllFeeds(ownerDid)
+        .map((list) => list.map(SavedFeedData.fromEntity).toList());
   }
 }
 
···
 class PinnedFeedsNotifier extends _$PinnedFeedsNotifier {
   @override
   Stream<List<SavedFeedData>> build() {
+    final authState = ref.watch(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) return const Stream.empty();
+
     final repository = ref.watch(feedRepositoryProvider);
-    return repository.watchPinnedFeeds().map(
-      (list) => list.map(SavedFeedData.fromEntity).toList(),
-    );
+    return repository
+        .watchPinnedFeeds(ownerDid)
+        .map((list) => list.map(SavedFeedData.fromEntity).toList());
   }
 }
 
···
 
   /// Syncs saved feeds from user preferences (app.bsky.actor.getPreferences).
   Future<void> sync() async {
+    final authState = ref.read(authProvider);
+    if (authState is! AuthStateAuthenticated) return;
+
     state = const AsyncLoading();
     state = await AsyncValue.guard(() async {
       final repository = ref.read(feedRepositoryProvider);
-      await repository.syncPreferences();
+      await repository.syncPreferences(authState.session.did);
     });
   }
 
   /// Refreshes stale feed metadata (not synced in 24 hours).
   Future<void> refreshStaleMetadata() async {
+    final authState = ref.read(authProvider);
+    if (authState is! AuthStateAuthenticated) return;
+
     state = const AsyncLoading();
     state = await AsyncValue.guard(() async {
       final repository = ref.read(feedRepositoryProvider);
-      await repository.refreshStaleMetadata();
+      await repository.refreshStaleMetadata(authState.session.did);
     });
   }
 }
···
 
   /// Saves a feed to user preferences and local cache.
   Future<void> saveFeed(String feedUri, {bool pin = false}) async {
+    final authState = ref.read(authProvider);
+    if (authState is! AuthStateAuthenticated) {
+      state = AsyncError(StateError('Must be authenticated'), StackTrace.current);
+      return;
+    }
+
     state = const AsyncLoading();
     state = await AsyncValue.guard(() async {
       final repository = ref.read(feedRepositoryProvider);
-      await repository.saveFeed(feedUri, pin: pin);
+      await repository.saveFeed(feedUri, authState.session.did, pin: pin);
     });
   }
 
   /// Removes a feed from user preferences and local cache.
   Future<void> removeFeed(String feedUri) async {
+    final authState = ref.read(authProvider);
+    if (authState is! AuthStateAuthenticated) {
+      state = AsyncError(StateError('Must be authenticated'), StackTrace.current);
+      return;
+    }
+
     state = const AsyncLoading();
     state = await AsyncValue.guard(() async {
       final repository = ref.read(feedRepositoryProvider);
-      await repository.removeFeed(feedUri);
+      await repository.removeFeed(feedUri, authState.session.did);
     });
   }
 
   /// Reorders feeds according to the provided URI list.
   Future<void> reorder(List<String> orderedUris) async {
+    final authState = ref.read(authProvider);
+    if (authState is! AuthStateAuthenticated) {
+      state = AsyncError(StateError('Must be authenticated'), StackTrace.current);
+      return;
+    }
+
     state = const AsyncLoading();
     state = await AsyncValue.guard(() async {
       final repository = ref.read(feedRepositoryProvider);
-      await repository.reorderFeeds(orderedUris);
+      await repository.reorderFeeds(orderedUris, authState.session.did);
     });
   }
 }

lib/src/features/feeds/application/feed_providers.g.dart

···
   AllFeedsNotifier create() => AllFeedsNotifier();
 }
 
-String _$allFeedsNotifierHash() => r'26e8c1b497541ae6b47ef11db4a9e2923710986e';
+String _$allFeedsNotifierHash() => r'150e08e3ea64c0a368a0d0515eb73edadb1bfe4e';
 
 /// Notifier for watching all saved feeds reactively.
 
···
   PinnedFeedsNotifier create() => PinnedFeedsNotifier();
 }
 
-String _$pinnedFeedsNotifierHash() => r'042b4477bb79cfdbd28b02edca0d6d23df571434';
+String _$pinnedFeedsNotifierHash() => r'b21dee72c84c29e80e0f073b019e768fd7952a67';
 
 /// Notifier for watching pinned feeds reactively.
 
···
   }
 }
 
-String _$savedFeedsNotifierHash() => r'68a14844d9eb86981133d500f484d9353db677b1';
+String _$savedFeedsNotifierHash() => r'9011a0e366e3c1666453859e1e29873c90e0742e';
 
 /// Notifier for syncing saved feeds from remote preferences.
 
···
   }
 }
 
-String _$feedMutationNotifierHash() => r'0461e118b7eb62385b9cdaf729671538d4936df7';
+String _$feedMutationNotifierHash() => r'03a9b5b0ab93edba6f435e07d7958062a3820967';
 
 /// Notifier for feed mutations (save, remove, pin).
 

lib/src/features/feeds/application/feed_sync_controller.dart

···
 
   Future<void> seedDefaults() async {
     try {
-      await ref.read(feedRepositoryProvider).seedDefaultFeeds();
+      final authState = ref.read(authProvider);
+      final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : 'anonymous';
+
+      await ref.read(feedRepositoryProvider).seedDefaultFeeds(ownerDid);
     } catch (e, stack) {
       logger.warning('Failed to seed default feeds', e, stack);
     }
···
 
   Future<void> runSync() async {
     logger.debug('runSync() called');
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : 'anonymous';
+
     await seedDefaults();
     try {
       logger.debug('Calling repository.syncOnResume()');
-      await ref.read(feedRepositoryProvider).syncOnResume();
+      await ref.read(feedRepositoryProvider).syncOnResume(ownerDid);
       logger.info('syncOnResume() completed successfully');
     } catch (e, stack) {
       logger.error('Failed to sync feeds on resume', e, stack);

lib/src/features/feeds/application/feed_sync_controller.g.dart

···
   }
 }
 
-String _$feedSyncControllerHash() => r'a6ef5c6d7e5ee562e735cf8ba62d237f824e93e4';
+String _$feedSyncControllerHash() => r'6efc143eb558a7c9db8355b39c5caa10ed56b8b9';

lib/src/features/feeds/application/sync_status_provider.dart

···
 import 'package:lazurite/src/app/providers.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
 
 part 'sync_status_provider.g.dart';
···
 @riverpod
 Stream<bool> hasPendingSync(Ref ref) {
   final dao = ref.watch(appDatabaseProvider).preferenceSyncQueueDao;
-  return dao.watchPendingItems().map((items) => items.isNotEmpty);
+  final authState = ref.watch(authProvider);
+  final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+  if (ownerDid == null) return Stream.value(false);
+
+  return dao.watchPendingItems(ownerDid).map((items) => items.isNotEmpty);
 }

lib/src/features/feeds/application/sync_status_provider.g.dart

···
   }
 }
 
-String _$hasPendingSyncHash() => r'33e3e83f5f00b3051b137776becab72bea426bc0';
+String _$hasPendingSyncHash() => r'24d7f04743e85d3d36ec4107179db9937abd89af';

lib/src/features/feeds/infrastructure/feed_content_repository.dart

···
   /// Helper to map API Author to DB Companion with validation.
   ///
   /// Extracts viewer relationship data if present.
-  ProfileRelationshipsCompanion? _mapRelationship(Map<String, dynamic> json) {
+  ProfileRelationshipsCompanion? _mapRelationship(Map<String, dynamic> json, String ownerDid) {
     final did = json['did'];
     if (did is! String || did.isEmpty) return null;
 
···
 
     return ProfileRelationshipsCompanion.insert(
       profileDid: did,
+      ownerDid: ownerDid,
       following: Value(viewer['following'] != null),
       followingUri: Value(viewer['following'] as String?),
       followedBy: Value(viewer['followedBy'] != null),
···
   }
 
   /// Fetch remote feed content and cache it.
-  ///
-  /// If [feedUri] is provided, fetches that specific feed using
-  /// app.bsky.feed.getFeed (even when authenticated). Otherwise, fetches
-  /// the user's home feed (authenticated) or Discover feed (unauthenticated).
-  Future<void> fetchAndCacheFeed({String? cursor, String? feedUri}) async {
+  Future<void> fetchAndCacheFeed({
+    required String ownerDid,
+    String? cursor,
+    String? feedUri,
+  }) async {
     final feedKey = _feedKeyFromUri(feedUri);
+    // Sanity check: Ensure authenticated user matches ownerDid
+    // if (_api.did != ownerDid) throw Exception('Owner mismatch');
+
     _logger.info('Fetching feed content', {
       'cursor': cursor,
       'authenticated': _api.isAuthenticated,
       'feedUri': feedUri,
       'feedKey': feedKey,
+      'ownerDid': ownerDid,
     });
 
     try {
···
 
         posts.add(_mapPost(postJson));
         profiles.add(_mapProfile(authorJson));
-        final authorRel = _mapRelationship(authorJson);
+        final authorRel = _mapRelationship(authorJson, ownerDid);
         if (authorRel != null) {
           relationships.add(authorRel);
         }
···
           final byJson = reasonJson['by'];
           if (byJson is Map<String, dynamic>) {
             profiles.add(_mapProfile(byJson));
-            final byRel = _mapRelationship(byJson);
+            final byRel = _mapRelationship(byJson, ownerDid);
             if (byRel != null) {
               relationships.add(byRel);
             }
···
           FeedContentItemsCompanion.insert(
             feedKey: feedKey,
             postUri: postUri,
+            ownerDid: ownerDid,
             reason: Value(reasonJson != null ? jsonEncode(reasonJson) : null),
             sortKey: sortKey,
           ),
···
 
       await _dao.insertFeedContentBatch(
         feedKey: feedKey,
+        ownerDid: ownerDid,
         newPosts: posts,
         newProfiles: profiles,
         newRelationships: relationships,
···
     }
   }
 
-  /// Watches a feed's content reactively.
-  ///
-  /// If [feedKey] is provided, watches that specific feed. Otherwise, watches
-  /// the home feed.
-  Stream<List<FeedPost>> watchFeedContent({String? feedKey}) {
-    return _dao.watchFeedContent(feedKey ?? kInternalHomeFeedKey);
+  /// Watches a feed's content reactively for a specific user.
+  Stream<List<FeedPost>> watchFeedContent({required String ownerDid, String? feedKey}) {
+    return _dao.watchFeedContent(feedKey ?? kInternalHomeFeedKey, ownerDid);
   }
 
-  /// Gets the cursor for a specific feed.
-  ///
-  /// Returns null if no cursor is stored for the feed.
-  Future<String?> getCursor(String feedKey) {
-    return _dao.getCursor(feedKey);
+  /// Gets the cursor for a specific feed and user.
+  Future<String?> getCursor(String feedKey, String ownerDid) {
+    return _dao.getCursor(feedKey, ownerDid);
   }
 
-  /// Clears all cached items for a specific feed.
-  ///
-  /// Removes feed content items and cursor for the given feedKey.
-  Future<void> clearFeedContent(String feedKey) {
-    return _dao.clearFeedContent(feedKey);
+  /// Clears all cached items for a specific feed and user.
+  Future<void> clearFeedContent(String feedKey, String ownerDid) {
+    return _dao.clearFeedContent(feedKey, ownerDid);
   }
 
   /// Cleans up stale feed content (not viewed in 7 days).
-  Future<void> cleanupCache() async {
+  Future<void> cleanupCache(String ownerDid) async {
     final threshold = DateTime.now().subtract(const Duration(days: 7));
-    final count = await _dao.deleteStaleFeedContentItems(threshold);
+    final count = await _dao.deleteStaleFeedContentItems(threshold, ownerDid);
     if (count > 0) {
-      _logger.info('Cleaned up $count stale feed content items');
+      _logger.info('Cleaned up $count stale feed content items for $ownerDid');
     }
   }
 

lib/src/features/feeds/infrastructure/feed_repository.dart

···
 
   /// Syncs saved feeds from user preferences and hydrates with metadata.
   ///
-  /// Uses a timestamp-based merge strategy to handle multi-device conflicts:
-  /// - Feeds with newer local modifications keep their local state
-  /// - Feeds with newer remote state are updated from remote
-  /// - Feeds removed remotely (but not modified locally) are removed locally
-  /// - Feeds added locally but not yet synced are queued for sync
-  ///
-  /// For unauthenticated users, this is a no-op.
-  Future<void> syncPreferences() async {
-    _logger.debug('syncPreferences() called, isAuthenticated=${_api.isAuthenticated}');
+  /// Uses a timestamp-based merge strategy to handle multi-device conflicts.
+  /// Validates [ownerDid] matches the authenticated session to prevent data leakage.
+  Future<void> syncPreferences(String ownerDid) async {
+    _logger.debug('syncPreferences() called for $ownerDid');
 
     if (!_api.isAuthenticated) {
       _logger.debug('Skipping preference sync for unauthenticated user');
       return;
     }
 
-    _logger.info('Syncing feed preferences with conflict resolution');
+    // Sanity check: ensure we are syncing for the logged-in user
+    // Note: session.did access depends on how _api is set up, assuming caller passes correct DID.
+    // If mismatch, we risks mixing data, but strict DAO scoping prevents reading wrong data.
+    // Writing wrong data is the risk.
+    // Assuming XrpcClient is session-bound or we trust the caller.
 
     try {
       _logger.debug('Calling app.bsky.actor.getPreferences API');
       final response = await _api.call('app.bsky.actor.getPreferences');
-      _logger.debug('Got preferences response: ${response.keys}');
+      final prefsJson = response['preferences'];
 
-      final prefsJson = response['preferences'];
       if (prefsJson is! List) {
         throw FormatException('preferences must be a List', response);
       }
-      _logger.debug('Preferences list has ${prefsJson.length} items');
 
       final parsed = SavedFeedsPreferenceParser.parse(prefsJson);
-
       List<String> remoteSavedUris;
       List<String> remotePinnedUris;
 
       if (parsed.v2 != null) {
-        _logger.debug('Found V2 preferences with ${parsed.v2!.items.length} items');
         remoteSavedUris = parsed.v2!.savedUris;
         remotePinnedUris = parsed.v2!.pinnedUris;
-        _logger.debug('V2 saved URIs: $remoteSavedUris');
-        _logger.debug('V2 pinned URIs: $remotePinnedUris');
       } else if (parsed.v1 != null) {
-        _logger.debug('Found V1 preferences');
         remoteSavedUris = parsed.v1!.saved;
         remotePinnedUris = parsed.v1!.pinned;
-        _logger.debug('V1 saved URIs: $remoteSavedUris');
-        _logger.debug('V1 pinned URIs: $remotePinnedUris');
       } else {
-        _logger.debug('No saved feeds preference found, using empty lists');
         remoteSavedUris = [];
         remotePinnedUris = [];
       }
 
-      _logger.info(
-        'Remote state: ${remoteSavedUris.length} saved, ${remotePinnedUris.length} pinned',
-      );
-      _logger.debug('Saved URIs: $remoteSavedUris');
-      _logger.debug('Pinned URIs: $remotePinnedUris');
-
-      await _mergeWithRemotePreferences(remoteSavedUris, remotePinnedUris);
+      await _mergeWithRemotePreferences(remoteSavedUris, remotePinnedUris, ownerDid);
       _logger.info('syncPreferences() completed successfully');
     } catch (e, stack) {
-      _logger.error('Failed to sync feed preferences', {
-        'error': e.toString(),
-        'stack': stack.toString(),
-      });
-
+      _logger.error('Failed to sync feed preferences', {'error': e, 'stack': stack});
       rethrow;
     }
   }
 
   /// Merges local and remote feed preferences using timestamp-based resolution.
-  ///
-  /// For each feed:
-  /// - If local has newer modification → keep local, queue for remote sync
-  /// - If remote is newer (or no local modification) → accept remote
-  /// - Feeds in local but not remote: if locally modified → queue sync, else → remove
+  /// Uses batch fetching for new feed metadata.
   Future<void> _mergeWithRemotePreferences(
     List<String> remoteSavedUris,
     List<String> remotePinnedUris,
+    String ownerDid,
   ) async {
-    final localFeeds = await _dao.getAllFeeds();
+    final localFeeds = await _dao.getAllFeeds(ownerDid);
     final now = DateTime.now();
     final remoteSavedSet = remoteSavedUris.toSet();
     final feedsToInsert = <SavedFeedsCompanion>[];
···
     final feedsToRemove = <String>[];
     final feedsToSyncToRemote = <String>[];
 
+    // Identify new remote feeds needing metadata
+    final newRemoteFeeds = <String>[];
+    for (final uri in remoteSavedUris) {
+      if (uri.startsWith('at://') &&
+          !uri.contains('/app.bsky.graph.list/') &&
+          !localFeeds.any((f) => f.uri == uri)) {
+        newRemoteFeeds.add(uri);
+      }
+    }
+
+    // Batch fetch metadata for new feeds
+    final Map<String, FeedGenerator> fetchedMetadata = {};
+    if (newRemoteFeeds.isNotEmpty) {
+      try {
+        final batchResults = await getFeedGenerators(newRemoteFeeds);
+        for (final feed in batchResults) {
+          fetchedMetadata[feed.uri] = feed;
+        }
+      } catch (e) {
+        _logger.warning('Failed to batch fetch feed metadata', {'error': e});
+      }
+    }
+
     for (var i = 0; i < remoteSavedUris.length; i++) {
       final remoteUri = remoteSavedUris[i];
       final remoteIsPinned = remotePinnedUris.contains(remoteUri);
+      final local = localFeeds.where((f) => f.uri == remoteUri).firstOrNull;
 
       if (!remoteUri.startsWith('at://')) {
-        _logger.debug('Processing special feed: $remoteUri');
-        final local = localFeeds.where((f) => f.uri == remoteUri).firstOrNull;
-
+        // Handle special feeds...
         if (local == null) {
-          _logger.debug('Adding new special feed: $remoteUri');
           feedsToInsert.add(
             SavedFeedsCompanion.insert(
               uri: remoteUri,
+              ownerDid: ownerDid,
               displayName: _getSpecialFeedDisplayName(remoteUri),
               description: Value(_getSpecialFeedDescription(remoteUri)),
-              avatar: const Value(null),
               creatorDid: '',
               likeCount: const Value(0),
               sortOrder: i,
···
               localUpdatedAt: const Value(null),
             ),
           );
-        } else if (local.localUpdatedAt == null) {
-          _logger.debug('Accepting remote state for special feed: $remoteUri');
+        } else if (local.localUpdatedAt == null ||
+            !local.localUpdatedAt!.isAfter(local.lastSynced)) {
+          // Unchanged or old local: Update from remote
           feedsToUpdate.add(
             _FeedUpdate(
               uri: remoteUri,
···
               clearLocalUpdatedAt: true,
             ),
           );
-        } else if (local.localUpdatedAt!.isAfter(local.lastSynced)) {
-          _logger.debug('Local is newer for special feed: $remoteUri');
-          feedsToSyncToRemote.add(remoteUri);
         } else {
-          _logger.debug('Remote is newer for special feed: $remoteUri');
-          feedsToUpdate.add(
-            _FeedUpdate(
-              uri: remoteUri,
-              sortOrder: i,
-              isPinned: remoteIsPinned,
-              lastSynced: now,
-              clearLocalUpdatedAt: true,
-            ),
-          );
+          // Local is newer
+          feedsToSyncToRemote.add(remoteUri);
         }
         continue;
       }
 
-      final local = localFeeds.where((f) => f.uri == remoteUri).firstOrNull;
-
       if (local == null) {
-        _logger.debug('Adding new remote feed: $remoteUri');
-        try {
-          if (remoteUri.contains('/app.bsky.graph.list/')) {
+        // New remote feed
+        if (remoteUri.contains('/app.bsky.graph.list/')) {
+          // List requires individual fetch
+          try {
             final listMetadata = await getListMetadata(remoteUri);
-
             await _profileDao.upsertProfile(
               ProfilesCompanion.insert(
                 did: listMetadata.creator.did,
                 handle: listMetadata.creator.handle,
               ),
             );
-
             feedsToInsert.add(
               SavedFeedsCompanion.insert(
                 uri: remoteUri,
+                ownerDid: ownerDid,
                 displayName: listMetadata.name,
                 description: Value(listMetadata.description),
                 avatar: Value(listMetadata.avatar),
···
                 localUpdatedAt: const Value(null),
               ),
             );
-          } else {
-            final metadata = await getFeedMetadata(remoteUri);
-
+          } catch (e) {
+            _logger.warning('Failed to fetch list $remoteUri', {'error': e});
+          }
+        } else {
+          // Feed Generator - check batched metadata
+          final metadata = fetchedMetadata[remoteUri];
+          if (metadata != null) {
             await _profileDao.upsertProfile(
               ProfilesCompanion.insert(did: metadata.creator.did, handle: metadata.creator.handle),
             );
-
             feedsToInsert.add(
               SavedFeedsCompanion.insert(
                 uri: remoteUri,
+                ownerDid: ownerDid,
                 displayName: metadata.displayName,
                 description: Value(metadata.description),
                 avatar: Value(metadata.avatar),
···
                 localUpdatedAt: const Value(null),
               ),
             );
+          } else {
+            // Fallback individual fetch if missed in batch (e.g. error) or try individually?
+            // If it failed in batch, it likely fails here too, but let's just skip/warn.
+            _logger.warning('Missing metadata for $remoteUri');
           }
-        } catch (e) {
-          _logger.error('Failed to fetch metadata for $remoteUri', {'error': e});
         }
-      } else if (local.localUpdatedAt == null) {
-        _logger.debug('Accepting remote state for: $remoteUri');
+      } else if (local.localUpdatedAt == null ||
+          !local.localUpdatedAt!.isAfter(local.lastSynced)) {
+        // Remote state wins
         feedsToUpdate.add(
           _FeedUpdate(
             uri: remoteUri,
···
             clearLocalUpdatedAt: true,
           ),
         );
-      } else if (local.localUpdatedAt!.isAfter(local.lastSynced)) {
-        _logger.debug('Local is newer, keeping local state for: $remoteUri');
-        feedsToSyncToRemote.add(remoteUri);
       } else {
-        _logger.debug('Remote is newer for: $remoteUri');
-        feedsToUpdate.add(
-          _FeedUpdate(
-            uri: remoteUri,
-            sortOrder: i,
-            isPinned: remoteIsPinned,
-            lastSynced: now,
-            clearLocalUpdatedAt: true,
-          ),
-        );
+        // Local state wins
+        feedsToSyncToRemote.add(remoteUri);
       }
     }
 
+    // Detect removals
     for (final local in localFeeds) {
       if (!remoteSavedSet.contains(local.uri)) {
         if (local.localUpdatedAt != null && local.localUpdatedAt!.isAfter(local.lastSynced)) {
-          _logger.debug('Queueing local-only feed for sync: ${local.uri}');
           feedsToSyncToRemote.add(local.uri);
         } else {
-          _logger.debug('Removing remotely-deleted feed: ${local.uri}');
           feedsToRemove.add(local.uri);
         }
       }
     }
 
+    // Apply changes
     if (feedsToInsert.isNotEmpty) {
       await _dao.upsertFeeds(feedsToInsert);
-      _logger.info('Added ${feedsToInsert.length} new feeds from remote');
     }
-
     for (final update in feedsToUpdate) {
       await _dao.updateSyncState(
         uri: update.uri,
+        ownerDid: ownerDid,
         sortOrder: update.sortOrder,
         isPinned: update.isPinned,
         lastSynced: update.lastSynced,
         clearLocalModification: update.clearLocalUpdatedAt,
       );
     }
-    if (feedsToUpdate.isNotEmpty) {
-      _logger.info('Updated ${feedsToUpdate.length} feeds from remote');
-    }
-
     for (final uri in feedsToRemove) {
-      await _dao.deleteFeed(uri);
-    }
-    if (feedsToRemove.isNotEmpty) {
-      _logger.info('Removed ${feedsToRemove.length} remotely-deleted feeds');
+      await _dao.deleteFeed(uri, ownerDid);
     }
 
+    // Queue local changes
     for (final uri in feedsToSyncToRemote) {
-      final existing = await _syncQueueDao.getPendingItems();
+      final existing = await _syncQueueDao.getPendingItems(ownerDid);
       if (!existing.any((e) => e.payload == uri && e.type == 'save')) {
-        await _syncQueueDao.enqueue(
-          PreferenceSyncQueueCompanion.insert(
-            category: const Value('feed'),
-            type: 'save',
-            payload: uri,
-            createdAt: now,
-          ),
-        );
+        await _syncQueueDao.enqueueFeedSync(type: 'save', feedUri: uri, ownerDid: ownerDid);
       }
     }
-    if (feedsToSyncToRemote.isNotEmpty) {
-      _logger.info('Queued ${feedsToSyncToRemote.length} local feeds for remote sync');
-    }
   }
 
   /// Saves a feed to user preferences and local cache.
-  ///
-  /// Uses a fail-safe transaction pattern:
-  /// 1. Atomically update local state AND queue sync operation
-  /// 2. Attempt remote sync
-  /// 3. If remote succeeds, dequeue the operation
-  ///
-  /// This ensures data consistency even if the app crashes during sync.
-  ///
-  /// Throws [ArgumentError] if the feed URI is invalid.
-  Future<void> saveFeed(String feedUri, {bool pin = false}) async {
-    if (!_api.isAuthenticated) {
-      throw Exception('Cannot save feed: user not authenticated');
-    }
-
+  Future<void> saveFeed(String feedUri, String ownerDid, {bool pin = false}) async {
+    if (!_api.isAuthenticated) throw Exception('User not authenticated');
     _validateFeedUri(feedUri);
-
-    _logger.info('Saving feed', {'uri': feedUri, 'pin': pin});
 
     FeedGenerator? metadata;
     String displayName = 'Saved Feed';
···
         ProfilesCompanion.insert(did: creatorDid, handle: metadata.creator.handle),
       );
     } catch (e) {
-      final existing = await _dao.getFeed(feedUri);
+      final existing = await _dao.getFeed(feedUri, ownerDid);
       if (existing != null) {
         displayName = existing.displayName;
         description = existing.description;
         avatar = existing.avatar;
         creatorDid = existing.creatorDid;
         likeCount = existing.likeCount;
-      } else {
-        _logger.warning('Could not fetch metadata for feed save, proceeding with defaults');
       }
     }
 
-    final allFeeds = await _dao.getAllFeeds();
+    final allFeeds = await _dao.getAllFeeds(ownerDid);
+    int? queueId;
 
-    int? queueId;
     try {
       queueId = await _dao.db.transaction(() async {
         await _dao.upsertFeed(
           SavedFeedsCompanion.insert(
             uri: feedUri,
+            ownerDid: ownerDid,
             displayName: displayName,
             description: Value(description),
             avatar: Value(avatar),
···
           ),
         );
 
-        return await _syncQueueDao.enqueue(
-          PreferenceSyncQueueCompanion.insert(
-            category: const Value('feed'),
-            type: 'save',
-            payload: feedUri,
-            createdAt: DateTime.now(),
-          ),
+        return await _syncQueueDao.enqueueFeedSync(
+          type: 'save',
+          feedUri: feedUri,
+          ownerDid: ownerDid,
         );
       });
     } catch (e) {
-      _logger.error('Failed to perform atomic local update + queue', {'error': e});
       rethrow;
     }
 
     try {
       await _executeRemoteSaveFeed(feedUri, pin);
-      _logger.info('Feed saved to remote successfully');
-      if (queueId != null) {
-        await _syncQueueDao.deleteItem(queueId);
-      }
+      if (queueId != null) await _syncQueueDao.deleteItem(queueId);
     } catch (e) {
-      _logger.warning('Network failed during saveFeed, operation queued for retry', {
-        'error': e,
-        'queueId': queueId,
-      });
+      // Failed sync, leave in queue
     }
   }
 
···
   }
 
   /// Removes a feed from user preferences and local cache.
-  ///
-  /// Uses a fail-safe transaction pattern:
-  /// 1. Atomically remove from local state AND queue sync operation
-  /// 2. Attempt remote sync
-  /// 3. If remote succeeds, dequeue the operation
-  ///
-  /// This ensures data consistency even if the app crashes during sync.
-  Future<void> removeFeed(String feedUri) async {
-    if (!_api.isAuthenticated) {
-      throw Exception('Cannot remove feed: user not authenticated');
-    }
-
-    _logger.info('Removing feed', {'uri': feedUri});
+  Future<void> removeFeed(String feedUri, String ownerDid) async {
+    if (!_api.isAuthenticated) throw Exception('User not authenticated');
 
     int? queueId;
     try {
       queueId = await _dao.db.transaction(() async {
-        await _dao.deleteFeed(feedUri);
-
-        return await _syncQueueDao.enqueue(
-          PreferenceSyncQueueCompanion.insert(
-            category: const Value('feed'),
-            type: 'remove',
-            payload: feedUri,
-            createdAt: DateTime.now(),
-          ),
+        await _dao.deleteFeed(feedUri, ownerDid);
+        return await _syncQueueDao.enqueueFeedSync(
+          type: 'remove',
+          feedUri: feedUri,
+          ownerDid: ownerDid,
         );
       });
     } catch (e) {
-      _logger.error('Failed to perform atomic local delete + queue', {'error': e});
       rethrow;
     }
 
     try {
       await _executeRemoteRemoveFeed(feedUri);
-      _logger.info('Feed removed from remote successfully');
-      if (queueId != null) {
-        await _syncQueueDao.deleteItem(queueId);
-      }
+      if (queueId != null) await _syncQueueDao.deleteItem(queueId);
     } catch (e) {
-      _logger.warning('Network failed during removeFeed, operation queued for retry', {
-        'error': e,
-        'queueId': queueId,
-      });
+      // Failed sync
     }
   }
 
···
   ///
   /// Updates local sortOrder for each feed and syncs to remote preferences.
   /// Uses a fail-safe transaction pattern similar to saveFeed/removeFeed.
-  Future<void> reorderFeeds(List<String> orderedUris) async {
-    if (!_api.isAuthenticated) {
-      throw Exception('Cannot reorder feeds: user not authenticated');
-    }
-
-    _logger.info('Reordering feeds', {'count': orderedUris.length});
+  Future<void> reorderFeeds(List<String> orderedUris, String ownerDid) async {
+    if (!_api.isAuthenticated) throw Exception('User not authenticated');
 
     int? queueId;
     try {
       queueId = await _dao.db.transaction(() async {
+        // Optimized update: only update if changed? For now just iterate.
         for (var i = 0; i < orderedUris.length; i++) {
-          await _dao.updateSortOrder(orderedUris[i], i);
+          await _dao.updateSortOrder(orderedUris[i], i, ownerDid);
         }
 
-        return await _syncQueueDao.enqueue(
-          PreferenceSyncQueueCompanion.insert(
-            category: const Value('feed'),
-            type: 'reorder',
-            payload: orderedUris.join(','),
-            createdAt: DateTime.now(),
-          ),
+        return await _syncQueueDao.enqueueFeedSync(
+          type: 'reorder',
+          feedUri: orderedUris.join(','),
+          ownerDid: ownerDid,
         );
       });
     } catch (e) {
-      _logger.error('Failed to perform atomic reorder update + queue', {'error': e});
       rethrow;
     }
 
     try {
       await _executeRemoteReorderFeeds(orderedUris);
-      _logger.info('Feeds reordered on remote successfully');
-      if (queueId != null) {
-        await _syncQueueDao.deleteItem(queueId);
-      }
+      if (queueId != null) await _syncQueueDao.deleteItem(queueId);
     } catch (e) {
-      _logger.warning('Network failed during reorderFeeds, operation queued for retry', {
-        'error': e,
-        'queueId': queueId,
-      });
+      // Failed sync
     }
   }
 
···
   /// Finds feeds with lastSynced older than 24 hours and updates their
   /// metadata from appropriate API endpoints (getFeedGenerator for feed generators,
   /// getList for lists). Special feeds (non-at:// URIs) are skipped.
-  Future<void> refreshStaleMetadata() async {
+  Future<void> refreshStaleMetadata(String ownerDid) async {
     if (!_api.isAuthenticated) return;
 
     final threshold = DateTime.now().subtract(const Duration(hours: 24));
-    final staleFeeds = await _dao.getStaleFeeds(threshold);
+    final staleFeeds = await _dao.getStaleFeeds(threshold, ownerDid);
 
     if (staleFeeds.isEmpty) {
       _logger.debug('No stale feeds to refresh');
···
           await _dao.upsertFeed(
             SavedFeedsCompanion.insert(
               uri: feed.uri,
+              ownerDid: ownerDid,
               displayName: listMetadata.name,
               description: Value(listMetadata.description),
               avatar: Value(listMetadata.avatar),
···
           await _dao.upsertFeed(
             SavedFeedsCompanion.insert(
               uri: feed.uri,
+              ownerDid: ownerDid,
               displayName: metadata.displayName,
               description: Value(metadata.description),
               avatar: Value(metadata.avatar),
···
   /// Attempts to re-apply any queued save/remove operations.
   /// Items that have reached the maximum retry count ([kMaxSyncRetries]) are skipped and left
   /// for cleanup.
-  Future<void> processSyncQueue() async {
+  Future<void> processSyncQueue(String ownerDid) async {
     if (!_api.isAuthenticated) return;
 
-    final retryable = await _syncQueueDao.getRetryableFeedItems();
+    final retryable = await _syncQueueDao.getRetryableFeedItems(ownerDid);
     if (retryable.isEmpty) {
       return;
     }
···
     for (final item in retryable) {
       try {
         if (item.type == 'save') {
-          final localFeed = await _dao.getFeed(item.payload);
+          final localFeed = await _dao.getFeed(item.payload, ownerDid);
           final shouldPin = localFeed?.isPinned ?? false;
 
           await _executeRemoteSaveFeed(item.payload, shouldPin);
···
   /// Syncs everything on app resume or network restoration.
   ///
   /// Also cleans up permanently failed sync items older than 30 days.
-  Future<void> syncOnResume() async {
-    _logger.info('Performing resume sync');
+  Future<void> syncOnResume(String ownerDid) async {
+    _logger.info('Performing resume sync for $ownerDid');
     try {
       final cleanupThreshold = DateTime.now().subtract(kSyncQueueCleanupAge);
       final cleaned = await _syncQueueDao.cleanupOldFailedItems(cleanupThreshold);
···
         _logger.info('Cleaned up $cleaned old failed sync items');
       }
 
-      await processSyncQueue();
-      await syncPreferences();
-      await refreshStaleMetadata();
+      await processSyncQueue(ownerDid);
+      await syncPreferences(ownerDid);
+      await refreshStaleMetadata(ownerDid);
     } catch (e) {
       _logger.error('Resume sync failed', {'error': e});
     }
   }
 
   /// Watches all saved feeds reactively.
-  Stream<List<SavedFeed>> watchAllFeeds() {
-    return _dao.watchAllFeeds();
+  Stream<List<SavedFeed>> watchAllFeeds(String ownerDid) {
+    return _dao.watchAllFeeds(ownerDid);
   }
 
   /// Watches pinned feeds reactively.
-  Stream<List<SavedFeed>> watchPinnedFeeds() {
-    return _dao.watchPinnedFeeds();
+  Stream<List<SavedFeed>> watchPinnedFeeds(String ownerDid) {
+    return _dao.watchPinnedFeeds(ownerDid);
   }
 
   /// Gets a specific feed by URI.
-  Future<SavedFeed?> getFeed(String uri) {
-    return _dao.getFeed(uri);
+  Future<SavedFeed?> getFeed(String uri, String ownerDid) {
+    return _dao.getFeed(uri, ownerDid);
   }
 
   /// URI for the Home timeline (authenticated users).
···
   ///
   /// Preserves pin status and sortOrder when migrating. Returns the migrated
   /// feed's properties if migration occurred, null otherwise.
-  Future<_MigrationResult?> _migrateDeprecatedFeed() async {
-    final deprecatedFeed = await _dao.getFeed(_kDeprecatedDiscoverUri);
+  Future<_MigrationResult?> _migrateDeprecatedFeed(String ownerDid) async {
+    final deprecatedFeed = await _dao.getFeed(_kDeprecatedDiscoverUri, ownerDid);
     if (deprecatedFeed == null) {
       return null;
     }
 
-    final newFeedExists = await _dao.getFeed(kDiscoverFeedUri) != null;
+    final newFeedExists = await _dao.getFeed(kDiscoverFeedUri, ownerDid) != null;
 
     final result = _MigrationResult(
       isPinned: deprecatedFeed.isPinned,
       sortOrder: deprecatedFeed.sortOrder,
     );
 
-    await _dao.deleteFeed(_kDeprecatedDiscoverUri);
+    await _dao.deleteFeed(_kDeprecatedDiscoverUri, ownerDid);
     _logger.info('Migrated deprecated discover feed', {
       'isPinned': result.isPinned,
       'sortOrder': result.sortOrder,
···
 
   /// Seeds default feeds if they don't already exist.
   ///
-  /// For unauthenticated users, ensures the Discover feed is available.
-  /// For authenticated users, removes all seeded feeds since they should only see feeds from their
-  /// preferences.
-  ///
-  /// If a deprecated feed URI exists, migrates the user to the new URI while preserving their
-  /// pin status and sortOrder.
-  Future<void> seedDefaultFeeds() async {
+  /// For unauthenticated users (ownerDid="unauthenticated"), ensures Discover feed.
+  /// For authenticated users, cleans up legacy/seed feeds that shouldn't be there.
+  Future<void> seedDefaultFeeds(String ownerDid) async {
     _logger.debug('Seeding default feeds');
 
-    final migration = await _migrateDeprecatedFeed();
+    final migration = await _migrateDeprecatedFeed(ownerDid); // Pass ownerDid if needed
 
     if (_api.isAuthenticated) {
-      await _dao.deleteFeed(kHomeFeedUri);
-      await _dao.deleteFeed(kForYouFeedUri);
-      await _dao.deleteFeed(kDiscoverFeedUri);
+      // Cleanup for authenticated users
+      await _dao.deleteFeed(kHomeFeedUri, ownerDid);
+      await _dao.deleteFeed(kForYouFeedUri, ownerDid);
+      await _dao.deleteFeed(kDiscoverFeedUri, ownerDid);
       _logger.debug('Removed seeded feeds for authenticated user');
       return;
     }
···
       shouldPin: migration?.isPinned ?? true,
       now: now,
       feeds: defaultFeeds,
+      ownerDid: ownerDid,
     );
 
-    if (defaultFeeds.isEmpty) {
+    if (defaultFeeds.isNotEmpty) {
+      await _dao.upsertFeeds(defaultFeeds);
+      _logger.info('Seeded ${defaultFeeds.length} default feeds');
+    } else {
       _logger.debug('Default feeds already up to date');
-      return;
     }
-
-    await _dao.upsertFeeds(defaultFeeds);
-    _logger.info('Seeded ${defaultFeeds.length} default feeds');
   }
 
   Future<void> _ensureCuratedFeed({
···
     required bool shouldPin,
     required DateTime now,
     required List<SavedFeedsCompanion> feeds,
+    required String ownerDid,
   }) async {
-    final existing = await _dao.getFeed(uri);
-    if (existing != null) {
-      return;
-    }
+    final existing = await _dao.getFeed(uri, ownerDid);
+    if (existing != null) return;
 
     FeedGenerator? metadata;
     try {
···
     feeds.add(
       SavedFeedsCompanion.insert(
         uri: uri,
+        ownerDid: ownerDid,
         displayName: metadata?.displayName ?? fallbackName,
         description: Value(metadata?.description ?? fallbackDescription),
         avatar: Value(metadata?.avatar),
···
         lastSynced: now,
       ),
     );
+  }
+
+  /// Fetches metadata for multiple feed generators in batches.
+  Future<List<FeedGenerator>> getFeedGenerators(List<String> uris) async {
+    if (uris.isEmpty) return [];
+
+    // Chunk requests to avoid hitting URL length limits or API constraints
+    // Assuming 25 is a safe batch size
+    const batchSize = 25;
+    final results = <FeedGenerator>[];
+
+    for (var i = 0; i < uris.length; i += batchSize) {
+      final end = (i + batchSize < uris.length) ? i + batchSize : uris.length;
+      final batch = uris.sublist(i, end);
+
+      try {
+        final response = await _api.call(
+          'app.bsky.feed.getFeedGenerators',
+          params: {'feeds': batch},
+        );
+
+        final views = (response['feeds'] as List).cast<Map<String, dynamic>>();
+        results.addAll(views.map((v) => FeedGenerator.fromJson(v)));
+      } catch (e) {
+        _logger.error('Batch fetch failed for slice $i-$end', {'error': e});
+        // Don't rethrow, partial success is better
+      }
+    }
+
+    return results;
   }
 }
 

lib/src/features/notifications/application/mark_as_seen_service.dart

···
   /// Timer for batching operations.
   Timer? _batchTimer;
 
-  /// Most recent notification timestamp in the current batch.
+  /// The owner DID for the current batch.
+  String? _currentOwnerDid;
+
+  /// The timestamp of the most recent seen notification in the current batch.
   DateTime? _latestSeenTimestamp;
 
-  /// Whether a flush is currently in progress.
+  /// Flag to prevent concurrent flush operations.
   bool _isFlushingseenAt = false;
 
   /// Marks a notification as seen by adding its timestamp to the batch.
   ///
   /// The notification will be marked locally immediately, and synced
   /// to the server after [_batchDuration] or when enough notifications accumulate.
-  void markAsSeen(DateTime notificationTimestamp) {
+  void markAsSeen(DateTime notificationTimestamp, String ownerDid) {
     _logger.debug('Marking notification as seen', {
       'timestamp': notificationTimestamp.toIso8601String(),
+      'ownerDid': ownerDid,
     });
 
+    if (_currentOwnerDid != null && _currentOwnerDid != ownerDid) {
+      // Owner changed, flush previous batch immediately
+      flush();
+    }
+
+    _currentOwnerDid = ownerDid;
+
     if (_latestSeenTimestamp == null || notificationTimestamp.isAfter(_latestSeenTimestamp!)) {
       _latestSeenTimestamp = notificationTimestamp;
     }
···
 
   /// Internal flush implementation.
   Future<void> _flush() async {
-    if (_isFlushingseenAt || _latestSeenTimestamp == null) {
+    if (_isFlushingseenAt || _latestSeenTimestamp == null || _currentOwnerDid == null) {
       return;
     }
 
     _isFlushingseenAt = true;
     final seenAt = _latestSeenTimestamp!;
+    final ownerDid = _currentOwnerDid!;
+
+    // Clear state before async operation to handle re-entry or new batches
     _latestSeenTimestamp = null;
+    _currentOwnerDid = null;
 
-    _logger.info('Flushing mark as seen batch', {'seenAt': seenAt.toIso8601String()});
+    _logger.info('Flushing mark as seen batch', {
+      'seenAt': seenAt.toIso8601String(),
+      'ownerDid': ownerDid,
+    });
 
     try {
-      await _repository.markAsSeenLocally(seenAt);
+      await _repository.markAsSeenLocally(seenAt, ownerDid);
       await _repository.updateSeen(seenAt);
 
       _logger.debug('Successfully flushed mark as seen batch', {});
···
       _logger.error('Failed to flush mark as seen batch', error, stack);
 
       try {
-        await _syncQueue.enqueueMarkSeen(seenAt);
-        _logger.info('Queued mark as seen for offline sync', {'seenAt': seenAt.toIso8601String()});
+        await _syncQueue.enqueueMarkSeen(seenAt, ownerDid);
+        _logger.info('Queued mark as seen for offline sync', {
+          'seenAt': seenAt.toIso8601String(),
+          'ownerDid': ownerDid,
+        });
       } catch (queueError, queueStack) {
         _logger.error('Failed to queue mark as seen for offline sync', queueError, queueStack);
       }

lib/src/features/notifications/application/notifications_notifier.dart

···
 class NotificationsNotifier extends _$NotificationsNotifier {
   Logger get _logger => ref.read(loggerProvider('NotificationsNotifier'));
 
-  bool get _isAuthenticated => ref.read(authProvider) is AuthStateAuthenticated;
-
   @override
   Stream<List<GroupedNotification>> build() {
     final repository = ref.watch(notificationsRepositoryProvider);
-    _logger.debug('Building grouped notifications stream', {});
-    return repository.watchNotifications().map(GroupedNotification.groupNotifications);
+    final authState = ref.watch(authProvider);
+
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) {
+      return const Stream.empty();
+    }
+
+    _logger.debug('Building grouped notifications stream', {'ownerDid': ownerDid});
+    return repository.watchNotifications(ownerDid).map(GroupedNotification.groupNotifications);
   }
 
   /// Refreshes notifications from the API.
-  ///
-  /// Fetches the latest notifications and updates the local cache.
   Future<void> refresh() async {
-    if (!_isAuthenticated) {
-      _logger.debug('Skipping refresh: not authenticated', {});
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) {
+      _logger.debug('Skipping refresh: not authenticated or unknown owner', {});
       return;
     }
 
     final repository = ref.read(notificationsRepositoryProvider);
 
     try {
-      await repository.fetchNotifications();
-      _logger.info('Notifications refreshed', {});
+      await repository.fetchNotifications(ownerDid: ownerDid);
+      _logger.info('Notifications refreshed', {'ownerDid': ownerDid});
     } catch (error, stack) {
       _logger.error('Failed to refresh notifications', error, stack);
       rethrow;
···
 
   /// Loads more notifications using cursor-based pagination.
   Future<void> loadMore() async {
-    if (!_isAuthenticated) {
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) {
       _logger.debug('Skipping loadMore: not authenticated', {});
       return;
     }
 
     final repository = ref.read(notificationsRepositoryProvider);
-    final cursor = await repository.getCursor();
+    final cursor = await repository.getCursor(ownerDid);
 
     if (cursor == null) {
       _logger.debug('No cursor available for loadMore', {});
···
     }
 
     try {
-      await repository.fetchNotifications(cursor: cursor);
+      await repository.fetchNotifications(ownerDid: ownerDid, cursor: cursor);
       _logger.info('Loaded more notifications', {'cursor': cursor});
     } catch (error, stack) {
       _logger.error('Failed to load more notifications', error, stack);
···
   }
 
   /// Marks all notifications as read.
-  ///
-  /// This flushes any pending mark as seen operations, then marks all
-  /// notifications as read locally and syncs with the server.
   Future<void> markAllAsRead() async {
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) return;
+
     final repository = ref.read(notificationsRepositoryProvider);
     final markAsSeenService = ref.read(markAsSeenServiceProvider);
 
     try {
       await markAsSeenService.flush();
 
-      await repository.markAllAsRead();
+      await repository.markAllAsRead(ownerDid);
 
-      await repository.updateSeen(DateTime.now());
+      await repository.markAsSeenLocally(DateTime.now(), ownerDid);
 
       _logger.info('Marked all notifications as read', {});
     } catch (error, stack) {

lib/src/features/notifications/application/notifications_notifier.g.dart

···
   NotificationsNotifier create() => NotificationsNotifier();
 }
 
-String _$notificationsNotifierHash() => r'287578fad2ea840c95e2dac8998c4763146fb8cd';
+String _$notificationsNotifierHash() => r'650ebb9034f46b19f7440fa0b1ceb5aff49d4431';
 
 /// Notifier for managing notification list state.
 ///

lib/src/features/notifications/application/unread_count_notifier.dart

···
 import 'package:riverpod_annotation/riverpod_annotation.dart';
 
-import '../../../core/utils/logger.dart';
 import '../../../core/utils/logger_provider.dart';
 import '../../../features/auth/application/auth_providers.dart';
 import '../../../features/auth/domain/auth_state.dart';
···
 /// reactive updates when notifications are marked as read.
 @riverpod
 class UnreadCountNotifier extends _$UnreadCountNotifier {
-  Logger get _logger => ref.read(loggerProvider('UnreadCountNotifier'));
-
-  bool get _isAuthenticated => ref.read(authProvider) is AuthStateAuthenticated;
-
   @override
   Stream<int> build() {
-    if (!_isAuthenticated) {
-      _logger.debug('Not authenticated, returning 0 unread count', {});
+    final logger = ref.read(loggerProvider('UnreadCountNotifier'));
+    final authState = ref.watch(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+    if (ownerDid == null) {
+      logger.debug('Not authenticated, returning 0 unread count', {});
       return Stream.value(0);
     }
 
     final repository = ref.watch(notificationsRepositoryProvider);
-    _logger.debug('Building unread count stream', {});
-    return repository.watchUnreadCount();
+    logger.debug('Building unread count stream', {});
+    return repository.watchUnreadCount(ownerDid);
   }
 }

lib/src/features/notifications/application/unread_count_notifier.g.dart

···
   UnreadCountNotifier create() => UnreadCountNotifier();
 }
 
-String _$unreadCountNotifierHash() => r'd92a51e1927057acc715ca32c4371e16e56b8707';
+String _$unreadCountNotifierHash() => r'cc920f31355bc1a2fc031bdf693fcb8c5ad7a4dc';
 
 /// Notifier for managing unread notification count.
 ///

lib/src/features/notifications/infrastructure/notifications_repository.dart

···
   static const kNotificationsFeedKey = 'notifications';
 
   /// Fetches notifications from the API and caches them locally.
-  ///
-  /// [cursor] - Pagination cursor for fetching older notifications.
-  /// [limit] - Maximum number of notifications to fetch (default 50, max 100).
-  Future<void> fetchNotifications({String? cursor, int limit = 50}) async {
-    _logger.info('Fetching notifications', {'cursor': cursor, 'limit': limit});
+  Future<void> fetchNotifications({
+    required String ownerDid,
+    String? cursor,
+    int limit = 50,
+  }) async {
+    _logger.info('Fetching notifications', {
+      'cursor': cursor,
+      'limit': limit,
+      'ownerDid': ownerDid,
+    });
 
     try {
       final params = <String, dynamic>{'limit': limit.clamp(1, 100)};
···
           NotificationsCompanion.insert(
             uri: notificationMap['uri'] as String,
             actorDid: author['did'] as String,
+            ownerDid: ownerDid,
             type: type.name,
             reasonSubjectUri: Value(notificationMap['reasonSubject'] as String?),
             recordJson: Value(recordJson),
···
       await _dao.insertNotificationsBatch(
         newNotifications: notifications,
         newProfiles: profiles,
+        ownerDid: ownerDid,
         newCursor: newCursor,
       );
 
···
     }
   }
 
-  /// Returns a stream of notifications from the local cache.
-  ///
-  /// Notifications are joined with actor profiles for complete display data.
-  Stream<List<AppNotification>> watchNotifications() {
-    return _dao.watchNotifications().map((items) {
+  /// Returns a stream of notifications from the local cache for a specific user.
+  Stream<List<AppNotification>> watchNotifications(String ownerDid) {
+    return _dao.watchNotifications(ownerDid).map((items) {
       return items
           .map((item) {
             final type = NotificationType.fromString(item.notification.type);
···
     });
   }
 
-  /// Gets the pagination cursor for loading more notifications.
-  Future<String?> getCursor() {
-    return _dao.getCursor();
+  /// Gets the pagination cursor for loading more notifications for a specific user.
+  Future<String?> getCursor(String ownerDid) {
+    return _dao.getCursor(ownerDid);
   }
 
-  /// Clears all cached notifications.
-  Future<void> clearNotifications() {
-    return _dao.clearNotifications();
+  /// Clears all cached notifications for a specific user.
+  Future<void> clearNotifications(String ownerDid) {
+    return _dao.clearNotifications(ownerDid);
   }
 
-  /// Deletes notifications older than the specified threshold.
-  Future<int> deleteStaleNotifications(DateTime threshold) {
-    return _dao.deleteStaleNotifications(threshold);
+  /// Deletes notifications older than the specified threshold for a specific user.
+  Future<int> deleteStaleNotifications(DateTime threshold, String ownerDid) {
+    return _dao.deleteStaleNotifications(threshold, ownerDid);
   }
 
-  /// Marks all notifications as read locally.
-  Future<void> markAllAsRead() {
-    return _dao.markAllAsRead();
+  /// Marks all notifications as read locally for a specific user.
+  Future<void> markAllAsRead(String ownerDid) {
+    return _dao.markAllAsRead(ownerDid);
   }
 
-  /// Returns a stream of the unread notification count.
-  ///
-  /// Emits updates whenever notifications are inserted, updated, or deleted.
-  Stream<int> watchUnreadCount() {
-    return _dao.watchUnreadCount();
+  /// Returns a stream of the unread notification count for a specific user.
+  Stream<int> watchUnreadCount(String ownerDid) {
+    return _dao.watchUnreadCount(ownerDid);
   }
 
   /// Fetches the current unread count from the API.
-  ///
-  /// Returns the number of unread notifications according to the server.
   Future<int> getUnreadCount() async {
     _logger.info('Fetching unread count from API', {});
 
···
   }
 
   /// Marks notifications as seen on the server.
-  ///
-  /// All notifications before [seenAt] timestamp will be marked as seen.
-  /// This updates the server state and should be followed by local cache updates.
   Future<void> updateSeen(DateTime seenAt) async {
     _logger.info('Updating seen state', {'seenAt': seenAt.toIso8601String()});
 
···
     }
   }
 
-  /// Marks specific notifications as seen locally.
-  ///
-  /// Updates the local cache to mark notifications before [seenAt] as read.
-  Future<void> markAsSeenLocally(DateTime seenAt) async {
-    _logger.debug('Marking notifications as seen locally', {'seenAt': seenAt.toIso8601String()});
+  /// Marks specific notifications as seen locally for a specific user.
+  Future<void> markAsSeenLocally(DateTime seenAt, String ownerDid) async {
+    _logger.debug('Marking notifications as seen locally', {
+      'seenAt': seenAt.toIso8601String(),
+      'ownerDid': ownerDid,
+    });
 
-    await _dao.markAsSeenBefore(seenAt);
+    await _dao.markAsSeenBefore(seenAt, ownerDid);
   }
 
-  /// Processes the sync queue to retry failed mark-as-seen operations.
-  ///
-  /// Cleans up old failed items, then attempts to sync the latest queued
-  /// timestamp. Since marking at timestamp T marks all notifications before T,
-  /// we only need to sync the most recent timestamp and can then clear all
-  /// older queue items.
-  Future<void> processSyncQueue() async {
-    _logger.debug('Processing notification sync queue', {});
+  /// Processes the sync queue to retry failed mark-as-seen operations for a specific user.
+  Future<void> processSyncQueue(String ownerDid) async {
+    _logger.debug('Processing notification sync queue', {'ownerDid': ownerDid});
 
     final threshold = DateTime.now().subtract(const Duration(days: 30));
     final cleanedCount = await _syncQueue.cleanupOldFailedItems(threshold);
···
       _logger.info('Cleaned up old failed sync items', {'count': cleanedCount});
     }
 
-    final latestSeenAt = await _syncQueue.getLatestSeenAt();
+    final latestSeenAt = await _syncQueue.getLatestSeenAt(ownerDid);
     if (latestSeenAt == null) {
       _logger.debug('No items in sync queue', {});
       return;
···
 
     _logger.info('Processing sync queue', {'latestSeenAt': latestSeenAt.toIso8601String()});
 
-    final retryableItems = await _syncQueue.getRetryableItems();
+    final retryableItems = await _syncQueue.getRetryableItems(ownerDid);
 
     try {
-      await markAsSeenLocally(latestSeenAt);
+      await markAsSeenLocally(latestSeenAt, ownerDid);
       await updateSeen(latestSeenAt);
 
-      final deletedCount = await _syncQueue.deleteItemsUpTo(latestSeenAt);
+      final deletedCount = await _syncQueue.deleteItemsUpTo(latestSeenAt, ownerDid);
       _logger.info('Successfully synced notifications', {
         'seenAt': latestSeenAt.toIso8601String(),
         'clearedQueueItems': deletedCount,

lib/src/features/notifications/presentation/widgets/grouped_notification_item.dart

···
 import 'package:go_router/go_router.dart';
 import 'package:lazurite/src/core/utils/date_formatter.dart';
 import 'package:lazurite/src/core/widgets/widgets.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:lazurite/src/features/notifications/application/notifications_providers.dart';
 import 'package:lazurite/src/features/notifications/domain/grouped_notification.dart';
 import 'package:lazurite/src/features/notifications/domain/notification_type.dart';
···
     }
 
     if (group.subjectUri != null) {
-      final service = ref.read(markAsSeenServiceProvider);
-      service.markAsSeen(group.mostRecentTimestamp);
+      final authState = ref.read(authProvider);
+      if (authState is AuthStateAuthenticated) {
+        final service = ref.read(markAsSeenServiceProvider);
+        service.markAsSeen(group.mostRecentTimestamp, authState.session.did);
+      }
 
       final encodedUri = Uri.encodeComponent(group.subjectUri!);
       GoRouter.of(context).push('/home/t/$encodedUri');

lib/src/features/notifications/presentation/widgets/notification_list_item.dart

···
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:go_router/go_router.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 
 import '../../../../core/utils/date_formatter.dart';
 import '../../../../core/widgets/avatar.dart';
···
 
     return VisibilityDetector(
       onVisible: () {
-        final service = ref.read(markAsSeenServiceProvider);
-        service.markAsSeen(notification.indexedAt);
+        final authState = ref.read(authProvider);
+        if (authState is AuthStateAuthenticated) {
+          final service = ref.read(markAsSeenServiceProvider);
+          service.markAsSeen(notification.indexedAt, authState.session.did);
+        }
       },
       child: card,
     );

lib/src/features/profile/application/profile_providers.dart

···
 
   Future<ProfileData> _fetchProfile(String actor) async {
     final repository = ref.read(profileRepositoryProvider);
-    return repository.getProfile(actor);
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : 'anonymous';
+    return repository.getProfile(actor, ownerDid);
   }
 
   Future<void> refresh() async {

lib/src/features/profile/application/profile_providers.g.dart

···
   }
 }
 
-String _$profileNotifierHash() => r'8427c3f560281abad899f53fb5b2c4e3f59c33fa';
+String _$profileNotifierHash() => r'7ccce6122fcf09098774583f7a1568dc94d50343';
 
 final class ProfileNotifierFamily extends $Family
     with

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

···
   /// Fetches a profile from the API and caches it.
   ///
   /// [actor] can be a DID or handle.
-  Future<ProfileData> getProfile(String actor) async {
-    _logger.info('Fetching profile', {'actor': actor});
+  Future<ProfileData> getProfile(String actor, String ownerDid) async {
+    _logger.info('Fetching profile', {'actor': actor, 'ownerDid': ownerDid});
     try {
       final response = await _api.call('app.bsky.actor.getProfile', params: {'actor': actor});
 
···
 
       await _relationshipsDao.upsertRelationship(
         ProfileRelationshipsCompanion.insert(
+          ownerDid: ownerDid,
           profileDid: profile.did,
           following: Value(profile.viewerFollowing),
           followingUri: Value(profile.viewerFollowUri),
···
 
       await _followsDao.upsertFollow(
         FollowsCompanion.insert(
-          actorDid: actorDid,
+          actorDid: actorDid, // actorDid is the owner
           subjectDid: subjectDid,
           uri: uri,
           createdAt: Value(DateTime.now()),
···
     try {
       await _api.call('app.bsky.graph.muteActor', body: {'actor': subjectDid});
 
-      await _relationshipsDao.updateMuteStatus(subjectDid, true);
+      await _relationshipsDao.updateMuteStatus(subjectDid, true, actorDid);
       _logger.debug('Muted user', {'subject': subjectDid});
     } catch (e, stack) {
       _logger.error('Failed to mute user', e, stack);
···
     try {
       await _api.call('app.bsky.graph.unmuteActor', body: {'actor': subjectDid});
 
-      await _relationshipsDao.updateMuteStatus(subjectDid, false);
+      await _relationshipsDao.updateMuteStatus(subjectDid, false, actorDid);
       _logger.debug('Unmuted user', {'subject': subjectDid});
     } catch (e, stack) {
       _logger.error('Failed to unmute user', e, stack);
···
 
       final uri = response['uri'] as String;
 
-      await _relationshipsDao.updateBlockStatus(subjectDid, true, blockingUri: uri);
+      await _relationshipsDao.updateBlockStatus(subjectDid, true, actorDid, blockingUri: uri);
       _logger.debug('Blocked user', {'subject': subjectDid, 'uri': uri});
       return uri;
     } catch (e, stack) {
···
       );
 
       if (subjectDid != null) {
-        await _relationshipsDao.updateBlockStatus(subjectDid, false);
+        await _relationshipsDao.updateBlockStatus(subjectDid, false, actorDid);
       }
 
       _logger.debug('Deleted block record', {'uri': blockUri});

lib/src/features/settings/application/preference_sync_controller.dart

···
   final logger = ref.watch(loggerProvider('PreferenceSync'));
   var hasInitialized = false;
 
-  Future<void> runSync() async {
-    logger.debug('runSync() called');
+  Future<void> runSync([String? ownerDid]) async {
+    logger.debug('runSync() called', {'ownerDid': ownerDid});
+
+    // If ownerDid is not provided, try to get it from current state
+    final authState = ref.read(authProvider);
+    final effectiveOwnerDid =
+        ownerDid ?? ((authState is AuthStateAuthenticated) ? authState.session.did : null);
+
+    if (effectiveOwnerDid == null) {
+      logger.debug('Skipping sync: no ownerDid available');
+      return;
+    }
+
     try {
       final repo = ref.read(blueskyPreferencesRepositoryProvider);
       logger.debug('Syncing preferences from remote');
-      await repo.syncPreferencesFromRemote();
+      await repo.syncPreferencesFromRemote(effectiveOwnerDid);
       logger.info('Preferences synced successfully');
 
       logger.debug('Processing preference sync queue');
-      await repo.processSyncQueue();
+      await repo.processSyncQueue(effectiveOwnerDid);
       logger.info('Preference sync queue processed');
     } catch (e, stack) {
       logger.error('Failed to sync preferences on resume', e, stack);
···
       if (wasAuthed != isAuthed) {
         if (isAuthed) {
           logger.info('User logged in - triggering preference sync');
-          unawaited(runSync());
+          final newDid = next.session.did;
+          unawaited(runSync(newDid));
         } else {
           logger.info('User logged out - clearing cached preferences');
-          unawaited(ref.read(blueskyPreferencesRepositoryProvider).clearAll());
+          final oldDid = (previous as AuthStateAuthenticated).session.did;
+          unawaited(ref.read(blueskyPreferencesRepositoryProvider).clearAll(oldDid));
         }
       } else if (isAuthed && wasAuthed) {
         final prevSession = previous.session;
         final nextSession = next.session;
-        if (prevSession.accessJwt != nextSession.accessJwt) {
+        if (prevSession.accessJwt != nextSession.accessJwt && prevSession.did == nextSession.did) {
+          // Same user, session refresh
           logger.debug('Session refreshed - triggering sync to fetch preferences');
-          unawaited(runSync());
+          unawaited(runSync(nextSession.did));
+        } else if (prevSession.did != nextSession.did) {
+          // User switched without full logout/login cycle (e.g. account switcher)
+          logger.info('User switched - clearing old prefs and syncing new');
+          unawaited(ref.read(blueskyPreferencesRepositoryProvider).clearAll(prevSession.did));
+          unawaited(runSync(nextSession.did));
         }
       }
     } else {
···
 
     if (authState is AuthStateAuthenticated) {
       logger.info('User is authenticated, running initial sync');
-      await runSync();
+      await runSync(authState.session.did);
     } else {
       logger.info('User not authenticated, skipping initial sync');
     }

lib/src/features/settings/application/preference_sync_controller.g.dart

···
   }
 }
 
-String _$preferenceSyncControllerHash() => r'394099cdba86119b64aa45ae68b7bbc1e39f760e';
+String _$preferenceSyncControllerHash() => r'305b3f9687000b6b52bcb4da4ea77629f45d66bb';

lib/src/features/settings/application/settings_providers.dart

···
 import 'package:lazurite/src/app/providers.dart';
 import 'package:lazurite/src/core/utils/logger_provider.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:lazurite/src/features/settings/domain/bluesky_preferences.dart';
 import 'package:lazurite/src/infrastructure/network/providers.dart';
 import 'package:lazurite/src/infrastructure/preferences/bluesky_preferences_repository.dart';
···
 @riverpod
 Stream<AdultContentPref> adultContentPref(Ref ref) {
   final repo = ref.watch(blueskyPreferencesRepositoryProvider);
-  return repo.watchAdultContentPref();
+  final authState = ref.watch(authProvider);
+
+  final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+  if (ownerDid == null) return Stream.value(const AdultContentPref(enabled: false));
+
+  return repo.watchAdultContentPref(ownerDid);
 }
 
 /// Watches content label preferences.
 @riverpod
 Stream<ContentLabelPrefs> contentLabelPrefs(Ref ref) {
   final repo = ref.watch(blueskyPreferencesRepositoryProvider);
-  return repo.watchContentLabelPrefs();
+  final authState = ref.watch(authProvider);
+
+  final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+  if (ownerDid == null) return Stream.value(ContentLabelPrefs.empty);
+
+  return repo.watchContentLabelPrefs(ownerDid);
 }
 
 /// Watches the labelers preference.
 @riverpod
 Stream<LabelersPref> labelersPref(Ref ref) {
   final repo = ref.watch(blueskyPreferencesRepositoryProvider);
-  return repo.watchLabelersPref();
+  final authState = ref.watch(authProvider);
+
+  final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+  if (ownerDid == null) return Stream.value(LabelersPref.empty);
+
+  return repo.watchLabelersPref(ownerDid);
 }
 
 /// Watches the feed view preference.
 @riverpod
 Stream<FeedViewPref> feedViewPref(Ref ref) {
   final repo = ref.watch(blueskyPreferencesRepositoryProvider);
-  return repo.watchFeedViewPref();
+  final authState = ref.watch(authProvider);
+
+  final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+  if (ownerDid == null) return Stream.value(FeedViewPref.defaultPref);
+
+  return repo.watchFeedViewPref(ownerDid);
 }
 
 /// Watches the thread view preference.
 @riverpod
 Stream<ThreadViewPref> threadViewPref(Ref ref) {
   final repo = ref.watch(blueskyPreferencesRepositoryProvider);
-  return repo.watchThreadViewPref();
+  final authState = ref.watch(authProvider);
+
+  final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+  if (ownerDid == null) return Stream.value(ThreadViewPref.defaultPref);
+
+  return repo.watchThreadViewPref(ownerDid);
 }
 
 /// Watches the muted words preference.
 @riverpod
 Stream<MutedWordsPref> mutedWordsPref(Ref ref) {
   final repo = ref.watch(blueskyPreferencesRepositoryProvider);
-  return repo.watchMutedWordsPref();
+  final authState = ref.watch(authProvider);
+
+  final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
+
+  if (ownerDid == null) return Stream.value(MutedWordsPref.empty);
+
+  return repo.watchMutedWordsPref(ownerDid);
 }

lib/src/features/settings/application/settings_providers.g.dart

···
   }
 }
 
-String _$adultContentPrefHash() => r'cdc458780da7c351c2fced97f1b3b03aa298340c';
+String _$adultContentPrefHash() => r'6175521bfb2e3f424fabc4f455b711f5acd2c30a';
 
 /// Watches content label preferences.
 
···
   }
 }
 
-String _$contentLabelPrefsHash() => r'2fc2f175331482fb8f05119519be263e04223440';
+String _$contentLabelPrefsHash() => r'64a76573483e6a43e306451a16ec7251396d3197';
 
 /// Watches the labelers preference.
 
···
   }
 }
 
-String _$labelersPrefHash() => r'ee7f90859d0d27d3bfc9dae105f62f64f85e2624';
+String _$labelersPrefHash() => r'683933f67c7717d800c5f563b2f23e33e89ba904';
 
 /// Watches the feed view preference.
 
···
   }
 }
 
-String _$feedViewPrefHash() => r'65ea4ae206e707cc70ca28091a39ba2d8b748c9c';
+String _$feedViewPrefHash() => r'6cbee61f1a6e3bb8170f5394539d29ecb6023f5b';
 
 /// Watches the thread view preference.
 
···
   }
 }
 
-String _$threadViewPrefHash() => r'4c5a060b06421d062c4905a3ea6ecf6662ecc75f';
+String _$threadViewPrefHash() => r'c75e582075530962cb5683ae0035e73c1c9570c0';
 
 /// Watches the muted words preference.
 
···
   }
 }
 
-String _$mutedWordsPrefHash() => r'aa031687ba6f0bfef3aaf1212c382611f0a74a9e';
+String _$mutedWordsPrefHash() => r'9052fd9aaba1911f28a132c9ed46467fd80ac132';

lib/src/features/settings/presentation/screens/content_moderation_screen.dart

···
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 
 import '../../application/settings_providers.dart';
 import '../../domain/bluesky_preferences.dart';
···
 
   Future<void> _updateAdultContent(WidgetRef ref, bool enabled) async {
     final repo = ref.read(blueskyPreferencesRepositoryProvider);
-    await repo.updateAdultContentPref(AdultContentPref(enabled: enabled));
+    final authState = ref.read(authProvider);
+    if (authState is AuthStateAuthenticated) {
+      await repo.updateAdultContentPref(AdultContentPref(enabled: enabled), authState.session.did);
+    }
   }
 
   Future<void> _updateLabelVisibility(
···
     updatedItems.add(ContentLabelPref(label: labelId, visibility: visibility));
 
     final repo = ref.read(blueskyPreferencesRepositoryProvider);
-    await repo.updateContentLabelPrefs(ContentLabelPrefs(items: updatedItems));
+    final authState = ref.read(authProvider);
+    if (authState is AuthStateAuthenticated) {
+      await repo.updateContentLabelPrefs(
+        ContentLabelPrefs(items: updatedItems),
+        authState.session.did,
+      );
+    }
   }
 }
 

lib/src/features/settings/presentation/screens/feed_preferences_screen.dart

···
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 
 import '../../application/settings_providers.dart';
 import '../../domain/bluesky_preferences.dart';
···
 
   Future<void> _updateFeedPref(WidgetRef ref, FeedViewPref pref) async {
     final repo = ref.read(blueskyPreferencesRepositoryProvider);
-    await repo.updateFeedViewPref(pref);
+    final authState = ref.read(authProvider);
+    if (authState is AuthStateAuthenticated) {
+      await repo.updateFeedViewPref(pref, authState.session.did);
+    }
   }
 
   Future<void> _updateThreadPref(WidgetRef ref, ThreadViewPref pref) async {
     final repo = ref.read(blueskyPreferencesRepositoryProvider);
-    await repo.updateThreadViewPref(pref);
+    final authState = ref.read(authProvider);
+    if (authState is AuthStateAuthenticated) {
+      await repo.updateThreadViewPref(pref, authState.session.did);
+    }
   }
 }

lib/src/features/settings/presentation/screens/muted_words_screen.dart

···
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:intl/intl.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 
 import '../../application/settings_providers.dart';
 import '../../domain/bluesky_preferences.dart';
···
     final updatedItems = [...pref.items, word];
 
     final repo = ref.read(blueskyPreferencesRepositoryProvider);
-    await repo.updateMutedWordsPref(MutedWordsPref(items: updatedItems));
+    final authState = ref.read(authProvider);
+    if (authState is AuthStateAuthenticated) {
+      await repo.updateMutedWordsPref(MutedWordsPref(items: updatedItems), authState.session.did);
+    }
   }
 
   Future<void> _removeMutedWord(MutedWord word, MutedWordsPref pref) async {
···
     if (confirmed == true) {
       final updatedItems = pref.items.where((w) => w.id != word.id).toList();
       final repo = ref.read(blueskyPreferencesRepositoryProvider);
-      await repo.updateMutedWordsPref(MutedWordsPref(items: updatedItems));
+      final authState = ref.read(authProvider);
+      if (authState is AuthStateAuthenticated) {
+        await repo.updateMutedWordsPref(
+          MutedWordsPref(items: updatedItems),
+          authState.session.did,
+        );
+      }
     }
   }
 }

lib/src/features/thread/application/thread_notifier.dart

···
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
 
 import '../infrastructure/thread_repository.dart';
···
 
   Future<ThreadViewPost> _fetchThread(String postUri) async {
     final repository = ref.read(threadRepositoryProvider);
-    return repository.getPostThread(postUri);
+    final authState = ref.read(authProvider);
+    final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : 'anonymous';
+    return repository.getPostThread(postUri, ownerDid);
   }
 
   Future<void> refresh() async {

lib/src/features/thread/application/thread_notifier.g.dart

···
   }
 }
 
-String _$threadNotifierHash() => r'acb87e725d16f18afdd4e7e4f65be411ee23664e';
+String _$threadNotifierHash() => r'779c8a2cb5b70214e9972972796a6820c41d42b1';
 
 final class ThreadNotifierFamily extends $Family
     with

lib/src/features/thread/application/thread_providers.dart

···
 import 'package:lazurite/src/app/providers.dart';
 import 'package:lazurite/src/core/utils/logger_provider.dart';
+import 'package:lazurite/src/features/auth/application/auth_providers.dart';
+import 'package:lazurite/src/features/auth/domain/auth_state.dart';
 import 'package:lazurite/src/infrastructure/db/daos/feed_content_dao.dart';
 import 'package:lazurite/src/infrastructure/network/providers.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
···
 @riverpod
 Stream<List<FeedPost>> threadCache(Ref ref, String postUri) {
   final db = ref.watch(appDatabaseProvider);
-  return db.feedContentDao.watchFeedContent('thread:$postUri');
+  final authState = ref.watch(authProvider);
+  final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : 'anonymous';
+  return db.feedContentDao.watchFeedContent('thread:$postUri', ownerDid);
 }

lib/src/features/thread/application/thread_providers.g.dart

···
   }
 }
 
-String _$threadCacheHash() => r'310780d1a52f20ec5d8752ce4ec6c687c8eb2226';
+String _$threadCacheHash() => r'100536b7b20ab801be85d2cdf02a5701aab1a2c7';
 
 final class ThreadCacheFamily extends $Family
     with $FunctionalFamilyOverride<Stream<List<FeedPost>>, String> {

lib/src/features/thread/infrastructure/thread_repository.dart

···
   final FeedContentDao _dao;
   final Logger _logger;
 
-  Future<ThreadViewPost> getPostThread(String uri) async {
-    _logger.info('Fetching thread', {'uri': uri});
+  Future<ThreadViewPost> getPostThread(String uri, String ownerDid) async {
+    _logger.info('Fetching thread', {'uri': uri, 'ownerDid': ownerDid});
     try {
       final response = await _api.call('app.bsky.feed.getPostThread', params: {'uri': uri});
 
       final threadJson = response['thread'] as Map<String, dynamic>;
       final thread = ThreadViewPost.fromJson(threadJson);
 
-      await _cacheThread(thread);
+      await _cacheThread(thread, ownerDid);
       _logger.debug('Cached thread posts and participants');
 
       return thread;
···
     }
   }
 
-  Future<void> _cacheThread(ThreadViewPost thread) async {
+  Future<void> _cacheThread(ThreadViewPost thread, String ownerDid) async {
     final posts = <PostsCompanion>[];
     final profiles = <ProfilesCompanion>[];
     final relationships = <ProfileRelationshipsCompanion>[];
···
     void visit(ThreadViewPost node) {
       final postCompanion = node.post.toPostsCompanion();
       final profileCompanion = node.post.toProfilesCompanion();
-      final relationshipCompanion = node.post.toRelationshipCompanion();
+      final relationshipCompanion = node.post.toRelationshipCompanion(ownerDid);
 
       if (seenPosts.add(node.post.uri)) {
         posts.add(postCompanion);
···
         FeedContentItemsCompanion.insert(
           feedKey: feedKey,
           postUri: node.post.uri,
+          ownerDid: ownerDid,
           sortKey: order.toString().padLeft(6, '0'),
         ),
       );
···
     if (posts.isNotEmpty) {
       await _dao.insertFeedContentBatch(
         feedKey: feedKey,
+        ownerDid: ownerDid,
         newPosts: posts,
         newProfiles: profiles,
         newRelationships: relationships,
···
     );
   }
 
-  ProfileRelationshipsCompanion? toRelationshipCompanion() {
+  ProfileRelationshipsCompanion? toRelationshipCompanion(String ownerDid) {
     final viewer = author.viewer;
     if (viewer == null) return null;
 
     return ProfileRelationshipsCompanion.insert(
+      ownerDid: ownerDid,
       profileDid: author.did,
       following: Value(viewer['following'] != null),
       followingUri: Value(viewer['following'] as String?),

lib/src/infrastructure/db/app_database.dart

···
 import 'package:path/path.dart' as p;
 import 'package:path_provider/path_provider.dart';
 
-import 'daos/bluesky_preferences_dao.dart';
 import 'daos/animation_preferences_dao.dart';
+import 'daos/bluesky_preferences_dao.dart';
 import 'daos/custom_theme_dao.dart';
+import 'daos/dm_convos_dao.dart';
+import 'daos/dm_messages_dao.dart';
+import 'daos/dm_outbox_dao.dart';
 import 'daos/drafts_dao.dart';
 import 'daos/feed_content_dao.dart';
 import 'daos/follows_dao.dart';
 import 'daos/local_settings_dao.dart';
+import 'daos/notifications_dao.dart';
+import 'daos/notifications_sync_queue_dao.dart';
 import 'daos/post_interactions_dao.dart';
 import 'daos/preference_sync_queue_dao.dart';
 import 'daos/profile_dao.dart';
···
 import 'daos/saved_feeds_dao.dart';
 import 'daos/search_cache_dao.dart';
 import 'daos/search_dao.dart';
-import 'daos/notifications_dao.dart';
-import 'daos/notifications_sync_queue_dao.dart';
-import 'daos/dm_convos_dao.dart';
-import 'daos/dm_messages_dao.dart';
-import 'daos/dm_outbox_dao.dart';
 import 'tables.dart';
 
 part 'app_database.g.dart';
···
   AppDatabase([QueryExecutor? e]) : super(e ?? _openConnection());
 
   @override
-  int get schemaVersion => 1;
+  int get schemaVersion => 3;
 
   @override
   MigrationStrategy get migration => MigrationStrategy(

lib/src/infrastructure/db/app_database.g.dart

···
     requiredDuringInsert: true,
     defaultConstraints: GeneratedColumn.constraintIsAlways('REFERENCES posts (uri)'),
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _reasonMeta = const VerificationMeta('reason');
   @override
   late final GeneratedColumn<String> reason = GeneratedColumn<String>(
···
     requiredDuringInsert: true,
   );
   @override
-  List<GeneratedColumn> get $columns => [feedKey, postUri, reason, sortKey];
+  List<GeneratedColumn> get $columns => [feedKey, postUri, ownerDid, reason, sortKey];
   @override
   String get aliasedName => _alias ?? actualTableName;
   @override
···
     } else if (isInserting) {
       context.missing(_postUriMeta);
     }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
+    }
     if (data.containsKey('reason')) {
       context.handle(_reasonMeta, reason.isAcceptableOrUnknown(data['reason']!, _reasonMeta));
     }
···
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {feedKey, postUri};
+  Set<GeneratedColumn> get $primaryKey => {feedKey, postUri, ownerDid};
   @override
   FeedContentItem map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
···
       postUri: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}post_uri'],
+      )!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
       )!,
       reason: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
···
 class FeedContentItem extends DataClass implements Insertable<FeedContentItem> {
   final String feedKey;
   final String postUri;
+  final String ownerDid;
   final String? reason;
   final String sortKey;
   const FeedContentItem({
     required this.feedKey,
     required this.postUri,
+    required this.ownerDid,
     this.reason,
     required this.sortKey,
   });
···
     final map = <String, Expression>{};
     map['feed_key'] = Variable<String>(feedKey);
     map['post_uri'] = Variable<String>(postUri);
+    map['owner_did'] = Variable<String>(ownerDid);
     if (!nullToAbsent || reason != null) {
       map['reason'] = Variable<String>(reason);
     }
···
     return FeedContentItemsCompanion(
       feedKey: Value(feedKey),
       postUri: Value(postUri),
+      ownerDid: Value(ownerDid),
       reason: reason == null && nullToAbsent ? const Value.absent() : Value(reason),
       sortKey: Value(sortKey),
     );
···
     return FeedContentItem(
       feedKey: serializer.fromJson<String>(json['feedKey']),
       postUri: serializer.fromJson<String>(json['postUri']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       reason: serializer.fromJson<String?>(json['reason']),
       sortKey: serializer.fromJson<String>(json['sortKey']),
     );
···
     return <String, dynamic>{
       'feedKey': serializer.toJson<String>(feedKey),
       'postUri': serializer.toJson<String>(postUri),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'reason': serializer.toJson<String?>(reason),
       'sortKey': serializer.toJson<String>(sortKey),
     };
···
   FeedContentItem copyWith({
     String? feedKey,
     String? postUri,
+    String? ownerDid,
     Value<String?> reason = const Value.absent(),
     String? sortKey,
   }) => FeedContentItem(
     feedKey: feedKey ?? this.feedKey,
     postUri: postUri ?? this.postUri,
+    ownerDid: ownerDid ?? this.ownerDid,
     reason: reason.present ? reason.value : this.reason,
     sortKey: sortKey ?? this.sortKey,
   );
···
     return FeedContentItem(
       feedKey: data.feedKey.present ? data.feedKey.value : this.feedKey,
       postUri: data.postUri.present ? data.postUri.value : this.postUri,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       reason: data.reason.present ? data.reason.value : this.reason,
       sortKey: data.sortKey.present ? data.sortKey.value : this.sortKey,
     );
···
     return (StringBuffer('FeedContentItem(')
           ..write('feedKey: $feedKey, ')
           ..write('postUri: $postUri, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('reason: $reason, ')
           ..write('sortKey: $sortKey')
           ..write(')'))
···
   }
 
   @override
-  int get hashCode => Object.hash(feedKey, postUri, reason, sortKey);
+  int get hashCode => Object.hash(feedKey, postUri, ownerDid, reason, sortKey);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
       (other is FeedContentItem &&
           other.feedKey == this.feedKey &&
           other.postUri == this.postUri &&
+          other.ownerDid == this.ownerDid &&
           other.reason == this.reason &&
           other.sortKey == this.sortKey);
 }
···
 class FeedContentItemsCompanion extends UpdateCompanion<FeedContentItem> {
   final Value<String> feedKey;
   final Value<String> postUri;
+  final Value<String> ownerDid;
   final Value<String?> reason;
   final Value<String> sortKey;
   final Value<int> rowid;
   const FeedContentItemsCompanion({
     this.feedKey = const Value.absent(),
     this.postUri = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.reason = const Value.absent(),
     this.sortKey = const Value.absent(),
     this.rowid = const Value.absent(),
···
   FeedContentItemsCompanion.insert({
     required String feedKey,
     required String postUri,
+    required String ownerDid,
     this.reason = const Value.absent(),
     required String sortKey,
     this.rowid = const Value.absent(),
   }) : feedKey = Value(feedKey),
        postUri = Value(postUri),
+       ownerDid = Value(ownerDid),
        sortKey = Value(sortKey);
   static Insertable<FeedContentItem> custom({
     Expression<String>? feedKey,
     Expression<String>? postUri,
+    Expression<String>? ownerDid,
     Expression<String>? reason,
     Expression<String>? sortKey,
     Expression<int>? rowid,
···
     return RawValuesInsertable({
       if (feedKey != null) 'feed_key': feedKey,
       if (postUri != null) 'post_uri': postUri,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (reason != null) 'reason': reason,
       if (sortKey != null) 'sort_key': sortKey,
       if (rowid != null) 'rowid': rowid,
···
   FeedContentItemsCompanion copyWith({
     Value<String>? feedKey,
     Value<String>? postUri,
+    Value<String>? ownerDid,
     Value<String?>? reason,
     Value<String>? sortKey,
     Value<int>? rowid,
···
     return FeedContentItemsCompanion(
       feedKey: feedKey ?? this.feedKey,
       postUri: postUri ?? this.postUri,
+      ownerDid: ownerDid ?? this.ownerDid,
       reason: reason ?? this.reason,
       sortKey: sortKey ?? this.sortKey,
       rowid: rowid ?? this.rowid,
···
     if (postUri.present) {
       map['post_uri'] = Variable<String>(postUri.value);
     }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
+    }
     if (reason.present) {
       map['reason'] = Variable<String>(reason.value);
     }
···
     return (StringBuffer('FeedContentItemsCompanion(')
           ..write('feedKey: $feedKey, ')
           ..write('postUri: $postUri, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('reason: $reason, ')
           ..write('sortKey: $sortKey, ')
           ..write('rowid: $rowid')
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _cursorMeta = const VerificationMeta('cursor');
   @override
   late final GeneratedColumn<String> cursor = GeneratedColumn<String>(
···
     requiredDuringInsert: false,
   );
   @override
-  List<GeneratedColumn> get $columns => [feedKey, cursor, lastUpdated];
+  List<GeneratedColumn> get $columns => [feedKey, ownerDid, cursor, lastUpdated];
   @override
   String get aliasedName => _alias ?? actualTableName;
   @override
···
     } else if (isInserting) {
       context.missing(_feedKeyMeta);
     }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
+    }
     if (data.containsKey('cursor')) {
       context.handle(_cursorMeta, cursor.isAcceptableOrUnknown(data['cursor']!, _cursorMeta));
     } else if (isInserting) {
···
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {feedKey};
+  Set<GeneratedColumn> get $primaryKey => {feedKey, ownerDid};
   @override
   FeedCursor map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
···
         DriftSqlType.string,
         data['${effectivePrefix}feed_key'],
       )!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
+      )!,
       cursor: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}cursor'],
···
 
 class FeedCursor extends DataClass implements Insertable<FeedCursor> {
   final String feedKey;
+  final String ownerDid;
   final String cursor;
   final DateTime? lastUpdated;
-  const FeedCursor({required this.feedKey, required this.cursor, this.lastUpdated});
+  const FeedCursor({
+    required this.feedKey,
+    required this.ownerDid,
+    required this.cursor,
+    this.lastUpdated,
+  });
   @override
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['feed_key'] = Variable<String>(feedKey);
+    map['owner_did'] = Variable<String>(ownerDid);
     map['cursor'] = Variable<String>(cursor);
     if (!nullToAbsent || lastUpdated != null) {
       map['last_updated'] = Variable<DateTime>(lastUpdated);
···
   FeedCursorsCompanion toCompanion(bool nullToAbsent) {
     return FeedCursorsCompanion(
       feedKey: Value(feedKey),
+      ownerDid: Value(ownerDid),
       cursor: Value(cursor),
       lastUpdated: lastUpdated == null && nullToAbsent ? const Value.absent() : Value(lastUpdated),
     );
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return FeedCursor(
       feedKey: serializer.fromJson<String>(json['feedKey']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       cursor: serializer.fromJson<String>(json['cursor']),
       lastUpdated: serializer.fromJson<DateTime?>(json['lastUpdated']),
     );
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'feedKey': serializer.toJson<String>(feedKey),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'cursor': serializer.toJson<String>(cursor),
       'lastUpdated': serializer.toJson<DateTime?>(lastUpdated),
     };
···
 
   FeedCursor copyWith({
     String? feedKey,
+    String? ownerDid,
     String? cursor,
     Value<DateTime?> lastUpdated = const Value.absent(),
   }) => FeedCursor(
     feedKey: feedKey ?? this.feedKey,
+    ownerDid: ownerDid ?? this.ownerDid,
     cursor: cursor ?? this.cursor,
     lastUpdated: lastUpdated.present ? lastUpdated.value : this.lastUpdated,
   );
   FeedCursor copyWithCompanion(FeedCursorsCompanion data) {
     return FeedCursor(
       feedKey: data.feedKey.present ? data.feedKey.value : this.feedKey,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       cursor: data.cursor.present ? data.cursor.value : this.cursor,
       lastUpdated: data.lastUpdated.present ? data.lastUpdated.value : this.lastUpdated,
     );
···
   String toString() {
     return (StringBuffer('FeedCursor(')
           ..write('feedKey: $feedKey, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('cursor: $cursor, ')
           ..write('lastUpdated: $lastUpdated')
           ..write(')'))
···
   }
 
   @override
-  int get hashCode => Object.hash(feedKey, cursor, lastUpdated);
+  int get hashCode => Object.hash(feedKey, ownerDid, cursor, lastUpdated);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
       (other is FeedCursor &&
           other.feedKey == this.feedKey &&
+          other.ownerDid == this.ownerDid &&
           other.cursor == this.cursor &&
           other.lastUpdated == this.lastUpdated);
 }
 
 class FeedCursorsCompanion extends UpdateCompanion<FeedCursor> {
   final Value<String> feedKey;
+  final Value<String> ownerDid;
   final Value<String> cursor;
   final Value<DateTime?> lastUpdated;
   final Value<int> rowid;
   const FeedCursorsCompanion({
     this.feedKey = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.cursor = const Value.absent(),
     this.lastUpdated = const Value.absent(),
     this.rowid = const Value.absent(),
   });
   FeedCursorsCompanion.insert({
     required String feedKey,
+    required String ownerDid,
     required String cursor,
     this.lastUpdated = const Value.absent(),
     this.rowid = const Value.absent(),
   }) : feedKey = Value(feedKey),
+       ownerDid = Value(ownerDid),
        cursor = Value(cursor);
   static Insertable<FeedCursor> custom({
     Expression<String>? feedKey,
+    Expression<String>? ownerDid,
     Expression<String>? cursor,
     Expression<DateTime>? lastUpdated,
     Expression<int>? rowid,
   }) {
     return RawValuesInsertable({
       if (feedKey != null) 'feed_key': feedKey,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (cursor != null) 'cursor': cursor,
       if (lastUpdated != null) 'last_updated': lastUpdated,
       if (rowid != null) 'rowid': rowid,
···
 
   FeedCursorsCompanion copyWith({
     Value<String>? feedKey,
+    Value<String>? ownerDid,
     Value<String>? cursor,
     Value<DateTime?>? lastUpdated,
     Value<int>? rowid,
   }) {
     return FeedCursorsCompanion(
       feedKey: feedKey ?? this.feedKey,
+      ownerDid: ownerDid ?? this.ownerDid,
       cursor: cursor ?? this.cursor,
       lastUpdated: lastUpdated ?? this.lastUpdated,
       rowid: rowid ?? this.rowid,
···
     if (feedKey.present) {
       map['feed_key'] = Variable<String>(feedKey.value);
     }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
+    }
     if (cursor.present) {
       map['cursor'] = Variable<String>(cursor.value);
     }
···
   String toString() {
     return (StringBuffer('FeedCursorsCompanion(')
           ..write('feedKey: $feedKey, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('cursor: $cursor, ')
           ..write('lastUpdated: $lastUpdated, ')
           ..write('rowid: $rowid')
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _displayNameMeta = const VerificationMeta('displayName');
   @override
   late final GeneratedColumn<String> displayName = GeneratedColumn<String>(
···
   @override
   List<GeneratedColumn> get $columns => [
     uri,
+    ownerDid,
     displayName,
     description,
     avatar,
···
     } else if (isInserting) {
       context.missing(_uriMeta);
     }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
+    }
     if (data.containsKey('display_name')) {
       context.handle(
         _displayNameMeta,
···
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {uri};
+  Set<GeneratedColumn> get $primaryKey => {uri, ownerDid};
   @override
   SavedFeed map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
     return SavedFeed(
       uri: attachedDatabase.typeMapping.read(DriftSqlType.string, data['${effectivePrefix}uri'])!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
+      )!,
       displayName: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}display_name'],
···
   /// Feed generator AT URI (at://did:plc:xxx/app.bsky.feed.generator/yyy).
   final String uri;
 
+  /// The DID of the user who saved this feed.
+  final String ownerDid;
+
   /// Display name of the feed.
   final String displayName;
 
···
   final DateTime? localUpdatedAt;
   const SavedFeed({
     required this.uri,
+    required this.ownerDid,
     required this.displayName,
     this.description,
     this.avatar,
···
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['uri'] = Variable<String>(uri);
+    map['owner_did'] = Variable<String>(ownerDid);
     map['display_name'] = Variable<String>(displayName);
     if (!nullToAbsent || description != null) {
       map['description'] = Variable<String>(description);
···
   SavedFeedsCompanion toCompanion(bool nullToAbsent) {
     return SavedFeedsCompanion(
       uri: Value(uri),
+      ownerDid: Value(ownerDid),
       displayName: Value(displayName),
       description: description == null && nullToAbsent ? const Value.absent() : Value(description),
       avatar: avatar == null && nullToAbsent ? const Value.absent() : Value(avatar),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return SavedFeed(
       uri: serializer.fromJson<String>(json['uri']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       displayName: serializer.fromJson<String>(json['displayName']),
       description: serializer.fromJson<String?>(json['description']),
       avatar: serializer.fromJson<String?>(json['avatar']),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'uri': serializer.toJson<String>(uri),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'displayName': serializer.toJson<String>(displayName),
       'description': serializer.toJson<String?>(description),
       'avatar': serializer.toJson<String?>(avatar),
···
 
   SavedFeed copyWith({
     String? uri,
+    String? ownerDid,
     String? displayName,
     Value<String?> description = const Value.absent(),
     Value<String?> avatar = const Value.absent(),
···
     Value<DateTime?> localUpdatedAt = const Value.absent(),
   }) => SavedFeed(
     uri: uri ?? this.uri,
+    ownerDid: ownerDid ?? this.ownerDid,
     displayName: displayName ?? this.displayName,
     description: description.present ? description.value : this.description,
     avatar: avatar.present ? avatar.value : this.avatar,
···
   SavedFeed copyWithCompanion(SavedFeedsCompanion data) {
     return SavedFeed(
       uri: data.uri.present ? data.uri.value : this.uri,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       displayName: data.displayName.present ? data.displayName.value : this.displayName,
       description: data.description.present ? data.description.value : this.description,
       avatar: data.avatar.present ? data.avatar.value : this.avatar,
···
   String toString() {
     return (StringBuffer('SavedFeed(')
           ..write('uri: $uri, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('displayName: $displayName, ')
           ..write('description: $description, ')
           ..write('avatar: $avatar, ')
···
   @override
   int get hashCode => Object.hash(
     uri,
+    ownerDid,
     displayName,
     description,
     avatar,
···
       identical(this, other) ||
       (other is SavedFeed &&
           other.uri == this.uri &&
+          other.ownerDid == this.ownerDid &&
           other.displayName == this.displayName &&
           other.description == this.description &&
           other.avatar == this.avatar &&
···
 
 class SavedFeedsCompanion extends UpdateCompanion<SavedFeed> {
   final Value<String> uri;
+  final Value<String> ownerDid;
   final Value<String> displayName;
   final Value<String?> description;
   final Value<String?> avatar;
···
   final Value<int> rowid;
   const SavedFeedsCompanion({
     this.uri = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.displayName = const Value.absent(),
     this.description = const Value.absent(),
     this.avatar = const Value.absent(),
···
   });
   SavedFeedsCompanion.insert({
     required String uri,
+    required String ownerDid,
     required String displayName,
     this.description = const Value.absent(),
     this.avatar = const Value.absent(),
···
     this.localUpdatedAt = const Value.absent(),
     this.rowid = const Value.absent(),
   }) : uri = Value(uri),
+       ownerDid = Value(ownerDid),
        displayName = Value(displayName),
        creatorDid = Value(creatorDid),
        sortOrder = Value(sortOrder),
        lastSynced = Value(lastSynced);
   static Insertable<SavedFeed> custom({
     Expression<String>? uri,
+    Expression<String>? ownerDid,
     Expression<String>? displayName,
     Expression<String>? description,
     Expression<String>? avatar,
···
   }) {
     return RawValuesInsertable({
       if (uri != null) 'uri': uri,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (displayName != null) 'display_name': displayName,
       if (description != null) 'description': description,
       if (avatar != null) 'avatar': avatar,
···
 
   SavedFeedsCompanion copyWith({
     Value<String>? uri,
+    Value<String>? ownerDid,
     Value<String>? displayName,
     Value<String?>? description,
     Value<String?>? avatar,
···
   }) {
     return SavedFeedsCompanion(
       uri: uri ?? this.uri,
+      ownerDid: ownerDid ?? this.ownerDid,
       displayName: displayName ?? this.displayName,
       description: description ?? this.description,
       avatar: avatar ?? this.avatar,
···
     if (uri.present) {
       map['uri'] = Variable<String>(uri.value);
     }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
+    }
     if (displayName.present) {
       map['display_name'] = Variable<String>(displayName.value);
     }
···
   String toString() {
     return (StringBuffer('SavedFeedsCompanion(')
           ..write('uri: $uri, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('displayName: $displayName, ')
           ..write('description: $description, ')
           ..write('avatar: $avatar, ')
···
     requiredDuringInsert: false,
     defaultConstraints: GeneratedColumn.constraintIsAlways('PRIMARY KEY AUTOINCREMENT'),
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _categoryMeta = const VerificationMeta('category');
   @override
   late final GeneratedColumn<String> category = GeneratedColumn<String>(
···
     defaultValue: const Constant(0),
   );
   @override
-  List<GeneratedColumn> get $columns => [id, category, type, payload, createdAt, retryCount];
+  List<GeneratedColumn> get $columns => [
+    id,
+    ownerDid,
+    category,
+    type,
+    payload,
+    createdAt,
+    retryCount,
+  ];
   @override
   String get aliasedName => _alias ?? actualTableName;
   @override
···
     final data = instance.toColumns(true);
     if (data.containsKey('id')) {
       context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
+    }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
     }
     if (data.containsKey('category')) {
       context.handle(
···
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
     return PreferenceSyncQueueData(
       id: attachedDatabase.typeMapping.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
+      )!,
       category: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}category'],
···
 
 class PreferenceSyncQueueData extends DataClass implements Insertable<PreferenceSyncQueueData> {
   final int id;
+
+  /// The DID of the user who owns this action.
+  final String ownerDid;
 
   /// Category of preference being synced: 'feed' or 'bluesky_pref'.
   final String category;
···
   final int retryCount;
   const PreferenceSyncQueueData({
     required this.id,
+    required this.ownerDid,
     required this.category,
     required this.type,
     required this.payload,
···
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['id'] = Variable<int>(id);
+    map['owner_did'] = Variable<String>(ownerDid);
     map['category'] = Variable<String>(category);
     map['type'] = Variable<String>(type);
     map['payload'] = Variable<String>(payload);
···
   PreferenceSyncQueueCompanion toCompanion(bool nullToAbsent) {
     return PreferenceSyncQueueCompanion(
       id: Value(id),
+      ownerDid: Value(ownerDid),
       category: Value(category),
       type: Value(type),
       payload: Value(payload),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return PreferenceSyncQueueData(
       id: serializer.fromJson<int>(json['id']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       category: serializer.fromJson<String>(json['category']),
       type: serializer.fromJson<String>(json['type']),
       payload: serializer.fromJson<String>(json['payload']),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'id': serializer.toJson<int>(id),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'category': serializer.toJson<String>(category),
       'type': serializer.toJson<String>(type),
       'payload': serializer.toJson<String>(payload),
···
 
   PreferenceSyncQueueData copyWith({
     int? id,
+    String? ownerDid,
     String? category,
     String? type,
     String? payload,
···
     int? retryCount,
   }) => PreferenceSyncQueueData(
     id: id ?? this.id,
+    ownerDid: ownerDid ?? this.ownerDid,
     category: category ?? this.category,
     type: type ?? this.type,
     payload: payload ?? this.payload,
···
   PreferenceSyncQueueData copyWithCompanion(PreferenceSyncQueueCompanion data) {
     return PreferenceSyncQueueData(
       id: data.id.present ? data.id.value : this.id,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       category: data.category.present ? data.category.value : this.category,
       type: data.type.present ? data.type.value : this.type,
       payload: data.payload.present ? data.payload.value : this.payload,
···
   String toString() {
     return (StringBuffer('PreferenceSyncQueueData(')
           ..write('id: $id, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('category: $category, ')
           ..write('type: $type, ')
           ..write('payload: $payload, ')
···
   }
 
   @override
-  int get hashCode => Object.hash(id, category, type, payload, createdAt, retryCount);
+  int get hashCode => Object.hash(id, ownerDid, category, type, payload, createdAt, retryCount);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
       (other is PreferenceSyncQueueData &&
           other.id == this.id &&
+          other.ownerDid == this.ownerDid &&
           other.category == this.category &&
           other.type == this.type &&
           other.payload == this.payload &&
···
 
 class PreferenceSyncQueueCompanion extends UpdateCompanion<PreferenceSyncQueueData> {
   final Value<int> id;
+  final Value<String> ownerDid;
   final Value<String> category;
   final Value<String> type;
   final Value<String> payload;
···
   final Value<int> retryCount;
   const PreferenceSyncQueueCompanion({
     this.id = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.category = const Value.absent(),
     this.type = const Value.absent(),
     this.payload = const Value.absent(),
···
   });
   PreferenceSyncQueueCompanion.insert({
     this.id = const Value.absent(),
+    required String ownerDid,
     this.category = const Value.absent(),
     required String type,
     required String payload,
     required DateTime createdAt,
     this.retryCount = const Value.absent(),
-  }) : type = Value(type),
+  }) : ownerDid = Value(ownerDid),
+       type = Value(type),
        payload = Value(payload),
        createdAt = Value(createdAt);
   static Insertable<PreferenceSyncQueueData> custom({
     Expression<int>? id,
+    Expression<String>? ownerDid,
     Expression<String>? category,
     Expression<String>? type,
     Expression<String>? payload,
···
   }) {
     return RawValuesInsertable({
       if (id != null) 'id': id,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (category != null) 'category': category,
       if (type != null) 'type': type,
       if (payload != null) 'payload': payload,
···
 
   PreferenceSyncQueueCompanion copyWith({
     Value<int>? id,
+    Value<String>? ownerDid,
     Value<String>? category,
     Value<String>? type,
     Value<String>? payload,
···
   }) {
     return PreferenceSyncQueueCompanion(
       id: id ?? this.id,
+      ownerDid: ownerDid ?? this.ownerDid,
       category: category ?? this.category,
       type: type ?? this.type,
       payload: payload ?? this.payload,
···
     if (id.present) {
       map['id'] = Variable<int>(id.value);
     }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
+    }
     if (category.present) {
       map['category'] = Variable<String>(category.value);
     }
···
   String toString() {
     return (StringBuffer('PreferenceSyncQueueCompanion(')
           ..write('id: $id, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('category: $category, ')
           ..write('type: $type, ')
           ..write('payload: $payload, ')
···
   final GeneratedDatabase attachedDatabase;
   final String? _alias;
   $ProfileRelationshipsTable(this.attachedDatabase, [this._alias]);
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _profileDidMeta = const VerificationMeta('profileDid');
   @override
   late final GeneratedColumn<String> profileDid = GeneratedColumn<String>(
···
   );
   @override
   List<GeneratedColumn> get $columns => [
+    ownerDid,
     profileDid,
     following,
     followingUri,
···
   }) {
     final context = VerificationContext();
     final data = instance.toColumns(true);
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
+    }
     if (data.containsKey('profile_did')) {
       context.handle(
         _profileDidMeta,
···
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {profileDid};
+  Set<GeneratedColumn> get $primaryKey => {ownerDid, profileDid};
   @override
   ProfileRelationship map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
     return ProfileRelationship(
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
+      )!,
       profileDid: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}profile_did'],
···
 }
 
 class ProfileRelationship extends DataClass implements Insertable<ProfileRelationship> {
+  /// The DID of the owner (the user who sees these relationships).
+  final String ownerDid;
+
   /// The DID of the profile this relationship applies to (subject).
   final String profileDid;
 
···
   /// When this relationship was last updated.
   final DateTime updatedAt;
   const ProfileRelationship({
+    required this.ownerDid,
     required this.profileDid,
     required this.following,
     this.followingUri,
···
   @override
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
+    map['owner_did'] = Variable<String>(ownerDid);
     map['profile_did'] = Variable<String>(profileDid);
     map['following'] = Variable<bool>(following);
     if (!nullToAbsent || followingUri != null) {
···
 
   ProfileRelationshipsCompanion toCompanion(bool nullToAbsent) {
     return ProfileRelationshipsCompanion(
+      ownerDid: Value(ownerDid),
       profileDid: Value(profileDid),
       following: Value(following),
       followingUri: followingUri == null && nullToAbsent
···
   factory ProfileRelationship.fromJson(Map<String, dynamic> json, {ValueSerializer? serializer}) {
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return ProfileRelationship(
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       profileDid: serializer.fromJson<String>(json['profileDid']),
       following: serializer.fromJson<bool>(json['following']),
       followingUri: serializer.fromJson<String?>(json['followingUri']),
···
   Map<String, dynamic> toJson({ValueSerializer? serializer}) {
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'profileDid': serializer.toJson<String>(profileDid),
       'following': serializer.toJson<bool>(following),
       'followingUri': serializer.toJson<String?>(followingUri),
···
   }
 
   ProfileRelationship copyWith({
+    String? ownerDid,
     String? profileDid,
     bool? following,
     Value<String?> followingUri = const Value.absent(),
···
     Value<String?> blockingByList = const Value.absent(),
     DateTime? updatedAt,
   }) => ProfileRelationship(
+    ownerDid: ownerDid ?? this.ownerDid,
     profileDid: profileDid ?? this.profileDid,
     following: following ?? this.following,
     followingUri: followingUri.present ? followingUri.value : this.followingUri,
···
   );
   ProfileRelationship copyWithCompanion(ProfileRelationshipsCompanion data) {
     return ProfileRelationship(
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       profileDid: data.profileDid.present ? data.profileDid.value : this.profileDid,
       following: data.following.present ? data.following.value : this.following,
       followingUri: data.followingUri.present ? data.followingUri.value : this.followingUri,
···
   @override
   String toString() {
     return (StringBuffer('ProfileRelationship(')
+          ..write('ownerDid: $ownerDid, ')
           ..write('profileDid: $profileDid, ')
           ..write('following: $following, ')
           ..write('followingUri: $followingUri, ')
···
 
   @override
   int get hashCode => Object.hash(
+    ownerDid,
     profileDid,
     following,
     followingUri,
···
   bool operator ==(Object other) =>
       identical(this, other) ||
       (other is ProfileRelationship &&
+          other.ownerDid == this.ownerDid &&
           other.profileDid == this.profileDid &&
           other.following == this.following &&
           other.followingUri == this.followingUri &&
···
 }
 
 class ProfileRelationshipsCompanion extends UpdateCompanion<ProfileRelationship> {
+  final Value<String> ownerDid;
   final Value<String> profileDid;
   final Value<bool> following;
   final Value<String?> followingUri;
···
   final Value<DateTime> updatedAt;
   final Value<int> rowid;
   const ProfileRelationshipsCompanion({
+    this.ownerDid = const Value.absent(),
     this.profileDid = const Value.absent(),
     this.following = const Value.absent(),
     this.followingUri = const Value.absent(),
···
     this.rowid = const Value.absent(),
   });
   ProfileRelationshipsCompanion.insert({
+    required String ownerDid,
     required String profileDid,
     this.following = const Value.absent(),
     this.followingUri = const Value.absent(),
···
     this.blockingByList = const Value.absent(),
     required DateTime updatedAt,
     this.rowid = const Value.absent(),
-  }) : profileDid = Value(profileDid),
+  }) : ownerDid = Value(ownerDid),
+       profileDid = Value(profileDid),
        updatedAt = Value(updatedAt);
   static Insertable<ProfileRelationship> custom({
+    Expression<String>? ownerDid,
     Expression<String>? profileDid,
     Expression<bool>? following,
     Expression<String>? followingUri,
···
     Expression<int>? rowid,
   }) {
     return RawValuesInsertable({
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (profileDid != null) 'profile_did': profileDid,
       if (following != null) 'following': following,
       if (followingUri != null) 'following_uri': followingUri,
···
   }
 
   ProfileRelationshipsCompanion copyWith({
+    Value<String>? ownerDid,
     Value<String>? profileDid,
     Value<bool>? following,
     Value<String?>? followingUri,
···
     Value<int>? rowid,
   }) {
     return ProfileRelationshipsCompanion(
+      ownerDid: ownerDid ?? this.ownerDid,
       profileDid: profileDid ?? this.profileDid,
       following: following ?? this.following,
       followingUri: followingUri ?? this.followingUri,
···
   @override
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
+    }
     if (profileDid.present) {
       map['profile_did'] = Variable<String>(profileDid.value);
     }
···
   @override
   String toString() {
     return (StringBuffer('ProfileRelationshipsCompanion(')
+          ..write('ownerDid: $ownerDid, ')
           ..write('profileDid: $profileDid, ')
           ..write('following: $following, ')
           ..write('followingUri: $followingUri, ')
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _dataMeta = const VerificationMeta('data');
   @override
   late final GeneratedColumn<String> data = GeneratedColumn<String>(
···
     requiredDuringInsert: true,
   );
   @override
-  List<GeneratedColumn> get $columns => [type, data, lastSynced];
+  List<GeneratedColumn> get $columns => [type, ownerDid, data, lastSynced];
   @override
   String get aliasedName => _alias ?? actualTableName;
   @override
···
     } else if (isInserting) {
       context.missing(_typeMeta);
     }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
+    }
     if (data.containsKey('data')) {
       context.handle(_dataMeta, this.data.isAcceptableOrUnknown(data['data']!, _dataMeta));
     } else if (isInserting) {
···
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {type};
+  Set<GeneratedColumn> get $primaryKey => {type, ownerDid};
   @override
   BlueskyPreference map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
···
         DriftSqlType.string,
         data['${effectivePrefix}type'],
       )!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
+      )!,
       data: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}data'],
···
   /// The preference type identifier (e.g., 'contentLabel', 'adultContent').
   final String type;
 
+  /// The DID of the owner of these preferences.
+  final String ownerDid;
+
   /// The preference data serialized as JSON.
   final String data;
 
   /// When this preference was last synced from the remote server.
   final DateTime lastSynced;
-  const BlueskyPreference({required this.type, required this.data, required this.lastSynced});
+  const BlueskyPreference({
+    required this.type,
+    required this.ownerDid,
+    required this.data,
+    required this.lastSynced,
+  });
   @override
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['type'] = Variable<String>(type);
+    map['owner_did'] = Variable<String>(ownerDid);
     map['data'] = Variable<String>(data);
     map['last_synced'] = Variable<DateTime>(lastSynced);
     return map;
···
   BlueskyPreferencesCompanion toCompanion(bool nullToAbsent) {
     return BlueskyPreferencesCompanion(
       type: Value(type),
+      ownerDid: Value(ownerDid),
       data: Value(data),
       lastSynced: Value(lastSynced),
     );
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return BlueskyPreference(
       type: serializer.fromJson<String>(json['type']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       data: serializer.fromJson<String>(json['data']),
       lastSynced: serializer.fromJson<DateTime>(json['lastSynced']),
     );
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'type': serializer.toJson<String>(type),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'data': serializer.toJson<String>(data),
       'lastSynced': serializer.toJson<DateTime>(lastSynced),
     };
   }
 
-  BlueskyPreference copyWith({String? type, String? data, DateTime? lastSynced}) =>
-      BlueskyPreference(
-        type: type ?? this.type,
-        data: data ?? this.data,
-        lastSynced: lastSynced ?? this.lastSynced,
-      );
+  BlueskyPreference copyWith({
+    String? type,
+    String? ownerDid,
+    String? data,
+    DateTime? lastSynced,
+  }) => BlueskyPreference(
+    type: type ?? this.type,
+    ownerDid: ownerDid ?? this.ownerDid,
+    data: data ?? this.data,
+    lastSynced: lastSynced ?? this.lastSynced,
+  );
   BlueskyPreference copyWithCompanion(BlueskyPreferencesCompanion data) {
     return BlueskyPreference(
       type: data.type.present ? data.type.value : this.type,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       data: data.data.present ? data.data.value : this.data,
       lastSynced: data.lastSynced.present ? data.lastSynced.value : this.lastSynced,
     );
···
   String toString() {
     return (StringBuffer('BlueskyPreference(')
           ..write('type: $type, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('data: $data, ')
           ..write('lastSynced: $lastSynced')
           ..write(')'))
···
   }
 
   @override
-  int get hashCode => Object.hash(type, data, lastSynced);
+  int get hashCode => Object.hash(type, ownerDid, data, lastSynced);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
       (other is BlueskyPreference &&
           other.type == this.type &&
+          other.ownerDid == this.ownerDid &&
           other.data == this.data &&
           other.lastSynced == this.lastSynced);
 }
 
 class BlueskyPreferencesCompanion extends UpdateCompanion<BlueskyPreference> {
   final Value<String> type;
+  final Value<String> ownerDid;
   final Value<String> data;
   final Value<DateTime> lastSynced;
   final Value<int> rowid;
   const BlueskyPreferencesCompanion({
     this.type = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.data = const Value.absent(),
     this.lastSynced = const Value.absent(),
     this.rowid = const Value.absent(),
   });
   BlueskyPreferencesCompanion.insert({
     required String type,
+    required String ownerDid,
     required String data,
     required DateTime lastSynced,
     this.rowid = const Value.absent(),
   }) : type = Value(type),
+       ownerDid = Value(ownerDid),
        data = Value(data),
        lastSynced = Value(lastSynced);
   static Insertable<BlueskyPreference> custom({
     Expression<String>? type,
+    Expression<String>? ownerDid,
     Expression<String>? data,
     Expression<DateTime>? lastSynced,
     Expression<int>? rowid,
   }) {
     return RawValuesInsertable({
       if (type != null) 'type': type,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (data != null) 'data': data,
       if (lastSynced != null) 'last_synced': lastSynced,
       if (rowid != null) 'rowid': rowid,
···
 
   BlueskyPreferencesCompanion copyWith({
     Value<String>? type,
+    Value<String>? ownerDid,
     Value<String>? data,
     Value<DateTime>? lastSynced,
     Value<int>? rowid,
   }) {
     return BlueskyPreferencesCompanion(
       type: type ?? this.type,
+      ownerDid: ownerDid ?? this.ownerDid,
       data: data ?? this.data,
       lastSynced: lastSynced ?? this.lastSynced,
       rowid: rowid ?? this.rowid,
···
     if (type.present) {
       map['type'] = Variable<String>(type.value);
     }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
+    }
     if (data.present) {
       map['data'] = Variable<String>(data.value);
     }
···
   String toString() {
     return (StringBuffer('BlueskyPreferencesCompanion(')
           ..write('type: $type, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('data: $data, ')
           ..write('lastSynced: $lastSynced, ')
           ..write('rowid: $rowid')
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _actorDidMeta = const VerificationMeta('actorDid');
   @override
   late final GeneratedColumn<String> actorDid = GeneratedColumn<String>(
···
   @override
   List<GeneratedColumn> get $columns => [
     uri,
+    ownerDid,
     actorDid,
     type,
     reasonSubjectUri,
···
     } else if (isInserting) {
       context.missing(_uriMeta);
     }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
+    }
     if (data.containsKey('actor_did')) {
       context.handle(
         _actorDidMeta,
···
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {uri};
+  Set<GeneratedColumn> get $primaryKey => {uri, ownerDid};
   @override
   Notification map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
     return Notification(
       uri: attachedDatabase.typeMapping.read(DriftSqlType.string, data['${effectivePrefix}uri'])!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
+      )!,
       actorDid: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}actor_did'],
···
 class Notification extends DataClass implements Insertable<Notification> {
   /// Notification AT URI (primary key).
   final String uri;
+
+  /// The DID of the user receiving the notification.
+  final String ownerDid;
 
   /// DID of the user who triggered the notification.
   final String actorDid;
···
   final DateTime cachedAt;
   const Notification({
     required this.uri,
+    required this.ownerDid,
     required this.actorDid,
     required this.type,
     this.reasonSubjectUri,
···
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['uri'] = Variable<String>(uri);
+    map['owner_did'] = Variable<String>(ownerDid);
     map['actor_did'] = Variable<String>(actorDid);
     map['type'] = Variable<String>(type);
     if (!nullToAbsent || reasonSubjectUri != null) {
···
   NotificationsCompanion toCompanion(bool nullToAbsent) {
     return NotificationsCompanion(
       uri: Value(uri),
+      ownerDid: Value(ownerDid),
       actorDid: Value(actorDid),
       type: Value(type),
       reasonSubjectUri: reasonSubjectUri == null && nullToAbsent
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return Notification(
       uri: serializer.fromJson<String>(json['uri']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       actorDid: serializer.fromJson<String>(json['actorDid']),
       type: serializer.fromJson<String>(json['type']),
       reasonSubjectUri: serializer.fromJson<String?>(json['reasonSubjectUri']),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'uri': serializer.toJson<String>(uri),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'actorDid': serializer.toJson<String>(actorDid),
       'type': serializer.toJson<String>(type),
       'reasonSubjectUri': serializer.toJson<String?>(reasonSubjectUri),
···
 
   Notification copyWith({
     String? uri,
+    String? ownerDid,
     String? actorDid,
     String? type,
     Value<String?> reasonSubjectUri = const Value.absent(),
···
     DateTime? cachedAt,
   }) => Notification(
     uri: uri ?? this.uri,
+    ownerDid: ownerDid ?? this.ownerDid,
     actorDid: actorDid ?? this.actorDid,
     type: type ?? this.type,
     reasonSubjectUri: reasonSubjectUri.present ? reasonSubjectUri.value : this.reasonSubjectUri,
···
   Notification copyWithCompanion(NotificationsCompanion data) {
     return Notification(
       uri: data.uri.present ? data.uri.value : this.uri,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       actorDid: data.actorDid.present ? data.actorDid.value : this.actorDid,
       type: data.type.present ? data.type.value : this.type,
       reasonSubjectUri: data.reasonSubjectUri.present
···
   String toString() {
     return (StringBuffer('Notification(')
           ..write('uri: $uri, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('actorDid: $actorDid, ')
           ..write('type: $type, ')
           ..write('reasonSubjectUri: $reasonSubjectUri, ')
···
   @override
   int get hashCode => Object.hash(
     uri,
+    ownerDid,
     actorDid,
     type,
     reasonSubjectUri,
···
       identical(this, other) ||
       (other is Notification &&
           other.uri == this.uri &&
+          other.ownerDid == this.ownerDid &&
           other.actorDid == this.actorDid &&
           other.type == this.type &&
           other.reasonSubjectUri == this.reasonSubjectUri &&
···
 
 class NotificationsCompanion extends UpdateCompanion<Notification> {
   final Value<String> uri;
+  final Value<String> ownerDid;
   final Value<String> actorDid;
   final Value<String> type;
   final Value<String?> reasonSubjectUri;
···
   final Value<int> rowid;
   const NotificationsCompanion({
     this.uri = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.actorDid = const Value.absent(),
     this.type = const Value.absent(),
     this.reasonSubjectUri = const Value.absent(),
···
   });
   NotificationsCompanion.insert({
     required String uri,
+    required String ownerDid,
     required String actorDid,
     required String type,
     this.reasonSubjectUri = const Value.absent(),
···
     required DateTime cachedAt,
     this.rowid = const Value.absent(),
   }) : uri = Value(uri),
+       ownerDid = Value(ownerDid),
        actorDid = Value(actorDid),
        type = Value(type),
        indexedAt = Value(indexedAt),
        cachedAt = Value(cachedAt);
   static Insertable<Notification> custom({
     Expression<String>? uri,
+    Expression<String>? ownerDid,
     Expression<String>? actorDid,
     Expression<String>? type,
     Expression<String>? reasonSubjectUri,
···
   }) {
     return RawValuesInsertable({
       if (uri != null) 'uri': uri,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (actorDid != null) 'actor_did': actorDid,
       if (type != null) 'type': type,
       if (reasonSubjectUri != null) 'reason_subject_uri': reasonSubjectUri,
···
 
   NotificationsCompanion copyWith({
     Value<String>? uri,
+    Value<String>? ownerDid,
     Value<String>? actorDid,
     Value<String>? type,
     Value<String?>? reasonSubjectUri,
···
   }) {
     return NotificationsCompanion(
       uri: uri ?? this.uri,
+      ownerDid: ownerDid ?? this.ownerDid,
       actorDid: actorDid ?? this.actorDid,
       type: type ?? this.type,
       reasonSubjectUri: reasonSubjectUri ?? this.reasonSubjectUri,
···
     final map = <String, Expression>{};
     if (uri.present) {
       map['uri'] = Variable<String>(uri.value);
+    }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
     }
     if (actorDid.present) {
       map['actor_did'] = Variable<String>(actorDid.value);
···
   String toString() {
     return (StringBuffer('NotificationsCompanion(')
           ..write('uri: $uri, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('actorDid: $actorDid, ')
           ..write('type: $type, ')
           ..write('reasonSubjectUri: $reasonSubjectUri, ')
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _cursorMeta = const VerificationMeta('cursor');
   @override
   late final GeneratedColumn<String> cursor = GeneratedColumn<String>(
···
     requiredDuringInsert: false,
   );
   @override
-  List<GeneratedColumn> get $columns => [feedKey, cursor, lastUpdated];
+  List<GeneratedColumn> get $columns => [feedKey, ownerDid, cursor, lastUpdated];
   @override
   String get aliasedName => _alias ?? actualTableName;
   @override
···
     } else if (isInserting) {
       context.missing(_feedKeyMeta);
     }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
+    }
     if (data.containsKey('cursor')) {
       context.handle(_cursorMeta, cursor.isAcceptableOrUnknown(data['cursor']!, _cursorMeta));
     } else if (isInserting) {
···
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {feedKey};
+  Set<GeneratedColumn> get $primaryKey => {feedKey, ownerDid};
   @override
   NotificationCursor map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
···
         DriftSqlType.string,
         data['${effectivePrefix}feed_key'],
       )!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
+      )!,
       cursor: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}cursor'],
···
   /// Feed key identifier (e.g., 'notifications').
   final String feedKey;
 
+  /// The DID of the user this cursor belongs to.
+  final String ownerDid;
+
   /// Pagination cursor from API.
   final String cursor;
 
   /// When the cursor was last updated.
   final DateTime? lastUpdated;
-  const NotificationCursor({required this.feedKey, required this.cursor, this.lastUpdated});
+  const NotificationCursor({
+    required this.feedKey,
+    required this.ownerDid,
+    required this.cursor,
+    this.lastUpdated,
+  });
   @override
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['feed_key'] = Variable<String>(feedKey);
+    map['owner_did'] = Variable<String>(ownerDid);
     map['cursor'] = Variable<String>(cursor);
     if (!nullToAbsent || lastUpdated != null) {
       map['last_updated'] = Variable<DateTime>(lastUpdated);
···
   NotificationCursorsCompanion toCompanion(bool nullToAbsent) {
     return NotificationCursorsCompanion(
       feedKey: Value(feedKey),
+      ownerDid: Value(ownerDid),
       cursor: Value(cursor),
       lastUpdated: lastUpdated == null && nullToAbsent ? const Value.absent() : Value(lastUpdated),
     );
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return NotificationCursor(
       feedKey: serializer.fromJson<String>(json['feedKey']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       cursor: serializer.fromJson<String>(json['cursor']),
       lastUpdated: serializer.fromJson<DateTime?>(json['lastUpdated']),
     );
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'feedKey': serializer.toJson<String>(feedKey),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'cursor': serializer.toJson<String>(cursor),
       'lastUpdated': serializer.toJson<DateTime?>(lastUpdated),
     };
···
 
   NotificationCursor copyWith({
     String? feedKey,
+    String? ownerDid,
     String? cursor,
     Value<DateTime?> lastUpdated = const Value.absent(),
   }) => NotificationCursor(
     feedKey: feedKey ?? this.feedKey,
+    ownerDid: ownerDid ?? this.ownerDid,
     cursor: cursor ?? this.cursor,
     lastUpdated: lastUpdated.present ? lastUpdated.value : this.lastUpdated,
   );
   NotificationCursor copyWithCompanion(NotificationCursorsCompanion data) {
     return NotificationCursor(
       feedKey: data.feedKey.present ? data.feedKey.value : this.feedKey,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       cursor: data.cursor.present ? data.cursor.value : this.cursor,
       lastUpdated: data.lastUpdated.present ? data.lastUpdated.value : this.lastUpdated,
     );
···
   String toString() {
     return (StringBuffer('NotificationCursor(')
           ..write('feedKey: $feedKey, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('cursor: $cursor, ')
           ..write('lastUpdated: $lastUpdated')
           ..write(')'))
···
   }
 
   @override
-  int get hashCode => Object.hash(feedKey, cursor, lastUpdated);
+  int get hashCode => Object.hash(feedKey, ownerDid, cursor, lastUpdated);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
       (other is NotificationCursor &&
           other.feedKey == this.feedKey &&
+          other.ownerDid == this.ownerDid &&
           other.cursor == this.cursor &&
           other.lastUpdated == this.lastUpdated);
 }
 
 class NotificationCursorsCompanion extends UpdateCompanion<NotificationCursor> {
   final Value<String> feedKey;
+  final Value<String> ownerDid;
   final Value<String> cursor;
   final Value<DateTime?> lastUpdated;
   final Value<int> rowid;
   const NotificationCursorsCompanion({
     this.feedKey = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.cursor = const Value.absent(),
     this.lastUpdated = const Value.absent(),
     this.rowid = const Value.absent(),
   });
   NotificationCursorsCompanion.insert({
     required String feedKey,
+    required String ownerDid,
     required String cursor,
     this.lastUpdated = const Value.absent(),
     this.rowid = const Value.absent(),
   }) : feedKey = Value(feedKey),
+       ownerDid = Value(ownerDid),
        cursor = Value(cursor);
   static Insertable<NotificationCursor> custom({
     Expression<String>? feedKey,
+    Expression<String>? ownerDid,
     Expression<String>? cursor,
     Expression<DateTime>? lastUpdated,
     Expression<int>? rowid,
   }) {
     return RawValuesInsertable({
       if (feedKey != null) 'feed_key': feedKey,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (cursor != null) 'cursor': cursor,
       if (lastUpdated != null) 'last_updated': lastUpdated,
       if (rowid != null) 'rowid': rowid,
···
 
   NotificationCursorsCompanion copyWith({
     Value<String>? feedKey,
+    Value<String>? ownerDid,
     Value<String>? cursor,
     Value<DateTime?>? lastUpdated,
     Value<int>? rowid,
   }) {
     return NotificationCursorsCompanion(
       feedKey: feedKey ?? this.feedKey,
+      ownerDid: ownerDid ?? this.ownerDid,
       cursor: cursor ?? this.cursor,
       lastUpdated: lastUpdated ?? this.lastUpdated,
       rowid: rowid ?? this.rowid,
···
     final map = <String, Expression>{};
     if (feedKey.present) {
       map['feed_key'] = Variable<String>(feedKey.value);
+    }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
     }
     if (cursor.present) {
       map['cursor'] = Variable<String>(cursor.value);
···
   String toString() {
     return (StringBuffer('NotificationCursorsCompanion(')
           ..write('feedKey: $feedKey, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('cursor: $cursor, ')
           ..write('lastUpdated: $lastUpdated, ')
           ..write('rowid: $rowid')
···
     requiredDuringInsert: false,
     defaultConstraints: GeneratedColumn.constraintIsAlways('PRIMARY KEY AUTOINCREMENT'),
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _typeMeta = const VerificationMeta('type');
   @override
   late final GeneratedColumn<String> type = GeneratedColumn<String>(
···
     defaultValue: const Constant(0),
   );
   @override
-  List<GeneratedColumn> get $columns => [id, type, seenAt, createdAt, retryCount];
+  List<GeneratedColumn> get $columns => [id, ownerDid, type, seenAt, createdAt, retryCount];
   @override
   String get aliasedName => _alias ?? actualTableName;
   @override
···
     if (data.containsKey('id')) {
       context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
     }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
+    }
     if (data.containsKey('type')) {
       context.handle(_typeMeta, type.isAcceptableOrUnknown(data['type']!, _typeMeta));
     } else if (isInserting) {
···
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
     return NotificationsSyncQueueData(
       id: attachedDatabase.typeMapping.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
+      )!,
       type: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}type'],
···
     implements Insertable<NotificationsSyncQueueData> {
   final int id;
 
+  /// The DID of the user who owns this action.
+  final String ownerDid;
+
   /// Type of operation: 'mark_seen'.
   final String type;
 
···
   final int retryCount;
   const NotificationsSyncQueueData({
     required this.id,
+    required this.ownerDid,
     required this.type,
     required this.seenAt,
     required this.createdAt,
···
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['id'] = Variable<int>(id);
+    map['owner_did'] = Variable<String>(ownerDid);
     map['type'] = Variable<String>(type);
     map['seen_at'] = Variable<String>(seenAt);
     map['created_at'] = Variable<DateTime>(createdAt);
···
   NotificationsSyncQueueCompanion toCompanion(bool nullToAbsent) {
     return NotificationsSyncQueueCompanion(
       id: Value(id),
+      ownerDid: Value(ownerDid),
       type: Value(type),
       seenAt: Value(seenAt),
       createdAt: Value(createdAt),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return NotificationsSyncQueueData(
       id: serializer.fromJson<int>(json['id']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       type: serializer.fromJson<String>(json['type']),
       seenAt: serializer.fromJson<String>(json['seenAt']),
       createdAt: serializer.fromJson<DateTime>(json['createdAt']),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'id': serializer.toJson<int>(id),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'type': serializer.toJson<String>(type),
       'seenAt': serializer.toJson<String>(seenAt),
       'createdAt': serializer.toJson<DateTime>(createdAt),
···
 
   NotificationsSyncQueueData copyWith({
     int? id,
+    String? ownerDid,
     String? type,
     String? seenAt,
     DateTime? createdAt,
     int? retryCount,
   }) => NotificationsSyncQueueData(
     id: id ?? this.id,
+    ownerDid: ownerDid ?? this.ownerDid,
     type: type ?? this.type,
     seenAt: seenAt ?? this.seenAt,
     createdAt: createdAt ?? this.createdAt,
···
   NotificationsSyncQueueData copyWithCompanion(NotificationsSyncQueueCompanion data) {
     return NotificationsSyncQueueData(
       id: data.id.present ? data.id.value : this.id,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       type: data.type.present ? data.type.value : this.type,
       seenAt: data.seenAt.present ? data.seenAt.value : this.seenAt,
       createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
···
   String toString() {
     return (StringBuffer('NotificationsSyncQueueData(')
           ..write('id: $id, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('type: $type, ')
           ..write('seenAt: $seenAt, ')
           ..write('createdAt: $createdAt, ')
···
   }
 
   @override
-  int get hashCode => Object.hash(id, type, seenAt, createdAt, retryCount);
+  int get hashCode => Object.hash(id, ownerDid, type, seenAt, createdAt, retryCount);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
       (other is NotificationsSyncQueueData &&
           other.id == this.id &&
+          other.ownerDid == this.ownerDid &&
           other.type == this.type &&
           other.seenAt == this.seenAt &&
           other.createdAt == this.createdAt &&
···
 
 class NotificationsSyncQueueCompanion extends UpdateCompanion<NotificationsSyncQueueData> {
   final Value<int> id;
+  final Value<String> ownerDid;
   final Value<String> type;
   final Value<String> seenAt;
   final Value<DateTime> createdAt;
   final Value<int> retryCount;
   const NotificationsSyncQueueCompanion({
     this.id = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.type = const Value.absent(),
     this.seenAt = const Value.absent(),
     this.createdAt = const Value.absent(),
···
   });
   NotificationsSyncQueueCompanion.insert({
     this.id = const Value.absent(),
+    required String ownerDid,
     required String type,
     required String seenAt,
     required DateTime createdAt,
     this.retryCount = const Value.absent(),
-  }) : type = Value(type),
+  }) : ownerDid = Value(ownerDid),
+       type = Value(type),
        seenAt = Value(seenAt),
        createdAt = Value(createdAt);
   static Insertable<NotificationsSyncQueueData> custom({
     Expression<int>? id,
+    Expression<String>? ownerDid,
     Expression<String>? type,
     Expression<String>? seenAt,
     Expression<DateTime>? createdAt,
···
   }) {
     return RawValuesInsertable({
       if (id != null) 'id': id,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (type != null) 'type': type,
       if (seenAt != null) 'seen_at': seenAt,
       if (createdAt != null) 'created_at': createdAt,
···
 
   NotificationsSyncQueueCompanion copyWith({
     Value<int>? id,
+    Value<String>? ownerDid,
     Value<String>? type,
     Value<String>? seenAt,
     Value<DateTime>? createdAt,
···
   }) {
     return NotificationsSyncQueueCompanion(
       id: id ?? this.id,
+      ownerDid: ownerDid ?? this.ownerDid,
       type: type ?? this.type,
       seenAt: seenAt ?? this.seenAt,
       createdAt: createdAt ?? this.createdAt,
···
     final map = <String, Expression>{};
     if (id.present) {
       map['id'] = Variable<int>(id.value);
+    }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
     }
     if (type.present) {
       map['type'] = Variable<String>(type.value);
···
   String toString() {
     return (StringBuffer('NotificationsSyncQueueCompanion(')
           ..write('id: $id, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('type: $type, ')
           ..write('seenAt: $seenAt, ')
           ..write('createdAt: $createdAt, ')
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _membersJsonMeta = const VerificationMeta('membersJson');
   @override
   late final GeneratedColumn<String> membersJson = GeneratedColumn<String>(
···
   @override
   List<GeneratedColumn> get $columns => [
     convoId,
+    ownerDid,
     membersJson,
     lastMessageText,
     lastMessageAt,
···
       context.handle(_convoIdMeta, convoId.isAcceptableOrUnknown(data['convo_id']!, _convoIdMeta));
     } else if (isInserting) {
       context.missing(_convoIdMeta);
+    }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
     }
     if (data.containsKey('members_json')) {
       context.handle(
···
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {convoId};
+  Set<GeneratedColumn> get $primaryKey => {convoId, ownerDid};
   @override
   DmConvo map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
···
       convoId: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}convo_id'],
+      )!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
       )!,
       membersJson: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
···
   /// Conversation ID (unique identifier from API).
   final String convoId;
 
+  /// The DID of the user who owns this conversation view.
+  final String ownerDid;
+
   /// JSON array of participant DIDs.
   final String membersJson;
 
···
   final DateTime cachedAt;
   const DmConvo({
     required this.convoId,
+    required this.ownerDid,
     required this.membersJson,
     this.lastMessageText,
     this.lastMessageAt,
···
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['convo_id'] = Variable<String>(convoId);
+    map['owner_did'] = Variable<String>(ownerDid);
     map['members_json'] = Variable<String>(membersJson);
     if (!nullToAbsent || lastMessageText != null) {
       map['last_message_text'] = Variable<String>(lastMessageText);
···
   DmConvosCompanion toCompanion(bool nullToAbsent) {
     return DmConvosCompanion(
       convoId: Value(convoId),
+      ownerDid: Value(ownerDid),
       membersJson: Value(membersJson),
       lastMessageText: lastMessageText == null && nullToAbsent
           ? const Value.absent()
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return DmConvo(
       convoId: serializer.fromJson<String>(json['convoId']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       membersJson: serializer.fromJson<String>(json['membersJson']),
       lastMessageText: serializer.fromJson<String?>(json['lastMessageText']),
       lastMessageAt: serializer.fromJson<DateTime?>(json['lastMessageAt']),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'convoId': serializer.toJson<String>(convoId),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'membersJson': serializer.toJson<String>(membersJson),
       'lastMessageText': serializer.toJson<String?>(lastMessageText),
       'lastMessageAt': serializer.toJson<DateTime?>(lastMessageAt),
···
 
   DmConvo copyWith({
     String? convoId,
+    String? ownerDid,
     String? membersJson,
     Value<String?> lastMessageText = const Value.absent(),
     Value<DateTime?> lastMessageAt = const Value.absent(),
···
     DateTime? cachedAt,
   }) => DmConvo(
     convoId: convoId ?? this.convoId,
+    ownerDid: ownerDid ?? this.ownerDid,
     membersJson: membersJson ?? this.membersJson,
     lastMessageText: lastMessageText.present ? lastMessageText.value : this.lastMessageText,
     lastMessageAt: lastMessageAt.present ? lastMessageAt.value : this.lastMessageAt,
···
   DmConvo copyWithCompanion(DmConvosCompanion data) {
     return DmConvo(
       convoId: data.convoId.present ? data.convoId.value : this.convoId,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       membersJson: data.membersJson.present ? data.membersJson.value : this.membersJson,
       lastMessageText: data.lastMessageText.present
           ? data.lastMessageText.value
···
   String toString() {
     return (StringBuffer('DmConvo(')
           ..write('convoId: $convoId, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('membersJson: $membersJson, ')
           ..write('lastMessageText: $lastMessageText, ')
           ..write('lastMessageAt: $lastMessageAt, ')
···
   @override
   int get hashCode => Object.hash(
     convoId,
+    ownerDid,
     membersJson,
     lastMessageText,
     lastMessageAt,
···
       identical(this, other) ||
       (other is DmConvo &&
           other.convoId == this.convoId &&
+          other.ownerDid == this.ownerDid &&
           other.membersJson == this.membersJson &&
           other.lastMessageText == this.lastMessageText &&
           other.lastMessageAt == this.lastMessageAt &&
···
 
 class DmConvosCompanion extends UpdateCompanion<DmConvo> {
   final Value<String> convoId;
+  final Value<String> ownerDid;
   final Value<String> membersJson;
   final Value<String?> lastMessageText;
   final Value<DateTime?> lastMessageAt;
···
   final Value<int> rowid;
   const DmConvosCompanion({
     this.convoId = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.membersJson = const Value.absent(),
     this.lastMessageText = const Value.absent(),
     this.lastMessageAt = const Value.absent(),
···
   });
   DmConvosCompanion.insert({
     required String convoId,
+    required String ownerDid,
     required String membersJson,
     this.lastMessageText = const Value.absent(),
     this.lastMessageAt = const Value.absent(),
···
     required DateTime cachedAt,
     this.rowid = const Value.absent(),
   }) : convoId = Value(convoId),
+       ownerDid = Value(ownerDid),
        membersJson = Value(membersJson),
        cachedAt = Value(cachedAt);
   static Insertable<DmConvo> custom({
     Expression<String>? convoId,
+    Expression<String>? ownerDid,
     Expression<String>? membersJson,
     Expression<String>? lastMessageText,
     Expression<DateTime>? lastMessageAt,
···
   }) {
     return RawValuesInsertable({
       if (convoId != null) 'convo_id': convoId,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (membersJson != null) 'members_json': membersJson,
       if (lastMessageText != null) 'last_message_text': lastMessageText,
       if (lastMessageAt != null) 'last_message_at': lastMessageAt,
···
 
   DmConvosCompanion copyWith({
     Value<String>? convoId,
+    Value<String>? ownerDid,
     Value<String>? membersJson,
     Value<String?>? lastMessageText,
     Value<DateTime?>? lastMessageAt,
···
   }) {
     return DmConvosCompanion(
       convoId: convoId ?? this.convoId,
+      ownerDid: ownerDid ?? this.ownerDid,
       membersJson: membersJson ?? this.membersJson,
       lastMessageText: lastMessageText ?? this.lastMessageText,
       lastMessageAt: lastMessageAt ?? this.lastMessageAt,
···
     if (convoId.present) {
       map['convo_id'] = Variable<String>(convoId.value);
     }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
+    }
     if (membersJson.present) {
       map['members_json'] = Variable<String>(membersJson.value);
     }
···
   String toString() {
     return (StringBuffer('DmConvosCompanion(')
           ..write('convoId: $convoId, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('membersJson: $membersJson, ')
           ..write('lastMessageText: $lastMessageText, ')
           ..write('lastMessageAt: $lastMessageAt, ')
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _convoIdMeta = const VerificationMeta('convoId');
   @override
   late final GeneratedColumn<String> convoId = GeneratedColumn<String>(
···
   @override
   List<GeneratedColumn> get $columns => [
     messageId,
+    ownerDid,
     convoId,
     senderDid,
     content,
···
     } else if (isInserting) {
       context.missing(_messageIdMeta);
     }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
+    }
     if (data.containsKey('convo_id')) {
       context.handle(_convoIdMeta, convoId.isAcceptableOrUnknown(data['convo_id']!, _convoIdMeta));
     } else if (isInserting) {
···
   }
 
   @override
-  Set<GeneratedColumn> get $primaryKey => {messageId};
+  Set<GeneratedColumn> get $primaryKey => {messageId, ownerDid};
   @override
   DmMessage map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
···
         DriftSqlType.string,
         data['${effectivePrefix}message_id'],
       )!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
+      )!,
       convoId: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}convo_id'],
···
 class DmMessage extends DataClass implements Insertable<DmMessage> {
   /// Message ID (unique identifier from API).
   final String messageId;
+
+  /// The DID of the user who owns this message view.
+  final String ownerDid;
 
   /// Conversation this message belongs to.
   final String convoId;
···
   final DateTime cachedAt;
   const DmMessage({
     required this.messageId,
+    required this.ownerDid,
     required this.convoId,
     required this.senderDid,
     required this.content,
···
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['message_id'] = Variable<String>(messageId);
+    map['owner_did'] = Variable<String>(ownerDid);
     map['convo_id'] = Variable<String>(convoId);
     map['sender_did'] = Variable<String>(senderDid);
     map['content'] = Variable<String>(content);
···
   DmMessagesCompanion toCompanion(bool nullToAbsent) {
     return DmMessagesCompanion(
       messageId: Value(messageId),
+      ownerDid: Value(ownerDid),
       convoId: Value(convoId),
       senderDid: Value(senderDid),
       content: Value(content),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return DmMessage(
       messageId: serializer.fromJson<String>(json['messageId']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       convoId: serializer.fromJson<String>(json['convoId']),
       senderDid: serializer.fromJson<String>(json['senderDid']),
       content: serializer.fromJson<String>(json['content']),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'messageId': serializer.toJson<String>(messageId),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'convoId': serializer.toJson<String>(convoId),
       'senderDid': serializer.toJson<String>(senderDid),
       'content': serializer.toJson<String>(content),
···
 
   DmMessage copyWith({
     String? messageId,
+    String? ownerDid,
     String? convoId,
     String? senderDid,
     String? content,
···
     DateTime? cachedAt,
   }) => DmMessage(
     messageId: messageId ?? this.messageId,
+    ownerDid: ownerDid ?? this.ownerDid,
     convoId: convoId ?? this.convoId,
     senderDid: senderDid ?? this.senderDid,
     content: content ?? this.content,
···
   DmMessage copyWithCompanion(DmMessagesCompanion data) {
     return DmMessage(
       messageId: data.messageId.present ? data.messageId.value : this.messageId,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       convoId: data.convoId.present ? data.convoId.value : this.convoId,
       senderDid: data.senderDid.present ? data.senderDid.value : this.senderDid,
       content: data.content.present ? data.content.value : this.content,
···
   String toString() {
     return (StringBuffer('DmMessage(')
           ..write('messageId: $messageId, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('convoId: $convoId, ')
           ..write('senderDid: $senderDid, ')
           ..write('content: $content, ')
···
 
   @override
   int get hashCode =>
-      Object.hash(messageId, convoId, senderDid, content, sentAt, status, cachedAt);
+      Object.hash(messageId, ownerDid, convoId, senderDid, content, sentAt, status, cachedAt);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
       (other is DmMessage &&
           other.messageId == this.messageId &&
+          other.ownerDid == this.ownerDid &&
           other.convoId == this.convoId &&
           other.senderDid == this.senderDid &&
           other.content == this.content &&
···
 
 class DmMessagesCompanion extends UpdateCompanion<DmMessage> {
   final Value<String> messageId;
+  final Value<String> ownerDid;
   final Value<String> convoId;
   final Value<String> senderDid;
   final Value<String> content;
···
   final Value<int> rowid;
   const DmMessagesCompanion({
     this.messageId = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.convoId = const Value.absent(),
     this.senderDid = const Value.absent(),
     this.content = const Value.absent(),
···
   });
   DmMessagesCompanion.insert({
     required String messageId,
+    required String ownerDid,
     required String convoId,
     required String senderDid,
     required String content,
···
     required DateTime cachedAt,
     this.rowid = const Value.absent(),
   }) : messageId = Value(messageId),
+       ownerDid = Value(ownerDid),
        convoId = Value(convoId),
        senderDid = Value(senderDid),
        content = Value(content),
···
        cachedAt = Value(cachedAt);
   static Insertable<DmMessage> custom({
     Expression<String>? messageId,
+    Expression<String>? ownerDid,
     Expression<String>? convoId,
     Expression<String>? senderDid,
     Expression<String>? content,
···
   }) {
     return RawValuesInsertable({
       if (messageId != null) 'message_id': messageId,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (convoId != null) 'convo_id': convoId,
       if (senderDid != null) 'sender_did': senderDid,
       if (content != null) 'content': content,
···
 
   DmMessagesCompanion copyWith({
     Value<String>? messageId,
+    Value<String>? ownerDid,
     Value<String>? convoId,
     Value<String>? senderDid,
     Value<String>? content,
···
   }) {
     return DmMessagesCompanion(
       messageId: messageId ?? this.messageId,
+      ownerDid: ownerDid ?? this.ownerDid,
       convoId: convoId ?? this.convoId,
       senderDid: senderDid ?? this.senderDid,
       content: content ?? this.content,
···
     final map = <String, Expression>{};
     if (messageId.present) {
       map['message_id'] = Variable<String>(messageId.value);
+    }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
     }
     if (convoId.present) {
       map['convo_id'] = Variable<String>(convoId.value);
···
   String toString() {
     return (StringBuffer('DmMessagesCompanion(')
           ..write('messageId: $messageId, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('convoId: $convoId, ')
           ..write('senderDid: $senderDid, ')
           ..write('content: $content, ')
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
+  static const VerificationMeta _ownerDidMeta = const VerificationMeta('ownerDid');
+  @override
+  late final GeneratedColumn<String> ownerDid = GeneratedColumn<String>(
+    'owner_did',
+    aliasedName,
+    false,
+    type: DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
   static const VerificationMeta _convoIdMeta = const VerificationMeta('convoId');
   @override
   late final GeneratedColumn<String> convoId = GeneratedColumn<String>(
···
   @override
   List<GeneratedColumn> get $columns => [
     outboxId,
+    ownerDid,
     convoId,
     messageText,
     status,
···
     } else if (isInserting) {
       context.missing(_outboxIdMeta);
     }
+    if (data.containsKey('owner_did')) {
+      context.handle(
+        _ownerDidMeta,
+        ownerDid.isAcceptableOrUnknown(data['owner_did']!, _ownerDidMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_ownerDidMeta);
+    }
     if (data.containsKey('convo_id')) {
       context.handle(_convoIdMeta, convoId.isAcceptableOrUnknown(data['convo_id']!, _convoIdMeta));
     } else if (isInserting) {
···
         DriftSqlType.string,
         data['${effectivePrefix}outbox_id'],
       )!,
+      ownerDid: attachedDatabase.typeMapping.read(
+        DriftSqlType.string,
+        data['${effectivePrefix}owner_did'],
+      )!,
       convoId: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}convo_id'],
···
 class DmOutboxData extends DataClass implements Insertable<DmOutboxData> {
   /// Local UUID for this outbox item.
   final String outboxId;
+
+  /// The DID of the user who sent this message.
+  final String ownerDid;
 
   /// Conversation to send the message to.
   final String convoId;
···
   final String? errorMessage;
   const DmOutboxData({
     required this.outboxId,
+    required this.ownerDid,
     required this.convoId,
     required this.messageText,
     required this.status,
···
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
     map['outbox_id'] = Variable<String>(outboxId);
+    map['owner_did'] = Variable<String>(ownerDid);
     map['convo_id'] = Variable<String>(convoId);
     map['message_text'] = Variable<String>(messageText);
     map['status'] = Variable<String>(status);
···
   DmOutboxCompanion toCompanion(bool nullToAbsent) {
     return DmOutboxCompanion(
       outboxId: Value(outboxId),
+      ownerDid: Value(ownerDid),
       convoId: Value(convoId),
       messageText: Value(messageText),
       status: Value(status),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return DmOutboxData(
       outboxId: serializer.fromJson<String>(json['outboxId']),
+      ownerDid: serializer.fromJson<String>(json['ownerDid']),
       convoId: serializer.fromJson<String>(json['convoId']),
       messageText: serializer.fromJson<String>(json['messageText']),
       status: serializer.fromJson<String>(json['status']),
···
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return <String, dynamic>{
       'outboxId': serializer.toJson<String>(outboxId),
+      'ownerDid': serializer.toJson<String>(ownerDid),
       'convoId': serializer.toJson<String>(convoId),
       'messageText': serializer.toJson<String>(messageText),
       'status': serializer.toJson<String>(status),
···
 
   DmOutboxData copyWith({
     String? outboxId,
+    String? ownerDid,
     String? convoId,
     String? messageText,
     String? status,
···
     Value<String?> errorMessage = const Value.absent(),
   }) => DmOutboxData(
     outboxId: outboxId ?? this.outboxId,
+    ownerDid: ownerDid ?? this.ownerDid,
     convoId: convoId ?? this.convoId,
     messageText: messageText ?? this.messageText,
     status: status ?? this.status,
···
   DmOutboxData copyWithCompanion(DmOutboxCompanion data) {
     return DmOutboxData(
       outboxId: data.outboxId.present ? data.outboxId.value : this.outboxId,
+      ownerDid: data.ownerDid.present ? data.ownerDid.value : this.ownerDid,
       convoId: data.convoId.present ? data.convoId.value : this.convoId,
       messageText: data.messageText.present ? data.messageText.value : this.messageText,
       status: data.status.present ? data.status.value : this.status,
···
   String toString() {
     return (StringBuffer('DmOutboxData(')
           ..write('outboxId: $outboxId, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('convoId: $convoId, ')
           ..write('messageText: $messageText, ')
           ..write('status: $status, ')
···
   @override
   int get hashCode => Object.hash(
     outboxId,
+    ownerDid,
     convoId,
     messageText,
     status,
···
       identical(this, other) ||
       (other is DmOutboxData &&
           other.outboxId == this.outboxId &&
+          other.ownerDid == this.ownerDid &&
           other.convoId == this.convoId &&
           other.messageText == this.messageText &&
           other.status == this.status &&
···
 
 class DmOutboxCompanion extends UpdateCompanion<DmOutboxData> {
   final Value<String> outboxId;
+  final Value<String> ownerDid;
   final Value<String> convoId;
   final Value<String> messageText;
   final Value<String> status;
···
   final Value<int> rowid;
   const DmOutboxCompanion({
     this.outboxId = const Value.absent(),
+    this.ownerDid = const Value.absent(),
     this.convoId = const Value.absent(),
     this.messageText = const Value.absent(),
     this.status = const Value.absent(),
···
   });
   DmOutboxCompanion.insert({
     required String outboxId,
+    required String ownerDid,
     required String convoId,
     required String messageText,
     required String status,
···
     this.errorMessage = const Value.absent(),
     this.rowid = const Value.absent(),
   }) : outboxId = Value(outboxId),
+       ownerDid = Value(ownerDid),
        convoId = Value(convoId),
        messageText = Value(messageText),
        status = Value(status),
        createdAt = Value(createdAt);
   static Insertable<DmOutboxData> custom({
     Expression<String>? outboxId,
+    Expression<String>? ownerDid,
     Expression<String>? convoId,
     Expression<String>? messageText,
     Expression<String>? status,
···
   }) {
     return RawValuesInsertable({
       if (outboxId != null) 'outbox_id': outboxId,
+      if (ownerDid != null) 'owner_did': ownerDid,
       if (convoId != null) 'convo_id': convoId,
       if (messageText != null) 'message_text': messageText,
       if (status != null) 'status': status,
···
 
   DmOutboxCompanion copyWith({
     Value<String>? outboxId,
+    Value<String>? ownerDid,
     Value<String>? convoId,
     Value<String>? messageText,
     Value<String>? status,
···
   }) {
     return DmOutboxCompanion(
       outboxId: outboxId ?? this.outboxId,
+      ownerDid: ownerDid ?? this.ownerDid,
       convoId: convoId ?? this.convoId,
       messageText: messageText ?? this.messageText,
       status: status ?? this.status,
···
     if (outboxId.present) {
       map['outbox_id'] = Variable<String>(outboxId.value);
     }
+    if (ownerDid.present) {
+      map['owner_did'] = Variable<String>(ownerDid.value);
+    }
     if (convoId.present) {
       map['convo_id'] = Variable<String>(convoId.value);
     }
···
   String toString() {
     return (StringBuffer('DmOutboxCompanion(')
           ..write('outboxId: $outboxId, ')
+          ..write('ownerDid: $ownerDid, ')
           ..write('convoId: $convoId, ')
           ..write('messageText: $messageText, ')
           ..write('status: $status, ')
···
     FeedContentItemsCompanion Function({
       required String feedKey,
       required String postUri,
+      required String ownerDid,
       Value<String?> reason,
       required String sortKey,
       Value<int> rowid,
···
     FeedContentItemsCompanion Function({
       Value<String> feedKey,
       Value<String> postUri,
+      Value<String> ownerDid,
       Value<String?> reason,
       Value<String> sortKey,
       Value<int> rowid,
···
   ColumnFilters<String> get feedKey =>
       $composableBuilder(column: $table.feedKey, builder: (column) => ColumnFilters(column));
 
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
+
   ColumnFilters<String> get reason =>
       $composableBuilder(column: $table.reason, builder: (column) => ColumnFilters(column));
 
···
   ColumnOrderings<String> get feedKey =>
       $composableBuilder(column: $table.feedKey, builder: (column) => ColumnOrderings(column));
 
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<String> get reason =>
       $composableBuilder(column: $table.reason, builder: (column) => ColumnOrderings(column));
 
···
   });
   GeneratedColumn<String> get feedKey =>
       $composableBuilder(column: $table.feedKey, builder: (column) => column);
+
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
 
   GeneratedColumn<String> get reason =>
       $composableBuilder(column: $table.reason, builder: (column) => column);
···
               ({
                 Value<String> feedKey = const Value.absent(),
                 Value<String> postUri = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String?> reason = const Value.absent(),
                 Value<String> sortKey = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
               }) => FeedContentItemsCompanion(
                 feedKey: feedKey,
                 postUri: postUri,
+                ownerDid: ownerDid,
                 reason: reason,
                 sortKey: sortKey,
                 rowid: rowid,
···
               ({
                 required String feedKey,
                 required String postUri,
+                required String ownerDid,
                 Value<String?> reason = const Value.absent(),
                 required String sortKey,
                 Value<int> rowid = const Value.absent(),
               }) => FeedContentItemsCompanion.insert(
                 feedKey: feedKey,
                 postUri: postUri,
+                ownerDid: ownerDid,
                 reason: reason,
                 sortKey: sortKey,
                 rowid: rowid,
···
 typedef $$FeedCursorsTableCreateCompanionBuilder =
     FeedCursorsCompanion Function({
       required String feedKey,
+      required String ownerDid,
       required String cursor,
       Value<DateTime?> lastUpdated,
       Value<int> rowid,
···
 typedef $$FeedCursorsTableUpdateCompanionBuilder =
     FeedCursorsCompanion Function({
       Value<String> feedKey,
+      Value<String> ownerDid,
       Value<String> cursor,
       Value<DateTime?> lastUpdated,
       Value<int> rowid,
···
   });
   ColumnFilters<String> get feedKey =>
       $composableBuilder(column: $table.feedKey, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
 
   ColumnFilters<String> get cursor =>
       $composableBuilder(column: $table.cursor, builder: (column) => ColumnFilters(column));
···
   ColumnOrderings<String> get feedKey =>
       $composableBuilder(column: $table.feedKey, builder: (column) => ColumnOrderings(column));
 
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<String> get cursor =>
       $composableBuilder(column: $table.cursor, builder: (column) => ColumnOrderings(column));
 
···
   GeneratedColumn<String> get feedKey =>
       $composableBuilder(column: $table.feedKey, builder: (column) => column);
 
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
+
   GeneratedColumn<String> get cursor =>
       $composableBuilder(column: $table.cursor, builder: (column) => column);
 
···
           updateCompanionCallback:
               ({
                 Value<String> feedKey = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> cursor = const Value.absent(),
                 Value<DateTime?> lastUpdated = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
               }) => FeedCursorsCompanion(
                 feedKey: feedKey,
+                ownerDid: ownerDid,
                 cursor: cursor,
                 lastUpdated: lastUpdated,
                 rowid: rowid,
···
           createCompanionCallback:
               ({
                 required String feedKey,
+                required String ownerDid,
                 required String cursor,
                 Value<DateTime?> lastUpdated = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
               }) => FeedCursorsCompanion.insert(
                 feedKey: feedKey,
+                ownerDid: ownerDid,
                 cursor: cursor,
                 lastUpdated: lastUpdated,
                 rowid: rowid,
···
 typedef $$SavedFeedsTableCreateCompanionBuilder =
     SavedFeedsCompanion Function({
       required String uri,
+      required String ownerDid,
       required String displayName,
       Value<String?> description,
       Value<String?> avatar,
···
 typedef $$SavedFeedsTableUpdateCompanionBuilder =
     SavedFeedsCompanion Function({
       Value<String> uri,
+      Value<String> ownerDid,
       Value<String> displayName,
       Value<String?> description,
       Value<String?> avatar,
···
   ColumnFilters<String> get uri =>
       $composableBuilder(column: $table.uri, builder: (column) => ColumnFilters(column));
 
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
+
   ColumnFilters<String> get displayName =>
       $composableBuilder(column: $table.displayName, builder: (column) => ColumnFilters(column));
 
···
   ColumnOrderings<String> get uri =>
       $composableBuilder(column: $table.uri, builder: (column) => ColumnOrderings(column));
 
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<String> get displayName =>
       $composableBuilder(column: $table.displayName, builder: (column) => ColumnOrderings(column));
 
···
   });
   GeneratedColumn<String> get uri =>
       $composableBuilder(column: $table.uri, builder: (column) => column);
+
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
 
   GeneratedColumn<String> get displayName =>
       $composableBuilder(column: $table.displayName, builder: (column) => column);
···
           updateCompanionCallback:
               ({
                 Value<String> uri = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> displayName = const Value.absent(),
                 Value<String?> description = const Value.absent(),
                 Value<String?> avatar = const Value.absent(),
···
                 Value<int> rowid = const Value.absent(),
               }) => SavedFeedsCompanion(
                 uri: uri,
+                ownerDid: ownerDid,
                 displayName: displayName,
                 description: description,
                 avatar: avatar,
···
           createCompanionCallback:
               ({
                 required String uri,
+                required String ownerDid,
                 required String displayName,
                 Value<String?> description = const Value.absent(),
                 Value<String?> avatar = const Value.absent(),
···
                 Value<int> rowid = const Value.absent(),
               }) => SavedFeedsCompanion.insert(
                 uri: uri,
+                ownerDid: ownerDid,
                 displayName: displayName,
                 description: description,
                 avatar: avatar,
···
 typedef $$PreferenceSyncQueueTableCreateCompanionBuilder =
     PreferenceSyncQueueCompanion Function({
       Value<int> id,
+      required String ownerDid,
       Value<String> category,
       required String type,
       required String payload,
···
 typedef $$PreferenceSyncQueueTableUpdateCompanionBuilder =
     PreferenceSyncQueueCompanion Function({
       Value<int> id,
+      Value<String> ownerDid,
       Value<String> category,
       Value<String> type,
       Value<String> payload,
···
   });
   ColumnFilters<int> get id =>
       $composableBuilder(column: $table.id, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
 
   ColumnFilters<String> get category =>
       $composableBuilder(column: $table.category, builder: (column) => ColumnFilters(column));
···
   ColumnOrderings<int> get id =>
       $composableBuilder(column: $table.id, builder: (column) => ColumnOrderings(column));
 
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<String> get category =>
       $composableBuilder(column: $table.category, builder: (column) => ColumnOrderings(column));
 
···
   });
   GeneratedColumn<int> get id =>
       $composableBuilder(column: $table.id, builder: (column) => column);
+
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
 
   GeneratedColumn<String> get category =>
       $composableBuilder(column: $table.category, builder: (column) => column);
···
           updateCompanionCallback:
               ({
                 Value<int> id = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> category = const Value.absent(),
                 Value<String> type = const Value.absent(),
                 Value<String> payload = const Value.absent(),
···
                 Value<int> retryCount = const Value.absent(),
               }) => PreferenceSyncQueueCompanion(
                 id: id,
+                ownerDid: ownerDid,
                 category: category,
                 type: type,
                 payload: payload,
···
           createCompanionCallback:
               ({
                 Value<int> id = const Value.absent(),
+                required String ownerDid,
                 Value<String> category = const Value.absent(),
                 required String type,
                 required String payload,
···
                 Value<int> retryCount = const Value.absent(),
               }) => PreferenceSyncQueueCompanion.insert(
                 id: id,
+                ownerDid: ownerDid,
                 category: category,
                 type: type,
                 payload: payload,
···
     >;
 typedef $$ProfileRelationshipsTableCreateCompanionBuilder =
     ProfileRelationshipsCompanion Function({
+      required String ownerDid,
       required String profileDid,
       Value<bool> following,
       Value<String?> followingUri,
···
     });
 typedef $$ProfileRelationshipsTableUpdateCompanionBuilder =
     ProfileRelationshipsCompanion Function({
+      Value<String> ownerDid,
       Value<String> profileDid,
       Value<bool> following,
       Value<String?> followingUri,
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
+
   ColumnFilters<bool> get following =>
       $composableBuilder(column: $table.following, builder: (column) => ColumnFilters(column));
 
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<bool> get following =>
       $composableBuilder(column: $table.following, builder: (column) => ColumnOrderings(column));
 
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
+
   GeneratedColumn<bool> get following =>
       $composableBuilder(column: $table.following, builder: (column) => column);
 
···
               $$ProfileRelationshipsTableAnnotationComposer($db: db, $table: table),
           updateCompanionCallback:
               ({
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> profileDid = const Value.absent(),
                 Value<bool> following = const Value.absent(),
                 Value<String?> followingUri = const Value.absent(),
···
                 Value<DateTime> updatedAt = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
               }) => ProfileRelationshipsCompanion(
+                ownerDid: ownerDid,
                 profileDid: profileDid,
                 following: following,
                 followingUri: followingUri,
···
               ),
           createCompanionCallback:
               ({
+                required String ownerDid,
                 required String profileDid,
                 Value<bool> following = const Value.absent(),
                 Value<String?> followingUri = const Value.absent(),
···
                 required DateTime updatedAt,
                 Value<int> rowid = const Value.absent(),
               }) => ProfileRelationshipsCompanion.insert(
+                ownerDid: ownerDid,
                 profileDid: profileDid,
                 following: following,
                 followingUri: followingUri,
···
 typedef $$BlueskyPreferencesTableCreateCompanionBuilder =
     BlueskyPreferencesCompanion Function({
       required String type,
+      required String ownerDid,
       required String data,
       required DateTime lastSynced,
       Value<int> rowid,
···
 typedef $$BlueskyPreferencesTableUpdateCompanionBuilder =
     BlueskyPreferencesCompanion Function({
       Value<String> type,
+      Value<String> ownerDid,
       Value<String> data,
       Value<DateTime> lastSynced,
       Value<int> rowid,
···
   ColumnFilters<String> get type =>
       $composableBuilder(column: $table.type, builder: (column) => ColumnFilters(column));
 
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
+
   ColumnFilters<String> get data =>
       $composableBuilder(column: $table.data, builder: (column) => ColumnFilters(column));
 
···
   ColumnOrderings<String> get type =>
       $composableBuilder(column: $table.type, builder: (column) => ColumnOrderings(column));
 
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<String> get data =>
       $composableBuilder(column: $table.data, builder: (column) => ColumnOrderings(column));
 
···
   GeneratedColumn<String> get type =>
       $composableBuilder(column: $table.type, builder: (column) => column);
 
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
+
   GeneratedColumn<String> get data =>
       $composableBuilder(column: $table.data, builder: (column) => column);
 
···
           updateCompanionCallback:
               ({
                 Value<String> type = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> data = const Value.absent(),
                 Value<DateTime> lastSynced = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
               }) => BlueskyPreferencesCompanion(
                 type: type,
+                ownerDid: ownerDid,
                 data: data,
                 lastSynced: lastSynced,
                 rowid: rowid,
···
           createCompanionCallback:
               ({
                 required String type,
+                required String ownerDid,
                 required String data,
                 required DateTime lastSynced,
                 Value<int> rowid = const Value.absent(),
               }) => BlueskyPreferencesCompanion.insert(
                 type: type,
+                ownerDid: ownerDid,
                 data: data,
                 lastSynced: lastSynced,
                 rowid: rowid,
···
 typedef $$NotificationsTableCreateCompanionBuilder =
     NotificationsCompanion Function({
       required String uri,
+      required String ownerDid,
       required String actorDid,
       required String type,
       Value<String?> reasonSubjectUri,
···
 typedef $$NotificationsTableUpdateCompanionBuilder =
     NotificationsCompanion Function({
       Value<String> uri,
+      Value<String> ownerDid,
       Value<String> actorDid,
       Value<String> type,
       Value<String?> reasonSubjectUri,
···
   ColumnFilters<String> get uri =>
       $composableBuilder(column: $table.uri, builder: (column) => ColumnFilters(column));
 
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
+
   ColumnFilters<String> get type =>
       $composableBuilder(column: $table.type, builder: (column) => ColumnFilters(column));
 
···
   ColumnOrderings<String> get uri =>
       $composableBuilder(column: $table.uri, builder: (column) => ColumnOrderings(column));
 
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<String> get type =>
       $composableBuilder(column: $table.type, builder: (column) => ColumnOrderings(column));
 
···
   });
   GeneratedColumn<String> get uri =>
       $composableBuilder(column: $table.uri, builder: (column) => column);
+
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
 
   GeneratedColumn<String> get type =>
       $composableBuilder(column: $table.type, builder: (column) => column);
···
           updateCompanionCallback:
               ({
                 Value<String> uri = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> actorDid = const Value.absent(),
                 Value<String> type = const Value.absent(),
                 Value<String?> reasonSubjectUri = const Value.absent(),
···
                 Value<int> rowid = const Value.absent(),
               }) => NotificationsCompanion(
                 uri: uri,
+                ownerDid: ownerDid,
                 actorDid: actorDid,
                 type: type,
                 reasonSubjectUri: reasonSubjectUri,
···
           createCompanionCallback:
               ({
                 required String uri,
+                required String ownerDid,
                 required String actorDid,
                 required String type,
                 Value<String?> reasonSubjectUri = const Value.absent(),
···
                 Value<int> rowid = const Value.absent(),
               }) => NotificationsCompanion.insert(
                 uri: uri,
+                ownerDid: ownerDid,
                 actorDid: actorDid,
                 type: type,
                 reasonSubjectUri: reasonSubjectUri,
···
 typedef $$NotificationCursorsTableCreateCompanionBuilder =
     NotificationCursorsCompanion Function({
       required String feedKey,
+      required String ownerDid,
       required String cursor,
       Value<DateTime?> lastUpdated,
       Value<int> rowid,
···
 typedef $$NotificationCursorsTableUpdateCompanionBuilder =
     NotificationCursorsCompanion Function({
       Value<String> feedKey,
+      Value<String> ownerDid,
       Value<String> cursor,
       Value<DateTime?> lastUpdated,
       Value<int> rowid,
···
   });
   ColumnFilters<String> get feedKey =>
       $composableBuilder(column: $table.feedKey, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
 
   ColumnFilters<String> get cursor =>
       $composableBuilder(column: $table.cursor, builder: (column) => ColumnFilters(column));
···
   ColumnOrderings<String> get feedKey =>
       $composableBuilder(column: $table.feedKey, builder: (column) => ColumnOrderings(column));
 
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<String> get cursor =>
       $composableBuilder(column: $table.cursor, builder: (column) => ColumnOrderings(column));
 
···
   });
   GeneratedColumn<String> get feedKey =>
       $composableBuilder(column: $table.feedKey, builder: (column) => column);
+
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
 
   GeneratedColumn<String> get cursor =>
       $composableBuilder(column: $table.cursor, builder: (column) => column);
···
           updateCompanionCallback:
               ({
                 Value<String> feedKey = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> cursor = const Value.absent(),
                 Value<DateTime?> lastUpdated = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
               }) => NotificationCursorsCompanion(
                 feedKey: feedKey,
+                ownerDid: ownerDid,
                 cursor: cursor,
                 lastUpdated: lastUpdated,
                 rowid: rowid,
···
           createCompanionCallback:
               ({
                 required String feedKey,
+                required String ownerDid,
                 required String cursor,
                 Value<DateTime?> lastUpdated = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
               }) => NotificationCursorsCompanion.insert(
                 feedKey: feedKey,
+                ownerDid: ownerDid,
                 cursor: cursor,
                 lastUpdated: lastUpdated,
                 rowid: rowid,
···
 typedef $$NotificationsSyncQueueTableCreateCompanionBuilder =
     NotificationsSyncQueueCompanion Function({
       Value<int> id,
+      required String ownerDid,
       required String type,
       required String seenAt,
       required DateTime createdAt,
···
 typedef $$NotificationsSyncQueueTableUpdateCompanionBuilder =
     NotificationsSyncQueueCompanion Function({
       Value<int> id,
+      Value<String> ownerDid,
       Value<String> type,
       Value<String> seenAt,
       Value<DateTime> createdAt,
···
   ColumnFilters<int> get id =>
       $composableBuilder(column: $table.id, builder: (column) => ColumnFilters(column));
 
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
+
   ColumnFilters<String> get type =>
       $composableBuilder(column: $table.type, builder: (column) => ColumnFilters(column));
 
···
   ColumnOrderings<int> get id =>
       $composableBuilder(column: $table.id, builder: (column) => ColumnOrderings(column));
 
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<String> get type =>
       $composableBuilder(column: $table.type, builder: (column) => ColumnOrderings(column));
 
···
   GeneratedColumn<int> get id =>
       $composableBuilder(column: $table.id, builder: (column) => column);
 
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
+
   GeneratedColumn<String> get type =>
       $composableBuilder(column: $table.type, builder: (column) => column);
 
···
           updateCompanionCallback:
               ({
                 Value<int> id = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> type = const Value.absent(),
                 Value<String> seenAt = const Value.absent(),
                 Value<DateTime> createdAt = const Value.absent(),
                 Value<int> retryCount = const Value.absent(),
               }) => NotificationsSyncQueueCompanion(
                 id: id,
+                ownerDid: ownerDid,
                 type: type,
                 seenAt: seenAt,
                 createdAt: createdAt,
···
           createCompanionCallback:
               ({
                 Value<int> id = const Value.absent(),
+                required String ownerDid,
                 required String type,
                 required String seenAt,
                 required DateTime createdAt,
                 Value<int> retryCount = const Value.absent(),
               }) => NotificationsSyncQueueCompanion.insert(
                 id: id,
+                ownerDid: ownerDid,
                 type: type,
                 seenAt: seenAt,
                 createdAt: createdAt,
···
 typedef $$DmConvosTableCreateCompanionBuilder =
     DmConvosCompanion Function({
       required String convoId,
+      required String ownerDid,
       required String membersJson,
       Value<String?> lastMessageText,
       Value<DateTime?> lastMessageAt,
···
 typedef $$DmConvosTableUpdateCompanionBuilder =
     DmConvosCompanion Function({
       Value<String> convoId,
+      Value<String> ownerDid,
       Value<String> membersJson,
       Value<String?> lastMessageText,
       Value<DateTime?> lastMessageAt,
···
   });
   ColumnFilters<String> get convoId =>
       $composableBuilder(column: $table.convoId, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
 
   ColumnFilters<String> get membersJson =>
       $composableBuilder(column: $table.membersJson, builder: (column) => ColumnFilters(column));
···
   ColumnOrderings<String> get convoId =>
       $composableBuilder(column: $table.convoId, builder: (column) => ColumnOrderings(column));
 
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<String> get membersJson =>
       $composableBuilder(column: $table.membersJson, builder: (column) => ColumnOrderings(column));
 
···
   });
   GeneratedColumn<String> get convoId =>
       $composableBuilder(column: $table.convoId, builder: (column) => column);
+
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
 
   GeneratedColumn<String> get membersJson =>
       $composableBuilder(column: $table.membersJson, builder: (column) => column);
···
           updateCompanionCallback:
               ({
                 Value<String> convoId = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> membersJson = const Value.absent(),
                 Value<String?> lastMessageText = const Value.absent(),
                 Value<DateTime?> lastMessageAt = const Value.absent(),
···
                 Value<int> rowid = const Value.absent(),
               }) => DmConvosCompanion(
                 convoId: convoId,
+                ownerDid: ownerDid,
                 membersJson: membersJson,
                 lastMessageText: lastMessageText,
                 lastMessageAt: lastMessageAt,
···
           createCompanionCallback:
               ({
                 required String convoId,
+                required String ownerDid,
                 required String membersJson,
                 Value<String?> lastMessageText = const Value.absent(),
                 Value<DateTime?> lastMessageAt = const Value.absent(),
···
                 Value<int> rowid = const Value.absent(),
               }) => DmConvosCompanion.insert(
                 convoId: convoId,
+                ownerDid: ownerDid,
                 membersJson: membersJson,
                 lastMessageText: lastMessageText,
                 lastMessageAt: lastMessageAt,
···
 typedef $$DmMessagesTableCreateCompanionBuilder =
     DmMessagesCompanion Function({
       required String messageId,
+      required String ownerDid,
       required String convoId,
       required String senderDid,
       required String content,
···
 typedef $$DmMessagesTableUpdateCompanionBuilder =
     DmMessagesCompanion Function({
       Value<String> messageId,
+      Value<String> ownerDid,
       Value<String> convoId,
       Value<String> senderDid,
       Value<String> content,
···
   });
   ColumnFilters<String> get messageId =>
       $composableBuilder(column: $table.messageId, builder: (column) => ColumnFilters(column));
+
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
 
   ColumnFilters<String> get convoId =>
       $composableBuilder(column: $table.convoId, builder: (column) => ColumnFilters(column));
···
   ColumnOrderings<String> get messageId =>
       $composableBuilder(column: $table.messageId, builder: (column) => ColumnOrderings(column));
 
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
+
   ColumnOrderings<String> get convoId =>
       $composableBuilder(column: $table.convoId, builder: (column) => ColumnOrderings(column));
 
···
   });
   GeneratedColumn<String> get messageId =>
       $composableBuilder(column: $table.messageId, builder: (column) => column);
+
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
 
   GeneratedColumn<String> get convoId =>
       $composableBuilder(column: $table.convoId, builder: (column) => column);
···
           updateCompanionCallback:
               ({
                 Value<String> messageId = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> convoId = const Value.absent(),
                 Value<String> senderDid = const Value.absent(),
                 Value<String> content = const Value.absent(),
···
                 Value<int> rowid = const Value.absent(),
               }) => DmMessagesCompanion(
                 messageId: messageId,
+                ownerDid: ownerDid,
                 convoId: convoId,
                 senderDid: senderDid,
                 content: content,
···
           createCompanionCallback:
               ({
                 required String messageId,
+                required String ownerDid,
                 required String convoId,
                 required String senderDid,
                 required String content,
···
                 Value<int> rowid = const Value.absent(),
               }) => DmMessagesCompanion.insert(
                 messageId: messageId,
+                ownerDid: ownerDid,
                 convoId: convoId,
                 senderDid: senderDid,
                 content: content,
···
 typedef $$DmOutboxTableCreateCompanionBuilder =
     DmOutboxCompanion Function({
       required String outboxId,
+      required String ownerDid,
       required String convoId,
       required String messageText,
       required String status,
···
 typedef $$DmOutboxTableUpdateCompanionBuilder =
     DmOutboxCompanion Function({
       Value<String> outboxId,
+      Value<String> ownerDid,
       Value<String> convoId,
       Value<String> messageText,
       Value<String> status,
···
   ColumnFilters<String> get outboxId =>
       $composableBuilder(column: $table.outboxId, builder: (column) => ColumnFilters(column));
 
+  ColumnFilters<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnFilters(column));
+
   ColumnFilters<String> get convoId =>
       $composableBuilder(column: $table.convoId, builder: (column) => ColumnFilters(column));
 
···
   });
   ColumnOrderings<String> get outboxId =>
       $composableBuilder(column: $table.outboxId, builder: (column) => ColumnOrderings(column));
+
+  ColumnOrderings<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => ColumnOrderings(column));
 
   ColumnOrderings<String> get convoId =>
       $composableBuilder(column: $table.convoId, builder: (column) => ColumnOrderings(column));
···
   GeneratedColumn<String> get outboxId =>
       $composableBuilder(column: $table.outboxId, builder: (column) => column);
 
+  GeneratedColumn<String> get ownerDid =>
+      $composableBuilder(column: $table.ownerDid, builder: (column) => column);
+
   GeneratedColumn<String> get convoId =>
       $composableBuilder(column: $table.convoId, builder: (column) => column);
 
···
           updateCompanionCallback:
               ({
                 Value<String> outboxId = const Value.absent(),
+                Value<String> ownerDid = const Value.absent(),
                 Value<String> convoId = const Value.absent(),
                 Value<String> messageText = const Value.absent(),
                 Value<String> status = const Value.absent(),
···
                 Value<int> rowid = const Value.absent(),
               }) => DmOutboxCompanion(
                 outboxId: outboxId,
+                ownerDid: ownerDid,
                 convoId: convoId,
                 messageText: messageText,
                 status: status,
···
           createCompanionCallback:
               ({
                 required String outboxId,
+                required String ownerDid,
                 required String convoId,
                 required String messageText,
                 required String status,
···
                 Value<int> rowid = const Value.absent(),
               }) => DmOutboxCompanion.insert(
                 outboxId: outboxId,
+                ownerDid: ownerDid,
                 convoId: convoId,
                 messageText: messageText,
                 status: status,

lib/src/infrastructure/db/daos/bluesky_preferences_dao.dart

···
   /// Gets a preference by its type identifier.
   ///
   /// Returns null if no preference of that type exists.
-  Future<BlueskyPreference?> getPreferenceByType(String type) async {
-    final query = select(blueskyPreferences)..where((t) => t.type.equals(type));
+  Future<BlueskyPreference?> getPreferenceByType(String type, String ownerDid) async {
+    final query = select(blueskyPreferences)
+      ..where((t) => t.type.equals(type) & t.ownerDid.equals(ownerDid));
     return query.getSingleOrNull();
   }
 
   /// Watches a preference by its type identifier.
   ///
   /// Emits null if no preference of that type exists.
-  Stream<BlueskyPreference?> watchPreferenceByType(String type) {
-    final query = select(blueskyPreferences)..where((t) => t.type.equals(type));
+  Stream<BlueskyPreference?> watchPreferenceByType(String type, String ownerDid) {
+    final query = select(blueskyPreferences)
+      ..where((t) => t.type.equals(type) & t.ownerDid.equals(ownerDid));
     return query.watchSingleOrNull();
   }
 
-  /// Gets all cached preferences.
-  Future<List<BlueskyPreference>> getAllPreferences() async {
-    return select(blueskyPreferences).get();
+  /// Gets all cached preferences for a specific owner.
+  Future<List<BlueskyPreference>> getAllPreferences(String ownerDid) async {
+    return (select(blueskyPreferences)..where((t) => t.ownerDid.equals(ownerDid))).get();
   }
 
-  /// Watches all cached preferences.
-  Stream<List<BlueskyPreference>> watchAllPreferences() {
-    return select(blueskyPreferences).watch();
+  /// Watches all cached preferences for a specific owner.
+  Stream<List<BlueskyPreference>> watchAllPreferences(String ownerDid) {
+    return (select(blueskyPreferences)..where((t) => t.ownerDid.equals(ownerDid))).watch();
   }
 
   /// Inserts or updates a preference.
···
     required String type,
     required String data,
     required DateTime lastSynced,
+    required String ownerDid,
   }) async {
     await into(blueskyPreferences).insertOnConflictUpdate(
-      BlueskyPreferencesCompanion.insert(type: type, data: data, lastSynced: lastSynced),
+      BlueskyPreferencesCompanion.insert(
+        type: type,
+        ownerDid: ownerDid,
+        data: data,
+        lastSynced: lastSynced,
+      ),
     );
   }
 
   /// Deletes a preference by its type identifier.
   ///
   /// Returns 1 if deleted, 0 if not found.
-  Future<int> deletePreference(String type) async {
-    return (delete(blueskyPreferences)..where((t) => t.type.equals(type))).go();
+  Future<int> deletePreference(String type, String ownerDid) async {
+    return (delete(
+      blueskyPreferences,
+    )..where((t) => t.type.equals(type) & t.ownerDid.equals(ownerDid))).go();
   }
 
-  /// Clears all cached preferences.
+  /// Clears all cached preferences for a specific owner.
   ///
   /// Useful when signing out or resetting the app.
-  Future<int> clearAll() async {
-    return delete(blueskyPreferences).go();
+  Future<int> clearAll(String ownerDid) async {
+    return (delete(blueskyPreferences)..where((t) => t.ownerDid.equals(ownerDid))).go();
   }
 }

lib/src/infrastructure/db/daos/dm_messages_dao.dart

···
     });
   }
 
-  /// Gets a stream of messages for a conversation sorted by sentAt ascending.
-  Stream<List<DmMessageWithSender>> watchMessagesByConvo(String convoId) {
+  /// Gets a stream of messages for a conversation sorted by sentAt ascending for a specific user.
+  Stream<List<DmMessageWithSender>> watchMessagesByConvo(String convoId, String ownerDid) {
     final query = select(
       dmMessages,
     ).join([innerJoin(profiles, profiles.did.equalsExp(dmMessages.senderDid))]);
-    query.where(dmMessages.convoId.equals(convoId));
+    query.where(dmMessages.convoId.equals(convoId) & dmMessages.ownerDid.equals(ownerDid));
     query.orderBy([OrderingTerm.asc(dmMessages.sentAt)]);
 
     return query.watch().map((rows) {
···
   }
 
   /// Gets messages for a conversation (non-streaming).
-  Future<List<DmMessageWithSender>> getMessagesByConvo(String convoId) async {
+  Future<List<DmMessageWithSender>> getMessagesByConvo(String convoId, String ownerDid) async {
     final query = select(
       dmMessages,
     ).join([innerJoin(profiles, profiles.did.equalsExp(dmMessages.senderDid))]);
-    query.where(dmMessages.convoId.equals(convoId));
+    query.where(dmMessages.convoId.equals(convoId) & dmMessages.ownerDid.equals(ownerDid));
     query.orderBy([OrderingTerm.asc(dmMessages.sentAt)]);
 
     final rows = await query.get();
···
   }
 
   /// Updates the status of a message.
-  Future<void> updateMessageStatus({required String messageId, required String status}) async {
-    await (update(dmMessages)..where((m) => m.messageId.equals(messageId))).write(
-      DmMessagesCompanion(status: Value(status)),
-    );
+  Future<void> updateMessageStatus({
+    required String messageId,
+    required String ownerDid,
+    required String status,
+  }) async {
+    await (update(dmMessages)
+          ..where((m) => m.messageId.equals(messageId) & m.ownerDid.equals(ownerDid)))
+        .write(DmMessagesCompanion(status: Value(status)));
   }
 
   /// Deletes a single message by its ID.
-  Future<int> deleteMessage(String messageId) async {
-    return (delete(dmMessages)..where((m) => m.messageId.equals(messageId))).go();
+  Future<int> deleteMessage(String messageId, String ownerDid) async {
+    return (delete(
+      dmMessages,
+    )..where((m) => m.messageId.equals(messageId) & m.ownerDid.equals(ownerDid))).go();
   }
 
   /// Gets the most recent message in a conversation.
-  Future<DmMessage?> getLatestMessage(String convoId) async {
+  Future<DmMessage?> getLatestMessage(String convoId, String ownerDid) async {
     final query = select(dmMessages)
-      ..where((m) => m.convoId.equals(convoId))
+      ..where((m) => m.convoId.equals(convoId) & m.ownerDid.equals(ownerDid))
       ..orderBy([(m) => OrderingTerm.desc(m.sentAt)])
       ..limit(1);
     return query.getSingleOrNull();
   }
 
   /// Deletes all messages for a conversation.
-  Future<int> deleteMessagesByConvo(String convoId) async {
-    return (delete(dmMessages)..where((m) => m.convoId.equals(convoId))).go();
+  Future<int> deleteMessagesByConvo(String convoId, String ownerDid) async {
+    return (delete(
+      dmMessages,
+    )..where((m) => m.convoId.equals(convoId) & m.ownerDid.equals(ownerDid))).go();
   }
 
-  /// Clears all cached messages.
-  Future<void> clearMessages() async {
-    await delete(dmMessages).go();
+  /// Clears all cached messages for a specific owner.
+  Future<int> clearMessages(String ownerDid) async {
+    return (delete(dmMessages)..where((m) => m.ownerDid.equals(ownerDid))).go();
   }
 }
 

lib/src/infrastructure/db/daos/dm_outbox_dao.dart

···
     await into(dmOutbox).insert(item);
   }
 
-  /// Gets a stream of all pending outbox items.
-  Stream<List<DmOutboxData>> watchPending() {
+  /// Gets a stream of all pending outbox items for a specific owner.
+  Stream<List<DmOutboxData>> watchPending(String ownerDid) {
     return (select(dmOutbox)
-          ..where((o) => o.status.isIn(['pending', 'sending']))
+          ..where((o) => o.ownerDid.equals(ownerDid) & o.status.isIn(['pending', 'sending']))
           ..orderBy([(o) => OrderingTerm.asc(o.createdAt)]))
         .watch();
   }
 
-  /// Gets all pending outbox items, oldest first.
-  Future<List<DmOutboxData>> getPending() async {
+  /// Gets all pending outbox items for a specific owner, oldest first.
+  Future<List<DmOutboxData>> getPending(String ownerDid) async {
     return (select(dmOutbox)
-          ..where((o) => o.status.equals('pending'))
+          ..where((o) => o.ownerDid.equals(ownerDid) & o.status.equals('pending'))
           ..orderBy([(o) => OrderingTerm.asc(o.createdAt)]))
         .get();
   }
 
-  /// Gets all failed outbox items.
-  Future<List<DmOutboxData>> getFailed() async {
+  /// Gets all failed outbox items for a specific owner.
+  Future<List<DmOutboxData>> getFailed(String ownerDid) async {
     return (select(dmOutbox)
-          ..where((o) => o.status.equals('failed'))
+          ..where((o) => o.ownerDid.equals(ownerDid) & o.status.equals('failed'))
           ..orderBy([(o) => OrderingTerm.desc(o.lastAttemptAt)]))
         .get();
   }
···
     return (select(dmOutbox)..where((o) => o.outboxId.equals(outboxId))).getSingleOrNull();
   }
 
-  /// Gets pending outbox items for a specific conversation.
-  Future<List<DmOutboxData>> getByConvo(String convoId) async {
+  /// Gets pending outbox items for a specific conversation and owner.
+  Future<List<DmOutboxData>> getByConvo(String convoId, String ownerDid) async {
     return (select(dmOutbox)
-          ..where((o) => o.convoId.equals(convoId) & o.status.isIn(['pending', 'sending']))
+          ..where(
+            (o) =>
+                o.convoId.equals(convoId) &
+                o.ownerDid.equals(ownerDid) &
+                o.status.isIn(['pending', 'sending']),
+          )
           ..orderBy([(o) => OrderingTerm.asc(o.createdAt)]))
         .get();
   }
···
     return (delete(dmOutbox)..where((o) => o.outboxId.equals(outboxId))).go();
   }
 
-  /// Clears all outbox items.
-  Future<void> clearOutbox() async {
-    await delete(dmOutbox).go();
+  /// Clears all outbox items for a specific owner.
+  Future<void> clearOutbox(String ownerDid) async {
+    await (delete(dmOutbox)..where((o) => o.ownerDid.equals(ownerDid))).go();
   }
 
-  /// Counts pending items.
-  Future<int> countPending() async {
+  /// Counts pending items for a specific owner.
+  Future<int> countPending(String ownerDid) async {
     final count = dmOutbox.outboxId.count();
-    final query = selectOnly(dmOutbox)..addColumns([count]);
+    final query = selectOnly(dmOutbox)
+      ..where(dmOutbox.ownerDid.equals(ownerDid))
+      ..addColumns([count]);
     query.where(dmOutbox.status.equals('pending'));
     final result = await query.getSingle();
     return result.read(count) ?? 0;

lib/src/infrastructure/db/daos/feed_content_dao.dart

···
   FeedContentDao(super.db);
 
   /// Inserts or updates a batch of posts, profiles, and feed content items.
-  /// Also updates the cursor for the given [feedKey].
+  /// Also updates the cursor for the given [feedKey] and [ownerDid].
   Future<void> insertFeedContentBatch({
     required List<PostsCompanion> newPosts,
     required List<ProfilesCompanion> newProfiles,
     required List<ProfileRelationshipsCompanion> newRelationships,
     required List<FeedContentItemsCompanion> newItems,
     required String feedKey,
+    required String ownerDid,
     String? newCursor,
   }) {
     return transaction(() async {
···
             (item) => FeedContentItemsCompanion.insert(
               feedKey: item.feedKey.value,
               postUri: item.postUri.value,
+              ownerDid: ownerDid,
               reason: item.reason,
               sortKey: item.sortKey.value,
             ),
···
         await into(feedCursors).insertOnConflictUpdate(
           FeedCursorsCompanion.insert(
             feedKey: feedKey,
+            ownerDid: ownerDid,
             cursor: newCursor,
             lastUpdated: Value(DateTime.now()),
           ),
···
     });
   }
 
-  /// Get stream of feed content items for a given feed.
-  Stream<List<FeedPost>> watchFeedContent(String feedKey) {
+  /// Get stream of feed content items for a given feed and owner.
+  Stream<List<FeedPost>> watchFeedContent(String feedKey, String ownerDid) {
     final query = select(feedContentItems).join([
       innerJoin(posts, posts.uri.equalsExp(feedContentItems.postUri)),
       innerJoin(profiles, profiles.did.equalsExp(posts.authorDid)),
       leftOuterJoin(profileRelationships, profileRelationships.profileDid.equalsExp(profiles.did)),
     ]);
 
-    query.where(feedContentItems.feedKey.equals(feedKey));
+    query.where(
+      feedContentItems.feedKey.equals(feedKey) & feedContentItems.ownerDid.equals(ownerDid),
+    );
     query.orderBy([OrderingTerm.desc(feedContentItems.sortKey)]);
 
     return query.watch().map((rows) {
···
     });
   }
 
-  /// Gets the cursor for a specific feed.
-  Future<String?> getCursor(String feedKey) async {
-    final query = select(feedCursors)..where((t) => t.feedKey.equals(feedKey));
+  /// Gets the cursor for a specific feed and owner.
+  Future<String?> getCursor(String feedKey, String ownerDid) async {
+    final query = select(feedCursors)
+      ..where((t) => t.feedKey.equals(feedKey) & t.ownerDid.equals(ownerDid));
     final result = await query.getSingleOrNull();
     return result?.cursor;
   }
 
-  /// Clears all cached items for a specific feed.
-  Future<void> clearFeedContent(String feedKey) async {
-    await (delete(feedContentItems)..where((t) => t.feedKey.equals(feedKey))).go();
-    await (delete(feedCursors)..where((t) => t.feedKey.equals(feedKey))).go();
+  /// Clears all cached items for a specific feed and owner.
+  Future<void> clearFeedContent(String feedKey, String ownerDid) async {
+    await (delete(
+      feedContentItems,
+    )..where((t) => t.feedKey.equals(feedKey) & t.ownerDid.equals(ownerDid))).go();
+    await (delete(
+      feedCursors,
+    )..where((t) => t.feedKey.equals(feedKey) & t.ownerDid.equals(ownerDid))).go();
   }
 
-  /// Deletes feed content items and cursors for feeds not updated since [threshold].
-  Future<int> deleteStaleFeedContentItems(DateTime threshold) async {
+  /// Deletes feed content items and cursors for feeds not updated since [threshold] for a specific user.
+  Future<int> deleteStaleFeedContentItems(DateTime threshold, String ownerDid) async {
     return transaction(() async {
-      final staleCursors = await (select(
-        feedCursors,
-      )..where((t) => t.lastUpdated.isSmallerThanValue(threshold))).get();
+      final staleCursors =
+          await (select(feedCursors)
+                ..where((t) => t.ownerDid.equals(ownerDid))
+                ..where((t) => t.lastUpdated.isSmallerThanValue(threshold)))
+              .get();
 
       int deletedCount = 0;
 
       for (final cursor in staleCursors) {
         deletedCount += await (delete(
           feedContentItems,
-        )..where((t) => t.feedKey.equals(cursor.feedKey))).go();
-        await (delete(feedCursors)..where((t) => t.feedKey.equals(cursor.feedKey))).go();
+        )..where((t) => t.feedKey.equals(cursor.feedKey) & t.ownerDid.equals(ownerDid))).go();
+        await (delete(
+          feedCursors,
+        )..where((t) => t.feedKey.equals(cursor.feedKey) & t.ownerDid.equals(ownerDid))).go();
       }
 
       return deletedCount;

lib/src/infrastructure/db/daos/notifications_dao.dart

···
   NotificationsDao(super.db);
 
   /// Inserts or updates a batch of notifications.
-  /// Also updates the cursor for pagination.
+  ///
+  /// Also inserts associated profiles for authors.
   Future<void> insertNotificationsBatch({
     required List<NotificationsCompanion> newNotifications,
     required List<ProfilesCompanion> newProfiles,
-    String? newCursor,
+    required String? newCursor,
+    required String ownerDid,
   }) {
     return transaction(() async {
       await batch((batch) {
···
         await into(notificationCursors).insertOnConflictUpdate(
           NotificationCursorsCompanion.insert(
             feedKey: 'notifications',
+            ownerDid: ownerDid,
             cursor: newCursor,
             lastUpdated: Value(DateTime.now()),
           ),
···
     });
   }
 
-  /// Gets a stream of notifications with their actors.
-  Stream<List<NotificationWithActor>> watchNotifications() {
-    final query = select(
-      notifications,
-    ).join([innerJoin(profiles, profiles.did.equalsExp(notifications.actorDid))]);
-
-    query.orderBy([OrderingTerm.desc(notifications.indexedAt)]);
-
-    return query.watch().map((rows) {
-      return rows.map((row) {
-        return NotificationWithActor(
-          notification: row.readTable(notifications),
-          actor: row.readTable(profiles),
-        );
-      }).toList();
-    });
+  /// Gets a stream of notifications from the local cache for a specific user.
+  Stream<List<NotificationWithActor>> watchNotifications(String ownerDid) {
+    return (select(notifications)
+          ..where((t) => t.ownerDid.equals(ownerDid))
+          ..orderBy([(t) => OrderingTerm(expression: t.indexedAt, mode: OrderingMode.desc)]))
+        .join([innerJoin(profiles, profiles.did.equalsExp(notifications.actorDid))])
+        .watch()
+        .map((rows) {
+          return rows.map((row) {
+            return NotificationWithActor(
+              notification: row.readTable(notifications),
+              actor: row.readTable(profiles),
+            );
+          }).toList();
+        });
   }
 
-  /// Gets the pagination cursor.
-  Future<String?> getCursor() async {
-    final query = select(notificationCursors)..where((t) => t.feedKey.equals('notifications'));
-    final result = await query.getSingleOrNull();
-    return result?.cursor;
+  /// Gets the pagination cursor for loading more notifications.
+  Future<String?> getCursor(String ownerDid) {
+    final query = select(notificationCursors)
+      ..where((t) => t.feedKey.equals('notifications') & t.ownerDid.equals(ownerDid));
+    return query.map((t) => t.cursor).getSingleOrNull();
   }
 
-  /// Clears all cached notifications and cursor.
-  Future<void> clearNotifications() async {
-    await delete(notifications).go();
-    await (delete(notificationCursors)..where((t) => t.feedKey.equals('notifications'))).go();
+  /// Clears all cached notifications for a specific user.
+  Future<void> clearNotifications(String ownerDid) async {
+    await (delete(notifications)..where((t) => t.ownerDid.equals(ownerDid))).go();
+    await (delete(
+      notificationCursors,
+    )..where((t) => t.feedKey.equals('notifications') & t.ownerDid.equals(ownerDid))).go();
   }
 
-  /// Deletes notifications older than the given threshold.
-  Future<int> deleteStaleNotifications(DateTime threshold) async {
-    return (delete(notifications)..where((t) => t.cachedAt.isSmallerThanValue(threshold))).go();
+  /// Deletes notifications older than the specified threshold for a specific user.
+  Future<int> deleteStaleNotifications(DateTime threshold, String ownerDid) {
+    return (delete(notifications)
+          ..where((t) => t.ownerDid.equals(ownerDid))
+          ..where((t) => t.cachedAt.isSmallerThanValue(threshold)))
+        .go();
   }
 
-  /// Marks all notifications as read.
-  Future<void> markAllAsRead() async {
-    await (update(notifications)..where((t) => t.isRead.equals(false))).write(
+  /// Marks all notifications as read locally for a specific user.
+  Future<void> markAllAsRead(String ownerDid) {
+    return (update(notifications)..where((t) => t.ownerDid.equals(ownerDid))).write(
       const NotificationsCompanion(isRead: Value(true)),
     );
   }
 
-  /// Marks notifications as read if they were indexed before the given timestamp.
-  ///
-  /// This is used for batching mark as seen operations - all notifications
-  /// before [seenAt] are marked as read locally.
-  Future<void> markAsSeenBefore(DateTime seenAt) async {
-    await (update(notifications)
-          ..where((t) => t.indexedAt.isSmallerOrEqualValue(seenAt) & t.isRead.equals(false)))
+  /// Marks notifications indexed before the given timestamp as seen (read + seenAt set) for a user.
+  Future<void> markAsSeenBefore(DateTime seenAt, String ownerDid) {
+    return (update(notifications)
+          ..where((t) => t.ownerDid.equals(ownerDid))
+          ..where((t) => t.indexedAt.isSmallerThanValue(seenAt)))
         .write(NotificationsCompanion(isRead: const Value(true), seenAt: Value(seenAt)));
   }
 
-  /// Gets a stream of the unread notification count.
-  ///
-  /// Emits updates whenever notifications are inserted, updated, or deleted.
-  Stream<int> watchUnreadCount() {
-    final query = selectOnly(notifications)..addColumns([notifications.uri.count()]);
-    query.where(notifications.isRead.equals(false));
-    return query.map((row) => row.read(notifications.uri.count()) ?? 0).watchSingle();
+  /// Returns a stream of the unread notification count for a specific user.
+  Stream<int> watchUnreadCount(String ownerDid) {
+    final count = notifications.uri.count();
+    final query = selectOnly(notifications)
+      ..where(notifications.ownerDid.equals(ownerDid))
+      ..where(notifications.isRead.not())
+      ..addColumns([count]);
+
+    return query.map((row) => row.read(count) ?? 0).watchSingle();
   }
 }
 

lib/src/infrastructure/db/daos/notifications_sync_queue_dao.dart

···
     with _$NotificationsSyncQueueDaoMixin {
   NotificationsSyncQueueDao(super.db);
 
-  /// Enqueues a mark-as-seen operation.
+  /// Enqueues a mark-as-seen operation for a specific user.
   ///
   /// The [seenAt] timestamp marks all notifications up to that point as seen.
-  Future<int> enqueueMarkSeen(DateTime seenAt) {
+  Future<int> enqueueMarkSeen(DateTime seenAt, String ownerDid) {
     return into(notificationsSyncQueue).insert(
       NotificationsSyncQueueCompanion.insert(
         type: 'mark_seen',
         seenAt: seenAt.toIso8601String(),
+        ownerDid: ownerDid,
         createdAt: DateTime.now(),
       ),
     );
   }
 
-  /// Gets all retryable items (retryCount < [kMaxNotificationSyncRetries]).
-  ///
-  /// Returns items ordered by creation time (oldest first).
-  Future<List<NotificationsSyncQueueData>> getRetryableItems() {
+  /// Get the latest 'seenAt' timestamp from the queue for a user.
+  Future<DateTime?> getLatestSeenAt(String ownerDid) async {
+    final query = select(notificationsSyncQueue)
+      ..where((t) => t.ownerDid.equals(ownerDid))
+      ..orderBy([(t) => OrderingTerm.desc(t.createdAt)])
+      ..limit(1);
+
+    final item = await query.getSingleOrNull();
+    if (item == null) return null;
+    return DateTime.tryParse(item.seenAt);
+  }
+
+  /// Get items that can be retried for a user.
+  Future<List<NotificationsSyncQueueData>> getRetryableItems(String ownerDid) {
     return (select(notificationsSyncQueue)
-          ..where((t) => t.retryCount.isSmallerThanValue(kMaxNotificationSyncRetries))
+          ..where(
+            (t) =>
+                t.ownerDid.equals(ownerDid) &
+                t.retryCount.isSmallerThanValue(kMaxNotificationSyncRetries),
+          )
           ..orderBy([(t) => OrderingTerm(expression: t.createdAt)]))
         .get();
   }
 
-  /// Gets the latest seenAt timestamp from the queue.
-  ///
-  /// Returns null if queue is empty. This allows batching multiple failed
-  /// operations into a single retry with the most recent timestamp.
-  Future<DateTime?> getLatestSeenAt() async {
-    final items = await getRetryableItems();
-    if (items.isEmpty) {
-      return null;
-    }
-
-    DateTime? latest;
-    for (final item in items) {
-      final timestamp = DateTime.parse(item.seenAt);
-      if (latest == null || timestamp.isAfter(latest)) {
-        latest = timestamp;
-      }
-    }
-    return latest;
-  }
-
   /// Increments the retry count for a specific item.
   Future<int> incrementRetryCount(int id) {
     return (update(notificationsSyncQueue)..where((t) => t.id.equals(id))).write(
···
     return (delete(notificationsSyncQueue)..where((t) => t.id.equals(id))).go();
   }
 
-  /// Deletes all items with seenAt <= the specified timestamp.
+  /// Deletes all items with seenAt <= the specified timestamp for a specific user.
   ///
   /// Used after successfully syncing to remove obsolete queue items.
-  Future<int> deleteItemsUpTo(DateTime seenAt) {
-    return (delete(
-      notificationsSyncQueue,
-    )..where((t) => t.seenAt.isSmallerOrEqualValue(seenAt.toIso8601String()))).go();
+  Future<int> deleteItemsUpTo(DateTime seenAt, String ownerDid) {
+    return (delete(notificationsSyncQueue)..where(
+          (t) =>
+              t.seenAt.isSmallerOrEqualValue(seenAt.toIso8601String()) &
+              t.ownerDid.equals(ownerDid),
+        ))
+        .go();
   }
 
   /// Cleans up old permanently failed items.
···
         .go();
   }
 
-  /// Clears the entire queue.
-  Future<int> clearQueue() {
-    return delete(notificationsSyncQueue).go();
+  /// Clears the entire queue for a specific user.
+  Future<int> clearQueue(String ownerDid) {
+    return (delete(notificationsSyncQueue)..where((t) => t.ownerDid.equals(ownerDid))).go();
   }
 }

lib/src/infrastructure/db/daos/preference_sync_queue_dao.dart

···
     return into(preferenceSyncQueue).insert(item);
   }
 
-  /// Enqueues a feed preference update.
-  Future<int> enqueueFeedSync({required String type, required String feedUri}) {
+  /// Enqueues a feed preference update for a specific user.
+  Future<int> enqueueFeedSync({
+    required String type,
+    required String feedUri,
+    required String ownerDid,
+  }) {
     return enqueue(
       PreferenceSyncQueueCompanion.insert(
         category: const Value('feed'),
         type: type,
         payload: feedUri,
+        ownerDid: ownerDid,
         createdAt: DateTime.now(),
       ),
     );
   }
 
-  /// Enqueues a Bluesky preference update.
+  /// Enqueues a Bluesky preference update for a specific user.
   ///
   /// The [preferenceType] should be one of: 'adultContent', 'contentLabels',
   /// 'labelers', 'feedView', 'threadView', 'mutedWords'.
   Future<int> enqueueBlueskyPrefSync({
     required String preferenceType,
     required String preferenceData,
+    required String ownerDid,
   }) {
     return enqueue(
       PreferenceSyncQueueCompanion.insert(
         category: const Value('bluesky_pref'),
         type: preferenceType,
         payload: preferenceData,
+        ownerDid: ownerDid,
         createdAt: DateTime.now(),
       ),
     );
   }
 
-  /// Gets all pending items in the queue, ordered by creation time.
-  Future<List<PreferenceSyncQueueData>> getPendingItems() {
-    return (select(
-      preferenceSyncQueue,
-    )..orderBy([(t) => OrderingTerm(expression: t.createdAt)])).get();
+  /// Gets all pending items in the queue for a specific user, ordered by creation time.
+  Future<List<PreferenceSyncQueueData>> getPendingItems(String ownerDid) {
+    return (select(preferenceSyncQueue)
+          ..where((t) => t.ownerDid.equals(ownerDid))
+          ..orderBy([(t) => OrderingTerm(expression: t.createdAt)]))
+        .get();
   }
 
-  /// Gets items that can still be retried (retryCount < [kMaxSyncRetries]).
-  Future<List<PreferenceSyncQueueData>> getRetryableItems() {
+  /// Gets items that can still be retried (retryCount < [kMaxSyncRetries]) for a user.
+  Future<List<PreferenceSyncQueueData>> getRetryableItems(String ownerDid) {
     return (select(preferenceSyncQueue)
+          ..where((t) => t.ownerDid.equals(ownerDid))
           ..where((t) => t.retryCount.isSmallerThanValue(kMaxSyncRetries))
           ..orderBy([(t) => OrderingTerm(expression: t.createdAt)]))
         .get();
   }
 
-  /// Gets retryable feed preference items.
-  Future<List<PreferenceSyncQueueData>> getRetryableFeedItems() {
+  /// Gets retryable feed preference items for a user.
+  Future<List<PreferenceSyncQueueData>> getRetryableFeedItems(String ownerDid) {
     return (select(preferenceSyncQueue)
+          ..where((t) => t.ownerDid.equals(ownerDid))
           ..where(
             (t) => t.category.equals('feed') & t.retryCount.isSmallerThanValue(kMaxSyncRetries),
           )
···
         .get();
   }
 
-  /// Gets retryable Bluesky preference items.
-  Future<List<PreferenceSyncQueueData>> getRetryableBlueskyPrefItems() {
+  /// Gets retryable Bluesky preference items for a user.
+  Future<List<PreferenceSyncQueueData>> getRetryableBlueskyPrefItems(String ownerDid) {
     return (select(preferenceSyncQueue)
+          ..where((t) => t.ownerDid.equals(ownerDid))
           ..where(
             (t) =>
                 t.category.equals('bluesky_pref') &
···
         .go();
   }
 
-  /// Watches all pending items in the queue.
-  Stream<List<PreferenceSyncQueueData>> watchPendingItems() {
-    return (select(
-      preferenceSyncQueue,
-    )..orderBy([(t) => OrderingTerm(expression: t.createdAt)])).watch();
+  /// Watches all pending items in the queue for a user.
+  Stream<List<PreferenceSyncQueueData>> watchPendingItems(String ownerDid) {
+    return (select(preferenceSyncQueue)
+          ..where((t) => t.ownerDid.equals(ownerDid))
+          ..orderBy([(t) => OrderingTerm(expression: t.createdAt)]))
+        .watch();
   }
 
   /// Deletes a specific item from the queue.
···
     return (delete(preferenceSyncQueue)..where((t) => t.id.equals(id))).go();
   }
 
-  /// Clears the entire queue.
-  Future<int> clearQueue() {
-    return delete(preferenceSyncQueue).go();
+  /// Clears the entire queue for a user.
+  Future<int> clearQueue(String ownerDid) {
+    return (delete(preferenceSyncQueue)..where((t) => t.ownerDid.equals(ownerDid))).go();
   }
 }

lib/src/infrastructure/db/daos/profile_relationship_dao.dart

···
   }
 
   /// Gets a viewer relationship by profile DID.
-  Future<ProfileRelationship?> getRelationship(String profileDid) {
-    return (select(
-      profileRelationships,
-    )..where((t) => t.profileDid.equals(profileDid))).getSingleOrNull();
+  Future<ProfileRelationship?> getRelationship(String profileDid, String ownerDid) {
+    return (select(profileRelationships)
+          ..where((t) => t.profileDid.equals(profileDid) & t.ownerDid.equals(ownerDid)))
+        .getSingleOrNull();
   }
 
   /// Watches a viewer relationship by profile DID.
-  Stream<ProfileRelationship?> watchRelationship(String profileDid) {
-    return (select(
-      profileRelationships,
-    )..where((t) => t.profileDid.equals(profileDid))).watchSingleOrNull();
+  Stream<ProfileRelationship?> watchRelationship(String profileDid, String ownerDid) {
+    return (select(profileRelationships)
+          ..where((t) => t.profileDid.equals(profileDid) & t.ownerDid.equals(ownerDid)))
+        .watchSingleOrNull();
   }
 
   /// Updates the mute status for a profile.
-  Future<void> updateMuteStatus(String profileDid, bool muted) {
-    return (update(profileRelationships)..where((t) => t.profileDid.equals(profileDid))).write(
+  Future<void> updateMuteStatus(String profileDid, bool muted, String ownerDid) {
+    return (update(
+      profileRelationships,
+    )..where((t) => t.profileDid.equals(profileDid) & t.ownerDid.equals(ownerDid))).write(
       ProfileRelationshipsCompanion(muted: Value(muted), updatedAt: Value(DateTime.now())),
     );
   }
 
   /// Updates the block status for a profile.
-  Future<void> updateBlockStatus(String profileDid, bool blocked, {String? blockingUri}) {
-    return (update(profileRelationships)..where((t) => t.profileDid.equals(profileDid))).write(
+  Future<void> updateBlockStatus(
+    String profileDid,
+    bool blocked,
+    String ownerDid, {
+    String? blockingUri,
+  }) {
+    return (update(
+      profileRelationships,
+    )..where((t) => t.profileDid.equals(profileDid) & t.ownerDid.equals(ownerDid))).write(
       ProfileRelationshipsCompanion(
         blocked: Value(blocked),
         blockingUri: Value(blockingUri),

lib/src/infrastructure/db/daos/saved_feeds_dao.dart

···
   }
 
   /// Deletes a saved feed by URI.
-  Future<int> deleteFeed(String uri) {
-    return (delete(savedFeeds)..where((t) => t.uri.equals(uri))).go();
+  Future<int> deleteFeed(String uri, String ownerDid) {
+    return (delete(savedFeeds)
+          ..where((t) => t.uri.equals(uri))
+          ..where((t) => t.ownerDid.equals(ownerDid)))
+        .go();
   }
 
-  /// Deletes all saved feeds.
+  /// Deletes all saved feeds for a specific owner.
   ///
   /// Used when clearing cache or during user logout.
-  Future<int> deleteAllFeeds() {
-    return delete(savedFeeds).go();
+  Future<int> deleteAllFeeds(String ownerDid) {
+    return (delete(savedFeeds)..where((t) => t.ownerDid.equals(ownerDid))).go();
   }
 
   /// Gets a saved feed by URI.
-  Future<SavedFeed?> getFeed(String uri) {
-    return (select(savedFeeds)..where((t) => t.uri.equals(uri))).getSingleOrNull();
+  Future<SavedFeed?> getFeed(String uri, String ownerDid) {
+    return (select(savedFeeds)
+          ..where((t) => t.uri.equals(uri))
+          ..where((t) => t.ownerDid.equals(ownerDid)))
+        .getSingleOrNull();
   }
 
   /// Watches a saved feed reactively.
-  Stream<SavedFeed?> watchFeed(String uri) {
-    return (select(savedFeeds)..where((t) => t.uri.equals(uri))).watchSingleOrNull();
+  Stream<SavedFeed?> watchFeed(String uri, String ownerDid) {
+    return (select(savedFeeds)
+          ..where((t) => t.uri.equals(uri))
+          ..where((t) => t.ownerDid.equals(ownerDid)))
+        .watchSingleOrNull();
   }
 
   /// Gets all saved feeds ordered by sortOrder.
-  Future<List<SavedFeed>> getAllFeeds() {
-    return (select(savedFeeds)..orderBy([(t) => OrderingTerm(expression: t.sortOrder)])).get();
+  Future<List<SavedFeed>> getAllFeeds(String ownerDid) {
+    return (select(savedFeeds)
+          ..where((t) => t.ownerDid.equals(ownerDid))
+          ..orderBy([(t) => OrderingTerm(expression: t.sortOrder)]))
+        .get();
   }
 
   /// Watches all saved feeds reactively, ordered by sortOrder.
-  Stream<List<SavedFeed>> watchAllFeeds() {
-    return (select(savedFeeds)..orderBy([(t) => OrderingTerm(expression: t.sortOrder)])).watch();
+  Stream<List<SavedFeed>> watchAllFeeds(String ownerDid) {
+    return (select(savedFeeds)
+          ..where((t) => t.ownerDid.equals(ownerDid))
+          ..orderBy([(t) => OrderingTerm(expression: t.sortOrder)]))
+        .watch();
   }
 
   /// Gets all pinned feeds ordered by sortOrder.
-  Future<List<SavedFeed>> getPinnedFeeds() {
+  Future<List<SavedFeed>> getPinnedFeeds(String ownerDid) {
     return (select(savedFeeds)
+          ..where((t) => t.ownerDid.equals(ownerDid))
           ..where((t) => t.isPinned.equals(true))
           ..orderBy([(t) => OrderingTerm(expression: t.sortOrder)]))
         .get();
   }
 
   /// Watches pinned feeds reactively, ordered by sortOrder.
-  Stream<List<SavedFeed>> watchPinnedFeeds() {
+  Stream<List<SavedFeed>> watchPinnedFeeds(String ownerDid) {
     return (select(savedFeeds)
+          ..where((t) => t.ownerDid.equals(ownerDid))
           ..where((t) => t.isPinned.equals(true))
           ..orderBy([(t) => OrderingTerm(expression: t.sortOrder)]))
         .watch();
···
   /// Gets feeds that haven't been synced recently (stale metadata).
   ///
   /// Returns feeds where lastSynced is older than the given threshold.
-  Future<List<SavedFeed>> getStaleFeeds(DateTime threshold) {
-    return (select(savedFeeds)..where((t) => t.lastSynced.isSmallerThanValue(threshold))).get();
+  Future<List<SavedFeed>> getStaleFeeds(DateTime threshold, String ownerDid) {
+    return (select(savedFeeds)
+          ..where((t) => t.ownerDid.equals(ownerDid))
+          ..where((t) => t.lastSynced.isSmallerThanValue(threshold)))
+        .get();
   }
 
   /// Updates the sortOrder for a feed and marks it as locally modified.
-  Future<int> updateSortOrder(String uri, int sortOrder) {
-    return (update(savedFeeds)..where((t) => t.uri.equals(uri))).write(
-      SavedFeedsCompanion(sortOrder: Value(sortOrder), localUpdatedAt: Value(DateTime.now())),
-    );
+  Future<int> updateSortOrder(String uri, int sortOrder, String ownerDid) {
+    return (update(savedFeeds)
+          ..where((t) => t.uri.equals(uri))
+          ..where((t) => t.ownerDid.equals(ownerDid)))
+        .write(
+          SavedFeedsCompanion(sortOrder: Value(sortOrder), localUpdatedAt: Value(DateTime.now())),
+        );
   }
 
   /// Updates the isPinned status for a feed.
-  Future<int> updatePinnedStatus(String uri, bool isPinned) {
-    return (update(savedFeeds)..where((t) => t.uri.equals(uri))).write(
-      SavedFeedsCompanion(isPinned: Value(isPinned), localUpdatedAt: Value(DateTime.now())),
-    );
+  Future<int> updatePinnedStatus(String uri, bool isPinned, String ownerDid) {
+    return (update(savedFeeds)
+          ..where((t) => t.uri.equals(uri))
+          ..where((t) => t.ownerDid.equals(ownerDid)))
+        .write(
+          SavedFeedsCompanion(isPinned: Value(isPinned), localUpdatedAt: Value(DateTime.now())),
+        );
   }
 
   /// Clears the localUpdatedAt timestamp after successful remote sync.
   ///
   /// This marks the feed as "in sync" with the remote state.
-  Future<int> clearLocalModification(String uri) {
-    return (update(savedFeeds)..where((t) => t.uri.equals(uri))).write(
-      const SavedFeedsCompanion(localUpdatedAt: Value(null)),
-    );
+  Future<int> clearLocalModification(String uri, String ownerDid) {
+    return (update(savedFeeds)
+          ..where((t) => t.uri.equals(uri))
+          ..where((t) => t.ownerDid.equals(ownerDid)))
+        .write(const SavedFeedsCompanion(localUpdatedAt: Value(null)));
   }
 
   /// Updates sync-related fields for an existing feed.
···
     required int sortOrder,
     required bool isPinned,
     required DateTime lastSynced,
+    required String ownerDid,
     bool clearLocalModification = false,
   }) {
-    return (update(savedFeeds)..where((t) => t.uri.equals(uri))).write(
-      SavedFeedsCompanion(
-        sortOrder: Value(sortOrder),
-        isPinned: Value(isPinned),
-        lastSynced: Value(lastSynced),
-        localUpdatedAt: clearLocalModification ? const Value(null) : const Value.absent(),
-      ),
-    );
+    return (update(savedFeeds)
+          ..where((t) => t.uri.equals(uri))
+          ..where((t) => t.ownerDid.equals(ownerDid)))
+        .write(
+          SavedFeedsCompanion(
+            sortOrder: Value(sortOrder),
+            isPinned: Value(isPinned),
+            lastSynced: Value(lastSynced),
+            localUpdatedAt: clearLocalModification ? const Value(null) : const Value.absent(),
+          ),
+        );
   }
 
   /// Gets feeds with pending local modifications (localUpdatedAt != null).
-  Future<List<SavedFeed>> getLocallyModifiedFeeds() {
-    return (select(savedFeeds)..where((t) => t.localUpdatedAt.isNotNull())).get();
+  Future<List<SavedFeed>> getLocallyModifiedFeeds(String ownerDid) {
+    return (select(savedFeeds)
+          ..where((t) => t.ownerDid.equals(ownerDid))
+          ..where((t) => t.localUpdatedAt.isNotNull()))
+        .get();
   }
 }

lib/src/infrastructure/db/tables.dart

···
 class FeedContentItems extends Table {
   TextColumn get feedKey => text()();
   TextColumn get postUri => text().references(Posts, #uri)();
+  TextColumn get ownerDid => text()();
   TextColumn get reason => text().nullable()();
   TextColumn get sortKey => text()();
 
   @override
-  Set<Column> get primaryKey => {feedKey, postUri};
+  Set<Column> get primaryKey => {feedKey, postUri, ownerDid};
 }
 
 class Accounts extends Table {
···
 
 class FeedCursors extends Table {
   TextColumn get feedKey => text()();
+  TextColumn get ownerDid => text()();
   TextColumn get cursor => text()();
   DateTimeColumn get lastUpdated => dateTime().nullable()();
 
   @override
-  Set<Column> get primaryKey => {feedKey};
+  Set<Column> get primaryKey => {feedKey, ownerDid};
 }
 
 class RecentSearches extends Table {
···
 
 /// Stores normalized viewer relationships for profiles.
 class ProfileRelationships extends Table {
+  /// The DID of the owner (the user who sees these relationships).
+  TextColumn get ownerDid => text()();
+
   /// The DID of the profile this relationship applies to (subject).
   TextColumn get profileDid => text().references(Profiles, #did)();
 
···
   DateTimeColumn get updatedAt => dateTime()();
 
   @override
-  Set<Column> get primaryKey => {profileDid};
+  Set<Column> get primaryKey => {ownerDid, profileDid};
 }
 
 /// Stores saved feed generators with metadata.
···
   /// Feed generator AT URI (at://did:plc:xxx/app.bsky.feed.generator/yyy).
   TextColumn get uri => text()();
 
+  /// The DID of the user who saved this feed.
+  TextColumn get ownerDid => text()();
+
   /// Display name of the feed.
   TextColumn get displayName => text()();
 
···
   DateTimeColumn get localUpdatedAt => dateTime().nullable()();
 
   @override
-  Set<Column> get primaryKey => {uri};
+  Set<Column> get primaryKey => {uri, ownerDid};
 }
 
 /// Stores queued preference updates for offline synchronization.
···
 /// preferences (content labels, muted words, etc.).
 class PreferenceSyncQueue extends Table {
   IntColumn get id => integer().autoIncrement()();
+
+  /// The DID of the user who owns this action.
+  TextColumn get ownerDid => text()();
 
   /// Category of preference being synced: 'feed' or 'bluesky_pref'.
   TextColumn get category => text().withDefault(const Constant('feed'))();
···
 class NotificationsSyncQueue extends Table {
   IntColumn get id => integer().autoIncrement()();
 
+  /// The DID of the user who owns this action.
+  TextColumn get ownerDid => text()();
+
   /// Type of operation: 'mark_seen'.
   TextColumn get type => text()();
 
···
 class BlueskyPreferences extends Table {
   /// The preference type identifier (e.g., 'contentLabel', 'adultContent').
   TextColumn get type => text()();
+
+  /// The DID of the owner of these preferences.
+  TextColumn get ownerDid => text()();
 
   /// The preference data serialized as JSON.
   TextColumn get data => text()();
···
   DateTimeColumn get lastSynced => dateTime()();
 
   @override
-  Set<Column> get primaryKey => {type};
+  Set<Column> get primaryKey => {type, ownerDid};
 }
 
 /// Stores user-customized themes.
···
   /// Notification AT URI (primary key).
   TextColumn get uri => text()();
 
+  /// The DID of the user receiving the notification.
+  TextColumn get ownerDid => text()();
+
   /// DID of the user who triggered the notification.
   TextColumn get actorDid => text().references(Profiles, #did)();
 
···
   DateTimeColumn get cachedAt => dateTime()();
 
   @override
-  Set<Column> get primaryKey => {uri};
+  Set<Column> get primaryKey => {uri, ownerDid};
 }
 
 /// Stores pagination cursor for notifications feed.
···
   /// Feed key identifier (e.g., 'notifications').
   TextColumn get feedKey => text()();
 
+  /// The DID of the user this cursor belongs to.
+  TextColumn get ownerDid => text()();
+
   /// Pagination cursor from API.
   TextColumn get cursor => text()();
 
···
   DateTimeColumn get lastUpdated => dateTime().nullable()();
 
   @override
-  Set<Column> get primaryKey => {feedKey};
+  Set<Column> get primaryKey => {feedKey, ownerDid};
 }
 
 /// Stores direct message conversations from chat.bsky.convo.listConvos.
···
   /// Conversation ID (unique identifier from API).
   TextColumn get convoId => text()();
 
+  /// The DID of the user who owns this conversation view.
+  TextColumn get ownerDid => text()();
+
   /// JSON array of participant DIDs.
   TextColumn get membersJson => text()();
 
···
   DateTimeColumn get cachedAt => dateTime()();
 
   @override
-  Set<Column> get primaryKey => {convoId};
+  Set<Column> get primaryKey => {convoId, ownerDid};
 }
 
 /// Stores direct messages from chat.bsky.convo.getMessages.
···
   /// Message ID (unique identifier from API).
   TextColumn get messageId => text()();
 
+  /// The DID of the user who owns this message view.
+  TextColumn get ownerDid => text()();
+
   /// Conversation this message belongs to.
   TextColumn get convoId => text()();
 
···
   DateTimeColumn get cachedAt => dateTime()();
 
   @override
-  Set<Column> get primaryKey => {messageId};
+  Set<Column> get primaryKey => {messageId, ownerDid};
 }
 
 /// Stores pending message sends for reliable offline delivery.
···
 class DmOutbox extends Table {
   /// Local UUID for this outbox item.
   TextColumn get outboxId => text()();
+
+  /// The DID of the user who sent this message.
+  TextColumn get ownerDid => text()();
 
   /// Conversation to send the message to.
   TextColumn get convoId => text()();

lib/src/infrastructure/network/providers.dart

···
     onSessionInvalidated: () {
       try {
         final db = ref.read(appDatabaseProvider);
-        db.feedContentDao.clearFeedContent('home');
+        db.feedContentDao.clearFeedContent('home', session.did);
       } catch (e) {
         /* Ignore if database not available */
       }

lib/src/infrastructure/network/providers.g.dart

···
   }
 }
 
-String _$dioPdsHash() => r'd1e9b53f22f3cdf12fa0cafcbc26908b1f10b36d';
+String _$dioPdsHash() => r'58b56b8b3713905fbe532dff9f7e5e80f3c47288';
 
 /// Provides the XRPC client for making API requests.
 ///

lib/src/infrastructure/preferences/bluesky_preferences_repository.dart

···
   final Logger _logger;
 
   /// Syncs all preferences from the remote Bluesky server.
-  ///
-  /// Fetches via app.bsky.actor.getPreferences, parses each preference
-  /// by its $type, and stores in the local database.
-  ///
-  /// For unauthenticated users, this is a no-op.
-  Future<void> syncPreferencesFromRemote() async {
+  Future<void> syncPreferencesFromRemote(String ownerDid) async {
     if (!_api.isAuthenticated) {
       _logger.debug('Skipping preference sync for unauthenticated user');
       return;
     }
 
-    _logger.info('Syncing Bluesky preferences from remote');
+    _logger.info('Syncing Bluesky preferences from remote', {'ownerDid': ownerDid});
 
     try {
       final response = await _api.call('app.bsky.actor.getPreferences');
···
       if (adultContent != null) {
         await _dao.upsertPreference(
           type: 'adultContent',
+          ownerDid: ownerDid,
           data: adultContent.toStoredJson(),
           lastSynced: now,
         );
···
         final prefs = ContentLabelPrefs.fromJsonList(contentLabels);
         await _dao.upsertPreference(
           type: 'contentLabels',
+          ownerDid: ownerDid,
           data: prefs.toStoredJson(),
           lastSynced: now,
         );
···
       if (labelers != null) {
         await _dao.upsertPreference(
           type: 'labelers',
+          ownerDid: ownerDid,
           data: labelers.toStoredJson(),
           lastSynced: now,
         );
···
       if (feedView != null) {
         await _dao.upsertPreference(
           type: 'feedView',
+          ownerDid: ownerDid,
           data: feedView.toStoredJson(),
           lastSynced: now,
         );
···
       if (threadView != null) {
         await _dao.upsertPreference(
           type: 'threadView',
+          ownerDid: ownerDid,
           data: threadView.toStoredJson(),
           lastSynced: now,
         );
···
       if (mutedWords != null) {
         await _dao.upsertPreference(
           type: 'mutedWords',
+          ownerDid: ownerDid,
           data: mutedWords.toStoredJson(),
           lastSynced: now,
         );
···
   }
 
   /// Gets the adult content preference.
-  Future<AdultContentPref> getAdultContentPref() async {
-    final row = await _dao.getPreferenceByType('adultContent');
+  Future<AdultContentPref> getAdultContentPref(String ownerDid) async {
+    final row = await _dao.getPreferenceByType('adultContent', ownerDid);
     if (row == null) return const AdultContentPref(enabled: false);
     try {
       return AdultContentPref.fromStoredJson(row.data);
···
   }
 
   /// Watches the adult content preference for changes.
-  Stream<AdultContentPref> watchAdultContentPref() {
-    return _dao.watchPreferenceByType('adultContent').map((row) {
+  Stream<AdultContentPref> watchAdultContentPref(String ownerDid) {
+    return _dao.watchPreferenceByType('adultContent', ownerDid).map((row) {
       if (row == null) return const AdultContentPref(enabled: false);
       try {
         return AdultContentPref.fromStoredJson(row.data);
···
   }
 
   /// Gets all content label preferences.
-  Future<ContentLabelPrefs> getContentLabelPrefs() async {
-    final row = await _dao.getPreferenceByType('contentLabels');
+  Future<ContentLabelPrefs> getContentLabelPrefs(String ownerDid) async {
+    final row = await _dao.getPreferenceByType('contentLabels', ownerDid);
     if (row == null) return ContentLabelPrefs.empty;
     try {
       return ContentLabelPrefs.fromStoredJson(row.data);
···
   }
 
   /// Watches content label preferences for changes.
-  Stream<ContentLabelPrefs> watchContentLabelPrefs() {
-    return _dao.watchPreferenceByType('contentLabels').map((row) {
+  Stream<ContentLabelPrefs> watchContentLabelPrefs(String ownerDid) {
+    return _dao.watchPreferenceByType('contentLabels', ownerDid).map((row) {
       if (row == null) return ContentLabelPrefs.empty;
       try {
         return ContentLabelPrefs.fromStoredJson(row.data);
···
   }
 
   /// Gets the labelers preference.
-  Future<LabelersPref> getLabelersPref() async {
-    final row = await _dao.getPreferenceByType('labelers');
+  Future<LabelersPref> getLabelersPref(String ownerDid) async {
+    final row = await _dao.getPreferenceByType('labelers', ownerDid);
     if (row == null) return LabelersPref.empty;
     try {
       return LabelersPref.fromStoredJson(row.data);
···
   }
 
   /// Watches the labelers preference for changes.
-  Stream<LabelersPref> watchLabelersPref() {
-    return _dao.watchPreferenceByType('labelers').map((row) {
+  Stream<LabelersPref> watchLabelersPref(String ownerDid) {
+    return _dao.watchPreferenceByType('labelers', ownerDid).map((row) {
       if (row == null) return LabelersPref.empty;
       try {
         return LabelersPref.fromStoredJson(row.data);
···
   }
 
   /// Gets the feed view preference.
-  Future<FeedViewPref> getFeedViewPref() async {
-    final row = await _dao.getPreferenceByType('feedView');
+  Future<FeedViewPref> getFeedViewPref(String ownerDid) async {
+    final row = await _dao.getPreferenceByType('feedView', ownerDid);
     if (row == null) return FeedViewPref.defaultPref;
     try {
       return FeedViewPref.fromStoredJson(row.data);
···
   }
 
   /// Watches the feed view preference for changes.
-  Stream<FeedViewPref> watchFeedViewPref() {
-    return _dao.watchPreferenceByType('feedView').map((row) {
+  Stream<FeedViewPref> watchFeedViewPref(String ownerDid) {
+    return _dao.watchPreferenceByType('feedView', ownerDid).map((row) {
       if (row == null) return FeedViewPref.defaultPref;
       try {
         return FeedViewPref.fromStoredJson(row.data);
···
   }
 
   /// Gets the thread view preference.
-  Future<ThreadViewPref> getThreadViewPref() async {
-    final row = await _dao.getPreferenceByType('threadView');
+  Future<ThreadViewPref> getThreadViewPref(String ownerDid) async {
+    final row = await _dao.getPreferenceByType('threadView', ownerDid);
     if (row == null) return ThreadViewPref.defaultPref;
     try {
       return ThreadViewPref.fromStoredJson(row.data);
···
   }
 
   /// Watches the thread view preference for changes.
-  Stream<ThreadViewPref> watchThreadViewPref() {
-    return _dao.watchPreferenceByType('threadView').map((row) {
+  Stream<ThreadViewPref> watchThreadViewPref(String ownerDid) {
+    return _dao.watchPreferenceByType('threadView', ownerDid).map((row) {
       if (row == null) return ThreadViewPref.defaultPref;
       try {
         return ThreadViewPref.fromStoredJson(row.data);
···
   /// Updates the feed view preference.
   ///
   /// Persists locally and queues for sync to Bluesky.
-  Future<void> updateFeedViewPref(FeedViewPref pref) async {
+  Future<void> updateFeedViewPref(FeedViewPref pref, String ownerDid) async {
     _logger.info('Updating feed view preference');
     final now = DateTime.now();
     final data = pref.toStoredJson();
 
-    await _dao.upsertPreference(type: 'feedView', data: data, lastSynced: now);
+    await _dao.upsertPreference(type: 'feedView', ownerDid: ownerDid, data: data, lastSynced: now);
 
-    await _syncQueueDao.enqueueBlueskyPrefSync(preferenceType: 'feedView', preferenceData: data);
+    await _syncQueueDao.enqueueBlueskyPrefSync(
+      preferenceType: 'feedView',
+      preferenceData: data,
+      ownerDid: ownerDid,
+    );
 
     _logger.debug('Feed view preference updated and queued for sync');
   }
···
   /// Updates the thread view preference.
   ///
   /// Persists locally and queues for sync to Bluesky.
-  Future<void> updateThreadViewPref(ThreadViewPref pref) async {
+  Future<void> updateThreadViewPref(ThreadViewPref pref, String ownerDid) async {
     _logger.info('Updating thread view preference');
     final now = DateTime.now();
     final data = pref.toStoredJson();
 
-    await _dao.upsertPreference(type: 'threadView', data: data, lastSynced: now);
+    await _dao.upsertPreference(
+      type: 'threadView',
+      ownerDid: ownerDid,
+      data: data,
+      lastSynced: now,
+    );
 
-    await _syncQueueDao.enqueueBlueskyPrefSync(preferenceType: 'threadView', preferenceData: data);
+    await _syncQueueDao.enqueueBlueskyPrefSync(
+      preferenceType: 'threadView',
+      preferenceData: data,
+      ownerDid: ownerDid,
+    );
 
     _logger.debug('Thread view preference updated and queued for sync');
   }
···
   /// Updates the adult content preference.
   ///
   /// Persists locally and queues for sync to Bluesky.
-  Future<void> updateAdultContentPref(AdultContentPref pref) async {
+  Future<void> updateAdultContentPref(AdultContentPref pref, String ownerDid) async {
     _logger.info('Updating adult content preference');
     final now = DateTime.now();
     final data = pref.toStoredJson();
 
-    await _dao.upsertPreference(type: 'adultContent', data: data, lastSynced: now);
+    await _dao.upsertPreference(
+      type: 'adultContent',
+      ownerDid: ownerDid,
+      data: data,
+      lastSynced: now,
+    );
 
     await _syncQueueDao.enqueueBlueskyPrefSync(
       preferenceType: 'adultContent',
       preferenceData: data,
+      ownerDid: ownerDid,
     );
 
     _logger.debug('Adult content preference updated and queued for sync');
···
   /// Updates content label preferences.
   ///
   /// Persists locally and queues for sync to Bluesky.
-  Future<void> updateContentLabelPrefs(ContentLabelPrefs prefs) async {
+  Future<void> updateContentLabelPrefs(ContentLabelPrefs prefs, String ownerDid) async {
     _logger.info('Updating content label preferences');
     final now = DateTime.now();
     final data = prefs.toStoredJson();
 
-    await _dao.upsertPreference(type: 'contentLabels', data: data, lastSynced: now);
+    await _dao.upsertPreference(
+      type: 'contentLabels',
+      ownerDid: ownerDid,
+      data: data,
+      lastSynced: now,
+    );
 
     await _syncQueueDao.enqueueBlueskyPrefSync(
       preferenceType: 'contentLabels',
       preferenceData: data,
+      ownerDid: ownerDid,
     );
 
     _logger.debug('Content label preferences updated and queued for sync');
   }
 
   /// Gets the muted words preference.
-  Future<MutedWordsPref> getMutedWordsPref() async {
-    final row = await _dao.getPreferenceByType('mutedWords');
+  Future<MutedWordsPref> getMutedWordsPref(String ownerDid) async {
+    final row = await _dao.getPreferenceByType('mutedWords', ownerDid);
     if (row == null) return MutedWordsPref.empty;
     try {
       return MutedWordsPref.fromStoredJson(row.data);
···
   }
 
   /// Watches the muted words preference for changes.
-  Stream<MutedWordsPref> watchMutedWordsPref() {
-    return _dao.watchPreferenceByType('mutedWords').map((row) {
+  Stream<MutedWordsPref> watchMutedWordsPref(String ownerDid) {
+    return _dao.watchPreferenceByType('mutedWords', ownerDid).map((row) {
       if (row == null) return MutedWordsPref.empty;
       try {
         return MutedWordsPref.fromStoredJson(row.data);
···
   /// Updates the muted words preference.
   ///
   /// Persists locally and queues for sync to Bluesky.
-  Future<void> updateMutedWordsPref(MutedWordsPref pref) async {
+  Future<void> updateMutedWordsPref(MutedWordsPref pref, String ownerDid) async {
     _logger.info('Updating muted words preference');
     final now = DateTime.now();
     final data = pref.toStoredJson();
 
-    await _dao.upsertPreference(type: 'mutedWords', data: data, lastSynced: now);
+    await _dao.upsertPreference(
+      type: 'mutedWords',
+      ownerDid: ownerDid,
+      data: data,
+      lastSynced: now,
+    );
 
-    await _syncQueueDao.enqueueBlueskyPrefSync(preferenceType: 'mutedWords', preferenceData: data);
+    await _syncQueueDao.enqueueBlueskyPrefSync(
+      preferenceType: 'mutedWords',
+      preferenceData: data,
+      ownerDid: ownerDid,
+    );
 
     _logger.debug('Muted words preference updated and queued for sync');
   }
···
   /// Clears all cached preferences.
   ///
   /// Useful when signing out.
-  Future<void> clearAll() async {
+  Future<void> clearAll(String ownerDid) async {
     _logger.info('Clearing all Bluesky preferences');
-    await _dao.clearAll();
+    await _dao.clearAll(ownerDid);
   }
 
   /// Processes the preference sync queue, retrying failed updates.
···
   /// 4. Deletes the queue item on success, or increments retry count on failure
   ///
   /// Also cleans up old permanently failed items (> 30 days).
-  Future<void> processSyncQueue() async {
+  Future<void> processSyncQueue(String ownerDid) async {
     if (!_api.isAuthenticated) return;
 
     final threshold = DateTime.now().subtract(const Duration(days: 30));
     await _syncQueueDao.cleanupOldFailedItems(threshold);
 
-    final retryable = await _syncQueueDao.getRetryableBlueskyPrefItems();
+    final retryable = await _syncQueueDao.getRetryableBlueskyPrefItems(ownerDid);
     if (retryable.isEmpty) {
       return;
     }

test/src/app/app_test.dart

···
     );
     when(() => mockSessionStorage.getSession()).thenAnswer((_) async => testSession);
     when(() => mockSearchRepository.watchRecentSearches()).thenAnswer((_) => Stream.value([]));
-    when(() => mockProfileRepository.getProfile(any())).thenAnswer(
+    when(
+      () => mockProfileRepository.getProfile(any(named: 'actor'), any(named: 'ownerDid')),
+    ).thenAnswer(
       (_) async => ProfileData(
         did: 'did:web:test',
         handle: 'handle',
···
     );
     when(() => mockProfileRepository.watchProfile(any())).thenAnswer((_) => Stream.value(null));
     when(
-      () => mockFeedContentRepository.watchFeedContent(feedKey: any(named: 'feedKey')),
+      () => mockFeedContentRepository.watchFeedContent(
+        ownerDid: any(named: 'ownerDid'),
+        feedKey: any(named: 'feedKey'),
+      ),
     ).thenAnswer((_) => Stream.value([]));
     when(
-      () => mockFeedContentRepository.fetchAndCacheFeed(feedUri: any(named: 'feedUri')),
+      () => mockFeedContentRepository.fetchAndCacheFeed(
+        ownerDid: any(named: 'ownerDid'),
+        feedUri: any(named: 'feedUri'),
+      ),
     ).thenAnswer((_) async {});
     when(
       () => mockFeedContentRepository.fetchAndCacheFeed(
+        ownerDid: any(named: 'ownerDid'),
         cursor: any(named: 'cursor'),
         feedUri: any(named: 'feedUri'),
       ),
     ).thenAnswer((_) async {});
-    when(() => mockFeedContentRepository.getCursor(any())).thenAnswer((_) async => null);
+    when(
+      () => mockFeedContentRepository.getCursor(any(named: 'feedKey'), any(named: 'ownerDid')),
+    ).thenAnswer((_) async => null);
   });
 
   List<Override> getTestOverrides() {

test/src/app/router_test.dart

···
     mockNotificationsRepository = MockNotificationsRepository();
     mockDmsRepository = MockDmsRepository();
     when(
-      () => mockNotificationsRepository.watchNotifications(),
+      () => mockNotificationsRepository.watchNotifications(any(named: 'ownerDid')),
     ).thenAnswer((_) => Stream.value([]));
-    when(() => mockNotificationsRepository.getCursor()).thenAnswer((_) async => null);
     when(
-      () => mockNotificationsRepository.fetchNotifications(cursor: any(named: 'cursor')),
+      () => mockNotificationsRepository.getCursor(any(named: 'ownerDid')),
+    ).thenAnswer((_) async => null);
+    when(
+      () => mockNotificationsRepository.fetchNotifications(
+        cursor: any(named: 'cursor'),
+        ownerDid: any(named: 'ownerDid'),
+      ),
     ).thenAnswer((_) async {});
-    when(() => mockNotificationsRepository.fetchNotifications()).thenAnswer((_) async {});
-    when(() => mockDmsRepository.watchConversations()).thenAnswer((_) => Stream.value([]));
+    when(
+      () => mockNotificationsRepository.fetchNotifications(ownerDid: any(named: 'ownerDid')),
+    ).thenAnswer((_) async {});
+    when(
+      () => mockDmsRepository.watchConversations(any(named: 'ownerDid')),
+    ).thenAnswer((_) => Stream.value([]));
+    when(
+      () => mockDmsRepository.fetchConversations(
+        cursor: any(named: 'cursor'),
+        ownerDid: any(named: 'ownerDid'),
+      ),
+    ).thenAnswer((_) async => null);
     when(
-      () => mockDmsRepository.fetchConversations(cursor: any(named: 'cursor')),
+      () => mockDmsRepository.fetchConversations(ownerDid: any(named: 'ownerDid')),
     ).thenAnswer((_) async => null);
-    when(() => mockDmsRepository.fetchConversations()).thenAnswer((_) async => null);
     testSession = Session(
       did: 'did:web:test',
       handle: 'handle',
···
     );
     when(() => mockSessionStorage.getSession()).thenAnswer((_) async => testSession);
     when(() => mockSearchRepository.watchRecentSearches()).thenAnswer((_) => Stream.value([]));
-    when(() => mockProfileRepository.getProfile(any())).thenAnswer(
+    when(
+      () => mockProfileRepository.getProfile(any(named: 'actor'), any(named: 'ownerDid')),
+    ).thenAnswer(
       (_) async => ProfileData(
         did: 'did:web:test',
         handle: 'handle',
···
     );
 
     when(
-      () => mockFeedContentRepository.watchFeedContent(feedKey: any(named: 'feedKey')),
+      () => mockFeedContentRepository.watchFeedContent(
+        feedKey: any(named: 'feedKey'),
+        ownerDid: any(named: 'ownerDid'),
+      ),
     ).thenAnswer((_) => Stream.value([]));
     when(
-      () => mockFeedContentRepository.fetchAndCacheFeed(feedUri: any(named: 'feedUri')),
+      () => mockFeedContentRepository.fetchAndCacheFeed(
+        feedUri: any(named: 'feedUri'),
+        ownerDid: any(named: 'ownerDid'),
+      ),
     ).thenAnswer((_) async {});
     when(
       () => mockFeedContentRepository.fetchAndCacheFeed(
         cursor: any(named: 'cursor'),
         feedUri: any(named: 'feedUri'),
+        ownerDid: any(named: 'ownerDid'),
       ),
     ).thenAnswer((_) async {});
-    when(() => mockFeedContentRepository.getCursor(any())).thenAnswer((_) async => null);
+    when(
+      () => mockFeedContentRepository.getCursor(any(named: 'feedKey'), any(named: 'ownerDid')),
+    ).thenAnswer((_) async => null);
   });
 
   List<Override> getTestOverrides() {

test/src/features/dms/infrastructure/dms_repository_test.dart

···
   late MockDmMessagesDao mockMessagesDao;
   late MockLogger mockLogger;
   late DmsRepository repository;
+  const ownerDid = 'did:web:tester';
 
   setUp(() {
     mockApi = MockXrpcClient();
···
           ),
         ).thenAnswer((_) async {});
 
-        await repository.fetchConversations();
+        await repository.fetchConversations(ownerDid: ownerDid);
 
         verify(
           () => mockApi.call(
···
           ),
         ).thenAnswer((_) async {});
 
-        await repository.fetchConversations(cursor: 'test_cursor');
+        await repository.fetchConversations(ownerDid: ownerDid, cursor: 'test_cursor');
 
         verify(
           () => mockApi.call(
···
           capturedProfiles = invocation.namedArguments[#newProfiles] as List;
         });
 
-        final cursor = await repository.fetchConversations();
+        final cursor = await repository.fetchConversations(ownerDid: ownerDid);
 
         expect(cursor, 'next_cursor');
         expect(capturedConvos, hasLength(1));
···
           capturedConvos = invocation.namedArguments[#newConvos] as List;
         });
 
-        await repository.fetchConversations();
+        await repository.fetchConversations(ownerDid: ownerDid);
 
         expect(capturedConvos, isEmpty);
       });
···
           () => mockApi.call(any(), params: any(named: 'params')),
         ).thenThrow(Exception('Network error'));
 
-        expect(() => repository.fetchConversations(), throwsException);
+        expect(() => repository.fetchConversations(ownerDid: ownerDid), throwsException);
 
         verify(() => mockLogger.error(any(), any(), any())).called(1);
       });
···
           ),
         ).thenAnswer((_) async {});
 
-        await repository.fetchMessages('convo1');
+        await repository.fetchMessages('convo1', ownerDid: ownerDid);
 
         verify(
           () => mockApi.call(
···
           capturedMessages = invocation.namedArguments[#newMessages] as List;
         });
 
-        final cursor = await repository.fetchMessages('convo1');
+        final cursor = await repository.fetchMessages('convo1', ownerDid: ownerDid);
 
         expect(cursor, 'next_cursor');
         expect(capturedMessages, hasLength(1));
···
     group('acceptConversation', () {
       test('calls acceptConvo API and updates DAO', () async {
         when(() => mockApi.call(any(), body: any(named: 'body'))).thenAnswer((_) async => {});
-        when(() => mockConvosDao.acceptConvo(any())).thenAnswer((_) async {});
+        when(() => mockConvosDao.acceptConvo(any(), any())).thenAnswer((_) async {});
 
-        await repository.acceptConversation('convo1');
+        await repository.acceptConversation('convo1', ownerDid);
 
         verify(
           () => mockApi.call('chat.bsky.convo.acceptConvo', body: {'convoId': 'convo1'}),
         ).called(1);
-        verify(() => mockConvosDao.acceptConvo('convo1')).called(1);
+        verify(() => mockConvosDao.acceptConvo('convo1', ownerDid)).called(1);
       });
     });
 
···
         when(() => mockApi.call(any(), body: any(named: 'body'))).thenAnswer((_) async => {});
         when(
           () => mockConvosDao.updateReadState(
+            ownerDid: any(named: 'ownerDid'),
             convoId: any(named: 'convoId'),
             lastReadMessageId: any(named: 'lastReadMessageId'),
             unreadCount: any(named: 'unreadCount'),
           ),
         ).thenAnswer((_) async {});
 
-        await repository.updateReadState('convo1', 'msg123');
+        await repository.updateReadState(
+          convoId: 'convo1',
+          messageId: 'msg123',
+          ownerDid: ownerDid,
+        );
 
         verify(
           () => mockApi.call(
···
         ).called(1);
         verify(
           () => mockConvosDao.updateReadState(
+            ownerDid: ownerDid,
             convoId: 'convo1',
             lastReadMessageId: 'msg123',
             unreadCount: 0,
···
 
     group('watchConversations', () {
       test('returns stream from DAO mapped to domain models', () async {
-        when(() => mockConvosDao.watchConversations()).thenAnswer((_) => Stream.value([]));
+        when(() => mockConvosDao.watchConversations(any())).thenAnswer((_) => Stream.value([]));
 
-        final stream = repository.watchConversations();
+        final stream = repository.watchConversations(ownerDid);
         final result = await stream.first;
 
         expect(result, isEmpty);
-        verify(() => mockConvosDao.watchConversations()).called(1);
+        verify(() => mockConvosDao.watchConversations(ownerDid)).called(1);
       });
     });
 
     group('watchMessages', () {
       test('returns stream from DAO mapped to domain models', () async {
         when(
-          () => mockMessagesDao.watchMessagesByConvo(any()),
+          () => mockMessagesDao.watchMessagesByConvo(any(), any()),
         ).thenAnswer((_) => Stream.value([]));
 
-        final stream = repository.watchMessages('convo1');
+        final stream = repository.watchMessages('convo1', ownerDid);
         final result = await stream.first;
 
         expect(result, isEmpty);
-        verify(() => mockMessagesDao.watchMessagesByConvo('convo1')).called(1);
+        verify(() => mockMessagesDao.watchMessagesByConvo('convo1', ownerDid)).called(1);
       });
     });
 
     group('clearAll', () {
       test('clears messages and conversations', () async {
-        when(() => mockMessagesDao.clearMessages()).thenAnswer((_) async {});
-        when(() => mockConvosDao.clearConversations()).thenAnswer((_) async {});
+        when(() => mockMessagesDao.clearMessages(any())).thenAnswer((_) async {
+          return 0;
+        });
+        when(() => mockConvosDao.clearConversations(any())).thenAnswer((_) async {});
 
-        await repository.clearAll();
+        await repository.clearAll(ownerDid);
 
-        verify(() => mockMessagesDao.clearMessages()).called(1);
-        verify(() => mockConvosDao.clearConversations()).called(1);
+        verify(() => mockMessagesDao.clearMessages(ownerDid)).called(1);
+        verify(() => mockConvosDao.clearConversations(ownerDid)).called(1);
       });
     });
   });

test/src/features/dms/infrastructure/outbox_repository_test.dart

···
         when(() => mockOutboxDao.enqueue(any())).thenAnswer((_) async {});
         when(() => mockMessagesDao.insertLocalMessage(any())).thenAnswer((_) async {});
 
-        final outboxId = await repository.enqueueSend('convo1', 'Hello!');
+        final outboxId = await repository.enqueueSend('convo1', 'Hello!', 'did:plc:owner');
 
         expect(outboxId, isNotEmpty);
         verify(() => mockOutboxDao.enqueue(any())).called(1);
···
 
     group('processOutbox', () {
       test('does nothing when queue is empty', () async {
-        when(() => mockOutboxDao.getPending()).thenAnswer((_) async => []);
+        when(() => mockOutboxDao.getPending(any(named: 'ownerDid'))).thenAnswer((_) async => []);
 
-        await repository.processOutbox();
+        await repository.processOutbox('did:plc:owner');
 
         verifyNever(() => mockApi.call(any(), body: any(named: 'body')));
       });
···
           createdAt: now,
           lastAttemptAt: null,
           errorMessage: null,
+          ownerDid: 'did:plc:owner',
         );
 
-        when(() => mockOutboxDao.getPending()).thenAnswer((_) async => [pendingItem]);
+        when(
+          () => mockOutboxDao.getPending(any(named: 'ownerDid')),
+        ).thenAnswer((_) async => [pendingItem]);
         when(
           () => mockOutboxDao.updateStatus(
             outboxId: any(named: 'outboxId'),
···
           () => mockMessagesDao.updateMessageStatus(
             messageId: any(named: 'messageId'),
             status: any(named: 'status'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((_) async {});
         when(
···
         ).thenAnswer((_) async => {'id': 'server_msg_id'});
         when(() => mockOutboxDao.deleteItem(any())).thenAnswer((_) async => 1);
 
-        await repository.processOutbox();
+        await repository.processOutbox('did:plc:owner');
 
         verify(
           () => mockApi.call('chat.bsky.convo.sendMessage', body: any(named: 'body')),
···
           createdAt: now,
           lastAttemptAt: null,
           errorMessage: null,
+          ownerDid: 'did:plc:owner',
         );
 
-        when(() => mockOutboxDao.getPending()).thenAnswer((_) async => [pendingItem]);
+        when(
+          () => mockOutboxDao.getPending(any(named: 'ownerDid')),
+        ).thenAnswer((_) async => [pendingItem]);
         when(
           () => mockOutboxDao.updateStatus(
             outboxId: any(named: 'outboxId'),
···
           () => mockMessagesDao.updateMessageStatus(
             messageId: any(named: 'messageId'),
             status: any(named: 'status'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((_) async {});
         when(
···
             createdAt: now,
             lastAttemptAt: now,
             errorMessage: 'Error',
+            ownerDid: 'did:plc:owner',
           ),
         );
 
-        await repository.processOutbox();
+        await repository.processOutbox('did:plc:owner');
 
         verify(() => mockOutboxDao.incrementRetryCount('outbox1')).called(1);
         verifyNever(() => mockOutboxDao.deleteItem(any()));
···
           createdAt: now,
           lastAttemptAt: null,
           errorMessage: null,
+          ownerDid: 'did:plc:owner',
         );
 
-        when(() => mockOutboxDao.getPending()).thenAnswer((_) async => [pendingItem]);
+        when(
+          () => mockOutboxDao.getPending(any(named: 'ownerDid')),
+        ).thenAnswer((_) async => [pendingItem]);
         when(
           () => mockOutboxDao.updateStatus(
             outboxId: any(named: 'outboxId'),
···
           () => mockMessagesDao.updateMessageStatus(
             messageId: any(named: 'messageId'),
             status: any(named: 'status'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((_) async {});
         when(
···
             createdAt: now,
             lastAttemptAt: now,
             errorMessage: 'Error',
+            ownerDid: 'did:plc:owner',
           ),
         );
 
-        await repository.processOutbox();
+        await repository.processOutbox('did:plc:owner');
 
         verify(
           () => mockOutboxDao.updateStatus(
···
             createdAt: now.subtract(const Duration(minutes: 2)),
             lastAttemptAt: null,
             errorMessage: null,
+            ownerDid: 'did:plc:owner',
           ),
           DmOutboxData(
             outboxId: 'outbox2',
···
             createdAt: now.subtract(const Duration(minutes: 1)),
             lastAttemptAt: null,
             errorMessage: null,
+            ownerDid: 'did:plc:owner',
           ),
           DmOutboxData(
             outboxId: 'outbox3',
···
             createdAt: now,
             lastAttemptAt: null,
             errorMessage: null,
+            ownerDid: 'did:plc:owner',
           ),
         ];
 
-        when(() => mockOutboxDao.getPending()).thenAnswer((_) async => items);
+        when(
+          () => mockOutboxDao.getPending(any(named: 'ownerDid')),
+        ).thenAnswer((_) async => items);
         when(
           () => mockOutboxDao.updateStatus(
             outboxId: any(named: 'outboxId'),
···
           () => mockMessagesDao.updateMessageStatus(
             messageId: any(named: 'messageId'),
             status: any(named: 'status'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((_) async {});
         when(
···
         ).thenAnswer((_) async => {'id': 'server_msg_id'});
         when(() => mockOutboxDao.deleteItem(any())).thenAnswer((_) async => 1);
 
-        await repository.processOutbox();
+        await repository.processOutbox('did:plc:owner');
 
         verify(
           () => mockApi.call('chat.bsky.convo.sendMessage', body: any(named: 'body')),
···
           createdAt: now,
           lastAttemptAt: null,
           errorMessage: null,
+          ownerDid: 'did:plc:owner',
         );
 
         when(() => mockOutboxDao.resetForRetry(any())).thenAnswer((_) async {});
···
           () => mockMessagesDao.updateMessageStatus(
             messageId: any(named: 'messageId'),
             status: any(named: 'status'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((_) async {});
         when(() => mockOutboxDao.getById(any())).thenAnswer((_) async => item);
···
         ).thenAnswer((_) async => {'id': 'server_msg_id'});
         when(() => mockOutboxDao.deleteItem(any())).thenAnswer((_) async => 1);
 
-        await repository.retryMessage('outbox1');
+        await repository.retryMessage('outbox1', 'did:plc:owner');
 
         verify(() => mockOutboxDao.resetForRetry('outbox1')).called(1);
         verify(
···
     group('deleteOutboxItem', () {
       test('removes item from outbox and deletes local message', () async {
         when(() => mockOutboxDao.deleteItem(any())).thenAnswer((_) async => 1);
-        when(() => mockMessagesDao.deleteMessage(any())).thenAnswer((_) async => 1);
+        when(
+          () => mockMessagesDao.deleteMessage(any(), any(named: 'ownerDid')),
+        ).thenAnswer((_) async => 1);
 
-        await repository.deleteOutboxItem('outbox1');
+        await repository.deleteOutboxItem('outbox1', 'did:plc:owner');
 
         verify(() => mockOutboxDao.deleteItem('outbox1')).called(1);
-        verify(() => mockMessagesDao.deleteMessage('pending:outbox1')).called(1);
+        verify(() => mockMessagesDao.deleteMessage('pending:outbox1', 'did:plc:owner')).called(1);
       });
     });
 
     group('getPendingCount', () {
       test('returns count from DAO', () async {
-        when(() => mockOutboxDao.countPending()).thenAnswer((_) async => 5);
+        when(() => mockOutboxDao.countPending(any(named: 'ownerDid'))).thenAnswer((_) async => 5);
 
-        final count = await repository.getPendingCount();
+        final count = await repository.getPendingCount('did:plc:owner');
 
         expect(count, 5);
-        verify(() => mockOutboxDao.countPending()).called(1);
+        verify(() => mockOutboxDao.countPending('did:plc:owner')).called(1);
       });
     });
   });

test/src/features/dms/presentation/conversation_list_notifier_test.dart

···
     });
 
     test('build watches conversations', () async {
-      when(() => mockRepository.watchConversations()).thenAnswer((_) => Stream.value([]));
+      when(
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
+      ).thenAnswer((_) => Stream.value([]));
 
       final subscription = container.listen(conversationListProvider, (previous, next) {});
 
···
       await container.read(conversationListProvider.future);
 
       expect(container.read(conversationListProvider).value, isEmpty);
-      verify(() => mockRepository.watchConversations()).called(1);
+      verify(() => mockRepository.watchConversations(any(named: 'ownerDid'))).called(1);
 
       subscription.close();
     });
 
     test('refresh fetches conversations', () async {
-      when(() => mockRepository.watchConversations()).thenAnswer((_) => Stream.value([]));
-      when(() => mockRepository.fetchConversations()).thenAnswer((_) async => 'cursor-1');
+      when(
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
+      ).thenAnswer((_) => Stream.value([]));
+      when(
+        () => mockRepository.fetchConversations(ownerDid: any(named: 'ownerDid')),
+      ).thenAnswer((_) async => 'cursor-1');
 
       final notifier = container.read(conversationListProvider.notifier);
       await notifier.refresh();
 
-      verify(() => mockRepository.fetchConversations()).called(1);
+      verify(() => mockRepository.fetchConversations(ownerDid: any(named: 'ownerDid'))).called(1);
     });
 
     test('loadMore fetches conversations with cursor', () async {
-      when(() => mockRepository.watchConversations()).thenAnswer((_) => Stream.value([]));
-      when(() => mockRepository.fetchConversations()).thenAnswer((_) async => 'cursor-1');
+      when(
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
+      ).thenAnswer((_) => Stream.value([]));
       when(
-        () => mockRepository.fetchConversations(cursor: 'cursor-1'),
+        () => mockRepository.fetchConversations(ownerDid: any(named: 'ownerDid')),
+      ).thenAnswer((_) async => 'cursor-1');
+      when(
+        () => mockRepository.fetchConversations(
+          ownerDid: any(named: 'ownerDid'),
+          cursor: 'cursor-1',
+        ),
       ).thenAnswer((_) async => 'cursor-2');
 
       final notifier = container.read(conversationListProvider.notifier);
···
 
       await notifier.loadMore();
 
-      verify(() => mockRepository.fetchConversations(cursor: 'cursor-1')).called(1);
+      verify(
+        () => mockRepository.fetchConversations(
+          cursor: 'cursor-1',
+          ownerDid: any(named: 'ownerDid'),
+        ),
+      ).called(1);
     });
 
     test('acceptConversation calls repository', () async {
-      when(() => mockRepository.watchConversations()).thenAnswer((_) => Stream.value([]));
-      when(() => mockRepository.acceptConversation(any())).thenAnswer((_) async {});
+      when(
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
+      ).thenAnswer((_) => Stream.value([]));
+      when(
+        () => mockRepository.acceptConversation(any(named: 'convoId'), any(named: 'ownerDid')),
+      ).thenAnswer((_) async {});
 
       final notifier = container.read(conversationListProvider.notifier);
       await notifier.acceptConversation('123');
 
-      verify(() => mockRepository.acceptConversation('123')).called(1);
+      verify(() => mockRepository.acceptConversation('123', any(named: 'ownerDid'))).called(1);
     });
   });
 }

test/src/features/dms/presentation/conversation_list_screen_test.dart

···
     setUp(() {
       mockRepository = MockDmsRepository();
       when(
-        () => mockRepository.fetchConversations(cursor: any(named: 'cursor')),
+        () => mockRepository.fetchConversations(
+          cursor: any(named: 'cursor'),
+          ownerDid: any(named: 'ownerDid'),
+        ),
       ).thenAnswer((_) async => null);
-      when(() => mockRepository.muteConversation(any())).thenAnswer((_) async {});
-      when(() => mockRepository.unmuteConversation(any())).thenAnswer((_) async {});
-      when(() => mockRepository.leaveConversation(any())).thenAnswer((_) async {});
       when(
-        () => mockRepository.fetchMessages(any(), limit: any(named: 'limit')),
+        () => mockRepository.muteConversation(any(), any(named: 'ownerDid')),
+      ).thenAnswer((_) async {});
+      when(
+        () => mockRepository.unmuteConversation(any(), any(named: 'ownerDid')),
+      ).thenAnswer((_) async {});
+      when(
+        () => mockRepository.leaveConversation(any(), any(named: 'ownerDid')),
+      ).thenAnswer((_) async {});
+      when(
+        () => mockRepository.fetchMessages(
+          any(),
+          limit: any(named: 'limit'),
+          ownerDid: any(named: 'ownerDid'),
+        ),
       ).thenAnswer((_) async => null);
-      when(() => mockRepository.watchMessages(any())).thenAnswer((_) => Stream.value([]));
-      when(() => mockRepository.updateReadState(any(), any())).thenAnswer((_) async {});
+      when(
+        () => mockRepository.watchMessages(any(), any(named: 'ownerDid')),
+      ).thenAnswer((_) => Stream.value([]));
+      when(
+        () => mockRepository.updateReadState(convoId: any(), messageId: any(), ownerDid: any()),
+      ).thenAnswer((_) async {});
     });
 
     const profile = Profile(
···
       final controller = StreamController<List<DmConversation>>();
       addTearDown(controller.close);
 
-      when(() => mockRepository.watchConversations()).thenAnswer((_) => controller.stream);
+      when(
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
+      ).thenAnswer((_) => controller.stream);
 
       await tester.pumpApp(
         const ConversationListScreen(),
···
     });
 
     testWidgets('renders empty state when no conversations', (tester) async {
-      when(() => mockRepository.watchConversations()).thenAnswer((_) => Stream.value([]));
-      when(() => mockRepository.fetchConversations()).thenAnswer((_) async => null);
+      when(
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
+      ).thenAnswer((_) => Stream.value([]));
+      when(
+        () => mockRepository.fetchConversations(ownerDid: any(named: 'ownerDid')),
+      ).thenAnswer((_) async => null);
 
       await tester.pumpApp(
         const ConversationListScreen(),
···
 
     testWidgets('renders conversation list', (tester) async {
       when(
-        () => mockRepository.watchConversations(),
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
       ).thenAnswer((_) => Stream.value([conversation]));
 
       await tester.pumpApp(
···
     testWidgets('renders message requests section', (tester) async {
       final requestConvo = conversation.copyWith(isAccepted: false, convoId: '456');
       when(
-        () => mockRepository.watchConversations(),
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
       ).thenAnswer((_) => Stream.value([requestConvo, conversation]));
 
       await tester.pumpApp(
···
 
     testWidgets('triggers refresh on pull to refresh', (tester) async {
       when(
-        () => mockRepository.watchConversations(),
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
       ).thenAnswer((_) => Stream.value([conversation]));
-      when(() => mockRepository.fetchConversations()).thenAnswer((_) async => 'new-cursor');
+      when(
+        () => mockRepository.fetchConversations(ownerDid: any(named: 'ownerDid')),
+      ).thenAnswer((_) async => 'new-cursor');
 
       await tester.pumpApp(
         const ConversationListScreen(),
···
       await tester.drag(find.byType(CustomScrollView), const Offset(0, 300));
       await tester.pumpAndSettle();
 
-      verify(() => mockRepository.fetchConversations()).called(1);
+      verify(() => mockRepository.fetchConversations(ownerDid: any(named: 'ownerDid'))).called(1);
     });
 
     testWidgets('shows FAB', (tester) async {
       when(
-        () => mockRepository.watchConversations(),
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
       ).thenAnswer((_) => Stream.value([conversation]));
 
       await tester.pumpApp(
···
 
     testWidgets('triggers mark as read on swipe right', (tester) async {
       when(
-        () => mockRepository.watchConversations(),
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
       ).thenAnswer((_) => Stream.value([conversation]));
 
       final message = dmm.AppDmMessage(
···
         status: dmm.MessageStatus.sent,
       );
 
-      when(() => mockRepository.watchMessages('123')).thenAnswer((_) => Stream.value([message]));
+      when(
+        () => mockRepository.watchMessages('123', any(named: 'ownerDid')),
+      ).thenAnswer((_) => Stream.value([message]));
 
       await tester.pumpApp(
         const ConversationListScreen(),
···
       );
       await tester.pumpAndSettle();
 
-      // Swipe right (Start to End)
       await tester.drag(find.byType(ConversationListItem), const Offset(500, 0));
       await tester.pumpAndSettle();
 
-      verify(() => mockRepository.fetchMessages('123', limit: 1)).called(1);
-      verify(() => mockRepository.updateReadState('123', 'msg1')).called(1);
+      verify(
+        () => mockRepository.fetchMessages('123', ownerDid: any(named: 'ownerDid'), limit: 1),
+      ).called(1);
+      verify(
+        () => mockRepository.updateReadState(
+          convoId: '123',
+          messageId: 'msg1',
+          ownerDid: any(named: 'ownerDid'),
+        ),
+      ).called(1);
     });
 
     testWidgets('triggers leave conversation on swipe left and confirm', (tester) async {
       when(
-        () => mockRepository.watchConversations(),
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
       ).thenAnswer((_) => Stream.value([conversation]));
 
       await tester.pumpApp(
···
       );
       await tester.pumpAndSettle();
 
-      // Swipe left (End to Start) - confirmDismiss logic makes this tricky with tester.drag
-      // unless we assume direction is correct.
-      // Offset -500 is left.
       await tester.drag(find.byType(ConversationListItem), const Offset(-500, 0));
       await tester.pumpAndSettle();
 
···
       await tester.tap(find.text('Leave'));
       await tester.pumpAndSettle();
 
-      verify(() => mockRepository.leaveConversation('123')).called(1);
+      verify(() => mockRepository.leaveConversation('123', any(named: 'ownerDid'))).called(1);
     });
 
     testWidgets('triggers mute/unmute on long press', (tester) async {
       when(
-        () => mockRepository.watchConversations(),
+        () => mockRepository.watchConversations(any(named: 'ownerDid')),
       ).thenAnswer((_) => Stream.value([conversation]));
 
       await tester.pumpApp(
···
       await tester.tap(find.text('Mute'));
       await tester.pumpAndSettle();
 
-      verify(() => mockRepository.muteConversation('123')).called(1);
+      verify(() => mockRepository.muteConversation('123', any(named: 'ownerDid'))).called(1);
     });
   });
 }

test/src/features/feeds/application/feed_content_notifier_test.dart

···
 
     registerFallbackValue('');
     when(
-      () => mockRepository.watchFeedContent(feedKey: any(named: 'feedKey')),
+      () => mockRepository.watchFeedContent(
+        feedKey: any(named: 'feedKey'),
+        ownerDid: any(named: 'ownerDid'),
+      ),
     ).thenAnswer((_) => Stream.value([]));
     when(
       () => mockRepository.fetchAndCacheFeed(
         cursor: any(named: 'cursor'),
         feedUri: any(named: 'feedUri'),
+        ownerDid: any(named: 'ownerDid'),
       ),
     ).thenAnswer((_) async {});
-    when(() => mockRepository.getCursor(any())).thenAnswer((_) async => null);
-    when(() => mockRepository.clearFeedContent(any())).thenAnswer((_) async {});
+    when(() => mockRepository.getCursor(any(), any())).thenAnswer((_) async => null);
+    when(() => mockRepository.clearFeedContent(any(), any())).thenAnswer((_) async {});
   });
 
   group('FeedContentNotifier', () {
···
       await Future.delayed(Duration.zero);
 
       verify(
-        () => mockRepository.watchFeedContent(feedKey: FeedContentRepository.kInternalHomeFeedKey),
+        () => mockRepository.watchFeedContent(
+          feedKey: FeedContentRepository.kInternalHomeFeedKey,
+          ownerDid: any(named: 'ownerDid'),
+        ),
       ).called(1);
     });
 
···
       const feedUri = 'at://did:example:123/app.bsky.feed.generator/custom';
 
       when(
-        () => mockRepository.watchFeedContent(feedKey: feedUri),
+        () => mockRepository.watchFeedContent(
+          feedKey: feedUri,
+          ownerDid: any(named: 'ownerDid'),
+        ),
       ).thenAnswer((_) => Stream.value([]));
 
       container.read(feedContentProvider(feedUri));
 
       await Future.delayed(Duration.zero);
 
-      verify(() => mockRepository.watchFeedContent(feedKey: feedUri)).called(1);
+      verify(
+        () => mockRepository.watchFeedContent(
+          feedKey: feedUri,
+          ownerDid: any(named: 'ownerDid'),
+        ),
+      ).called(1);
     });
 
     test('build maps following feed to internal home key', () async {
···
       await Future.delayed(Duration.zero);
 
       verify(
-        () => mockRepository.watchFeedContent(feedKey: FeedContentRepository.kInternalHomeFeedKey),
+        () => mockRepository.watchFeedContent(
+          feedKey: FeedContentRepository.kInternalHomeFeedKey,
+          ownerDid: any(named: 'ownerDid'),
+        ),
       ).called(1);
     });
 
···
       final container = createContainer();
       addTearDown(container.dispose);
       const feedUri = FeedRepository.kHomeFeedUri;
-      when(() => mockRepository.fetchAndCacheFeed(feedUri: null)).thenAnswer((_) async {});
+      when(
+        () => mockRepository.fetchAndCacheFeed(feedUri: null, ownerDid: any(named: 'ownerDid')),
+      ).thenAnswer((_) async {});
 
       await container.read(feedContentProvider(feedUri).notifier).refresh();
 
-      verify(() => mockRepository.fetchAndCacheFeed(feedUri: null)).called(1);
+      verify(
+        () => mockRepository.fetchAndCacheFeed(feedUri: null, ownerDid: any(named: 'ownerDid')),
+      ).called(1);
     });
 
     test('refresh calls fetchAndCacheFeed with correct key for custom feed', () async {
···
       const feedUri = 'at://did:example:123/app.bsky.feed.generator/custom';
 
       when(
-        () => mockRepository.watchFeedContent(feedKey: feedUri),
+        () => mockRepository.watchFeedContent(
+          feedKey: feedUri,
+          ownerDid: any(named: 'ownerDid'),
+        ),
       ).thenAnswer((_) => Stream.value([]));
-      when(() => mockRepository.fetchAndCacheFeed(feedUri: feedUri)).thenAnswer((_) async {});
+      when(
+        () => mockRepository.fetchAndCacheFeed(
+          feedUri: feedUri,
+          ownerDid: any(named: 'ownerDid'),
+        ),
+      ).thenAnswer((_) async {});
 
       await container.read(feedContentProvider(feedUri).notifier).refresh();
 
-      verify(() => mockRepository.fetchAndCacheFeed(feedUri: feedUri)).called(1);
+      verify(
+        () => mockRepository.fetchAndCacheFeed(
+          feedUri: feedUri,
+          ownerDid: any(named: 'ownerDid'),
+        ),
+      ).called(1);
     });
 
     test('loadMore fetches next page using cursor', () async {
···
       const feedUri = FeedRepository.kHomeFeedUri;
 
       when(
-        () => mockRepository.getCursor(FeedContentRepository.kInternalHomeFeedKey),
+        () => mockRepository.getCursor(FeedContentRepository.kInternalHomeFeedKey, any()),
       ).thenAnswer((_) async => 'next_cursor');
       when(
-        () => mockRepository.fetchAndCacheFeed(cursor: 'next_cursor', feedUri: null),
+        () => mockRepository.fetchAndCacheFeed(
+          cursor: 'next_cursor',
+          feedUri: null,
+          ownerDid: any(named: 'ownerDid'),
+        ),
       ).thenAnswer((_) async {});
 
       await container.read(feedContentProvider(feedUri).notifier).loadMore();
 
-      verify(() => mockRepository.getCursor(FeedContentRepository.kInternalHomeFeedKey)).called(1);
+      verify(
+        () => mockRepository.getCursor(FeedContentRepository.kInternalHomeFeedKey, any()),
+      ).called(1);
       verify(
-        () => mockRepository.fetchAndCacheFeed(cursor: 'next_cursor', feedUri: null),
+        () => mockRepository.fetchAndCacheFeed(
+          cursor: 'next_cursor',
+          feedUri: null,
+          ownerDid: any(named: 'ownerDid'),
+        ),
       ).called(1);
     });
 
···
       const feedUri = FeedRepository.kHomeFeedUri;
 
       when(
-        () => mockRepository.getCursor(FeedContentRepository.kInternalHomeFeedKey),
+        () => mockRepository.getCursor(FeedContentRepository.kInternalHomeFeedKey, any()),
       ).thenAnswer((_) async => null);
 
       await container.read(feedContentProvider(feedUri).notifier).loadMore();
 
-      verify(() => mockRepository.getCursor(FeedContentRepository.kInternalHomeFeedKey)).called(1);
+      verify(
+        () => mockRepository.getCursor(FeedContentRepository.kInternalHomeFeedKey, any()),
+      ).called(1);
       verifyNever(
         () => mockRepository.fetchAndCacheFeed(
           cursor: any(named: 'cursor'),
           feedUri: any(named: 'feedUri'),
+          ownerDid: any(named: 'ownerDid'),
         ),
       );
     });
···
       const feedUri = FeedRepository.kHomeFeedUri;
 
       when(
-        () => mockRepository.clearFeedContent(FeedContentRepository.kInternalHomeFeedKey),
+        () => mockRepository.clearFeedContent(FeedContentRepository.kInternalHomeFeedKey, any()),
       ).thenAnswer((_) async {});
 
       await container.read(feedContentProvider(feedUri).notifier).clearFeedContent();
 
       verify(
-        () => mockRepository.clearFeedContent(FeedContentRepository.kInternalHomeFeedKey),
+        () => mockRepository.clearFeedContent(FeedContentRepository.kInternalHomeFeedKey, any()),
       ).called(1);
     });
 
···
         () => mockRepository.fetchAndCacheFeed(
           cursor: any(named: 'cursor'),
           feedUri: any(named: 'feedUri'),
+          ownerDid: any(named: 'ownerDid'),
         ),
       );
     });

test/src/features/feeds/application/feed_providers_test.dart

···
           sortOrder: 0,
           isPinned: false,
           lastSynced: DateTime.now(),
+          ownerDid: 'did:plc:test',
         ),
         SavedFeed(
           uri: 'at://did:plc:test/app.bsky.feed.generator/feed2',
···
           sortOrder: 1,
           isPinned: true,
           lastSynced: DateTime.now(),
+          ownerDid: 'did:plc:test',
         ),
       ];
 
-      when(() => mockRepository.watchAllFeeds()).thenAnswer((_) => Stream.value(feeds));
+      when(() => mockRepository.watchAllFeeds(any())).thenAnswer((_) => Stream.value(feeds));
 
       final container = createContainer();
 
···
     });
 
     test('handles empty feed list', () async {
-      when(() => mockRepository.watchAllFeeds()).thenAnswer((_) => Stream.value([]));
+      when(() => mockRepository.watchAllFeeds(any())).thenAnswer((_) => Stream.value([]));
 
       final container = createContainer();
 
···
           sortOrder: 0,
           isPinned: true,
           lastSynced: DateTime.now(),
+          ownerDid: 'did:plc:test',
         ),
       ];
 
-      when(() => mockRepository.watchPinnedFeeds()).thenAnswer((_) => Stream.value(pinnedFeeds));
+      when(
+        () => mockRepository.watchPinnedFeeds(any()),
+      ).thenAnswer((_) => Stream.value(pinnedFeeds));
 
       final container = createContainer();
 
···
     });
 
     test('handles no pinned feeds', () async {
-      when(() => mockRepository.watchPinnedFeeds()).thenAnswer((_) => Stream.value([]));
+      when(() => mockRepository.watchPinnedFeeds(any())).thenAnswer((_) => Stream.value([]));
 
       final container = createContainer();
 
···
         sortOrder: 0,
         isPinned: true,
         lastSynced: DateTime.now(),
+        ownerDid: 'did:plc:test',
       );
 
-      when(() => mockRepository.watchPinnedFeeds()).thenAnswer((_) => Stream.value([pinnedFeed]));
+      when(
+        () => mockRepository.watchPinnedFeeds(any()),
+      ).thenAnswer((_) => Stream.value([pinnedFeed]));
 
       final container = createContainer(authenticated: true);
       final subscription = container.listen(pinnedFeedsProvider, (previous, next) {});
···
     });
 
     test('initial state falls back to discover when authenticated with no pinned feeds', () async {
-      when(() => mockRepository.watchPinnedFeeds()).thenAnswer((_) => Stream.value([]));
+      when(() => mockRepository.watchPinnedFeeds(any())).thenAnswer((_) => Stream.value([]));
 
       final container = createContainer(authenticated: true);
 
···
         sortOrder: 0,
         isPinned: true,
         lastSynced: DateTime.now(),
+        ownerDid: 'did:plc:test',
       );
 
-      when(() => mockRepository.watchPinnedFeeds()).thenAnswer((_) => Stream.value([pinnedFeed]));
+      when(
+        () => mockRepository.watchPinnedFeeds(any()),
+      ).thenAnswer((_) => Stream.value([pinnedFeed]));
 
       final container = createContainer(authenticated: true);
       final subscription = container.listen(pinnedFeedsProvider, (previous, next) {});
···
     });
 
     test('resetToDefault falls back to discover when unauthenticated', () async {
-      when(() => mockRepository.watchPinnedFeeds()).thenAnswer((_) => Stream.value([]));
+      when(() => mockRepository.watchPinnedFeeds(any())).thenAnswer((_) => Stream.value([]));
 
       final container = createContainer(authenticated: false);
       final subscription = container.listen(pinnedFeedsProvider, (_, _) {});

test/src/features/feeds/application/feed_sync_controller_test.dart

···
 
   setUp(() {
     mockRepository = MockFeedRepository();
-    when(() => mockRepository.seedDefaultFeeds()).thenAnswer((_) async {});
-    when(() => mockRepository.syncOnResume()).thenAnswer((_) async {});
-    when(() => mockRepository.syncPreferences()).thenAnswer((_) async {});
+    when(() => mockRepository.seedDefaultFeeds(any())).thenAnswer((_) async {});
+    when(() => mockRepository.syncOnResume(any())).thenAnswer((_) async {});
+    when(() => mockRepository.syncPreferences(any())).thenAnswer((_) async {});
   });
 
   group('FeedRepository sync behavior', () {
     test('syncOnResume calls syncPreferences', () async {
-      await mockRepository.syncOnResume();
+      await mockRepository.syncOnResume(any());
 
-      verify(() => mockRepository.syncOnResume()).called(1);
+      verify(() => mockRepository.syncOnResume(any())).called(1);
     });
 
     test('seedDefaultFeeds is callable', () async {
-      await mockRepository.seedDefaultFeeds();
+      await mockRepository.seedDefaultFeeds(any());
 
-      verify(() => mockRepository.seedDefaultFeeds()).called(1);
+      verify(() => mockRepository.seedDefaultFeeds(any())).called(1);
     });
 
     test('syncPreferences is callable', () async {
-      await mockRepository.syncPreferences();
+      await mockRepository.syncPreferences(any());
 
-      verify(() => mockRepository.syncPreferences()).called(1);
+      verify(() => mockRepository.syncPreferences(any())).called(1);
     });
   });
 
   group('sync flow integration', () {
     test('simulates login sync flow', () async {
-      await mockRepository.seedDefaultFeeds();
-      await mockRepository.syncOnResume();
+      await mockRepository.seedDefaultFeeds(any());
+      await mockRepository.syncOnResume(any());
 
-      verify(() => mockRepository.seedDefaultFeeds()).called(1);
-      verify(() => mockRepository.syncOnResume()).called(1);
+      verify(() => mockRepository.seedDefaultFeeds(any())).called(1);
+      verify(() => mockRepository.syncOnResume(any())).called(1);
     });
 
     test('simulates app resume flow', () async {
-      await mockRepository.seedDefaultFeeds();
-      await mockRepository.syncOnResume();
+      await mockRepository.seedDefaultFeeds(any());
+      await mockRepository.syncOnResume(any());
 
-      verify(() => mockRepository.seedDefaultFeeds()).called(1);
-      verify(() => mockRepository.syncOnResume()).called(1);
+      verify(() => mockRepository.seedDefaultFeeds(any())).called(1);
+      verify(() => mockRepository.syncOnResume(any())).called(1);
     });
   });
 }

test/src/features/feeds/infrastructure/feed_content_repository_test.dart

···
 class MockFeedContentDao extends Mock implements FeedContentDao {}
 
 void main() {
+  const ownerDid = 'did:web:tester';
   late MockXrpcClient mockApi;
   late MockFeedContentDao mockDao;
   late MockLogger mockLogger;
···
         when(
           () => mockDao.insertFeedContentBatch(
             feedKey: any(named: 'feedKey'),
+            ownerDid: ownerDid,
             newPosts: any(named: 'newPosts'),
             newProfiles: any(named: 'newProfiles'),
             newRelationships: any(named: 'newRelationships'),
···
           ),
         ).thenAnswer((_) async {});
 
-        await repository.fetchAndCacheFeed();
+        await repository.fetchAndCacheFeed(ownerDid: ownerDid);
 
         verify(
           () => mockApi.call('app.bsky.feed.getTimeline', params: any(named: 'params')),
···
             newRelationships: any(named: 'newRelationships'),
             newItems: any(named: 'newItems'),
             newCursor: 'next_cursor',
+            ownerDid: ownerDid,
           ),
         ).called(1);
       },
···
         when(
           () => mockDao.insertFeedContentBatch(
             feedKey: any(named: 'feedKey'),
+            ownerDid: ownerDid,
             newPosts: any(named: 'newPosts'),
             newProfiles: any(named: 'newProfiles'),
             newRelationships: any(named: 'newRelationships'),
···
           ),
         ).thenAnswer((_) async {});
 
-        await repository.fetchAndCacheFeed();
+        await repository.fetchAndCacheFeed(ownerDid: ownerDid);
 
         verify(
           () => mockApi.call(
···
       when(
         () => mockDao.insertFeedContentBatch(
           feedKey: any(named: 'feedKey'),
+          ownerDid: ownerDid,
           newPosts: any(named: 'newPosts'),
           newProfiles: any(named: 'newProfiles'),
           newRelationships: any(named: 'newRelationships'),
···
       ).thenAnswer((_) async {});
 
       const feedUri = 'at://did:example:123/app.bsky.feed.generator/custom';
-      await repository.fetchAndCacheFeed(feedUri: feedUri);
+      await repository.fetchAndCacheFeed(feedUri: feedUri, ownerDid: ownerDid);
 
       verify(
         () => mockApi.call(
···
       verify(
         () => mockDao.insertFeedContentBatch(
           feedKey: feedUri,
+          ownerDid: ownerDid,
           newPosts: any(named: 'newPosts'),
           newProfiles: any(named: 'newProfiles'),
           newRelationships: any(named: 'newRelationships'),
···
         () => mockApi.call(any(), params: any(named: 'params')),
       ).thenThrow(Exception('Bad Request'));
 
-      expect(() => repository.fetchAndCacheFeed(), throwsException);
+      expect(() => repository.fetchAndCacheFeed(ownerDid: ownerDid), throwsException);
 
       verify(() => mockLogger.error(any(), any(), any())).called(1);
     });
···
         when(
           () => mockDao.insertFeedContentBatch(
             feedKey: any(named: 'feedKey'),
+            ownerDid: ownerDid,
             newPosts: any(named: 'newPosts'),
             newProfiles: any(named: 'newProfiles'),
             newRelationships: any(named: 'newRelationships'),
···
           ),
         ).thenAnswer((_) async {});
 
-        await repository.fetchAndCacheFeed();
+        await repository.fetchAndCacheFeed(ownerDid: ownerDid);
 
         verify(
           () => mockDao.insertFeedContentBatch(
···
             newRelationships: any(named: 'newRelationships'),
             newItems: any(named: 'newItems'),
             newCursor: any(named: 'newCursor'),
+            ownerDid: ownerDid,
           ),
         ).called(1);
 
···
         );
 
         expect(
-          () => repository.fetchAndCacheFeed(feedUri: '__internal:malicious'),
+          () => repository.fetchAndCacheFeed(feedUri: '__internal:malicious', ownerDid: ownerDid),
           throwsA(
             isA<ArgumentError>().having(
               (e) => e.message,
···
         when(
           () => mockDao.insertFeedContentBatch(
             feedKey: any(named: 'feedKey'),
+            ownerDid: ownerDid,
             newPosts: any(named: 'newPosts'),
             newProfiles: any(named: 'newProfiles'),
             newRelationships: any(named: 'newRelationships'),
···
         ).thenAnswer((_) async {});
 
         const validUri = 'at://did:plc:abc123/app.bsky.feed.generator/test';
-        await repository.fetchAndCacheFeed(feedUri: validUri);
+        await repository.fetchAndCacheFeed(feedUri: validUri, ownerDid: ownerDid);
 
         verify(
           () => mockDao.insertFeedContentBatch(
             feedKey: validUri,
+            ownerDid: ownerDid,
             newPosts: any(named: 'newPosts'),
             newProfiles: any(named: 'newProfiles'),
             newRelationships: any(named: 'newRelationships'),
···
         when(
           () => mockDao.insertFeedContentBatch(
             feedKey: any(named: 'feedKey'),
+            ownerDid: ownerDid,
             newPosts: any(named: 'newPosts'),
             newProfiles: any(named: 'newProfiles'),
             newRelationships: any(named: 'newRelationships'),
···
           capturedPosts = invocation.namedArguments[#newPosts] as List;
         });
 
-        await repository.fetchAndCacheFeed();
+        await repository.fetchAndCacheFeed(ownerDid: ownerDid);
 
         expect(capturedPosts, isNotNull);
         expect(capturedPosts, hasLength(1));
···
         when(
           () => mockDao.insertFeedContentBatch(
             feedKey: any(named: 'feedKey'),
+            ownerDid: ownerDid,
             newPosts: any(named: 'newPosts'),
             newProfiles: any(named: 'newProfiles'),
             newRelationships: any(named: 'newRelationships'),
···
           capturedPosts = invocation.namedArguments[#newPosts] as List;
         });
 
-        await repository.fetchAndCacheFeed();
+        await repository.fetchAndCacheFeed(ownerDid: ownerDid);
 
         expect(capturedPosts, isNotNull);
         final postCompanion = capturedPosts!.first;
···
         when(
           () => mockDao.insertFeedContentBatch(
             feedKey: any(named: 'feedKey'),
+            ownerDid: ownerDid,
             newPosts: any(named: 'newPosts'),
             newProfiles: any(named: 'newProfiles'),
             newRelationships: any(named: 'newRelationships'),
···
           capturedItems = invocation.namedArguments[#newItems] as List;
         });
 
-        await repository.fetchAndCacheFeed();
+        await repository.fetchAndCacheFeed(ownerDid: ownerDid);
 
         expect(capturedItems, isNotNull);
         final sortKeys = capturedItems!
···
         when(
           () => mockDao.insertFeedContentBatch(
             feedKey: any(named: 'feedKey'),
+            ownerDid: ownerDid,
             newPosts: any(named: 'newPosts'),
             newProfiles: any(named: 'newProfiles'),
             newRelationships: any(named: 'newRelationships'),
···
           allCapturedItems.add(items);
         });
 
-        await repository.fetchAndCacheFeed();
-        await repository.fetchAndCacheFeed();
+        await repository.fetchAndCacheFeed(ownerDid: ownerDid);
+        await repository.fetchAndCacheFeed(ownerDid: ownerDid);
 
         final allSortKeys = allCapturedItems
             .expand((items) => items)

test/src/features/feeds/infrastructure/feed_repository_lists_test.dart

···
   late AppDatabase db;
   late MockLogger mockLogger;
   late FeedRepository repository;
+  const ownerDid = 'did:web:tester';
 
   setUp(() {
     mockApi = MockXrpcClient();
···
         ),
       ).thenAnswer((_) async => feedMetadata);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(2));
 
       final list = feeds.firstWhere((f) => f.uri == 'at://did:plc:abc/app.bsky.graph.list/mylist');
···
         ),
       ).thenAnswer((_) async => feedMetadata);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(2));
 
       final followingFeed = feeds.firstWhere((f) => f.uri == 'following');
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenAnswer((_) async => prefsResponse);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
 
       final timelineFeed = feeds.first;
···
           isPinned: const Value(false),
           lastSynced: DateTime.now().subtract(const Duration(days: 1)),
           localUpdatedAt: const Value(null),
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenAnswer((_) async => prefsResponse);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
 
       final followingFeed = feeds.first;
···
           creatorDid: 'did:plc:abc',
           sortOrder: 0,
           lastSynced: staleTimestamp,
+          ownerDid: ownerDid,
         ),
       );
 
···
         ),
       ).thenAnswer((_) async => listMetadata);
 
-      await repository.refreshStaleMetadata();
+      await repository.refreshStaleMetadata(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
 
       final list = feeds.first;
···
           creatorDid: '',
           sortOrder: 0,
           lastSynced: staleTimestamp,
+          ownerDid: ownerDid,
         ),
       );
 
-      await repository.refreshStaleMetadata();
+      await repository.refreshStaleMetadata(ownerDid);
 
       verifyNever(() => mockApi.call('app.bsky.graph.getList', params: any(named: 'params')));
       verifyNever(
···
           creatorDid: 'did:plc:abc',
           sortOrder: 0,
           lastSynced: staleTimestamp,
+          ownerDid: ownerDid,
         ),
         SavedFeedsCompanion.insert(
           uri: 'at://did:plc:def/app.bsky.feed.generator/test',
···
           creatorDid: 'did:plc:def',
           sortOrder: 1,
           lastSynced: staleTimestamp,
+          ownerDid: ownerDid,
         ),
       ]);
 
···
         ),
       ).thenAnswer((_) async => feedMetadata);
 
-      await repository.refreshStaleMetadata();
+      await repository.refreshStaleMetadata(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(2));
 
       final list = feeds.firstWhere((f) => f.uri == 'at://did:plc:abc/app.bsky.graph.list/mylist');

test/src/features/feeds/infrastructure/feed_repository_management_test.dart

···
   late AppDatabase db;
   late MockLogger mockLogger;
   late FeedRepository repository;
+  const ownerDid = 'did:web:tester';
 
   setUp(() {
     mockApi = MockXrpcClient();
···
         () => mockApi.call('app.bsky.feed.getFeedGenerator', params: {'feed': feedUri}),
       ).thenAnswer((_) async => feedMetadata);
 
-      await repository.saveFeed(feedUri);
+      await repository.saveFeed(feedUri, ownerDid);
 
       verify(
         () => mockApi.call(
···
         ),
       ).called(1);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNotNull);
       expect(feed!.displayName, 'New Feed');
-      final queue = await db.preferenceSyncQueueDao.getPendingItems();
+      final queue = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queue, isEmpty);
     });
 
···
         () => mockApi.call('app.bsky.feed.getFeedGenerator', params: {'feed': feedUri}),
       ).thenThrow(Exception('Network error'));
 
-      await repository.saveFeed(feedUri);
+      await repository.saveFeed(feedUri, ownerDid);
 
       verify(
         () => mockApi.call('app.bsky.actor.putPreferences', body: any(named: 'body')),
       ).called(1);
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNotNull);
       expect(feed!.displayName, 'Saved Feed');
     });
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenThrow(Exception('Network error'));
 
-      await repository.saveFeed(feedUri);
+      await repository.saveFeed(feedUri, ownerDid);
 
-      final queue = await db.preferenceSyncQueueDao.getPendingItems();
+      final queue = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queue, hasLength(1));
       expect(queue.first.type, 'save');
       expect(queue.first.payload, feedUri);
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNotNull);
     });
 
···
         () => mockApi.call('app.bsky.feed.getFeedGenerator', params: {'feed': feedUri}),
       ).thenAnswer((_) async => feedMetadata);
 
-      await repository.saveFeed(feedUri, pin: true);
+      await repository.saveFeed(feedUri, ownerDid, pin: true);
 
       verify(
         () => mockApi.call(
···
         ),
       ).called(1);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed!.isPinned, true);
     });
 
···
         () => mockApi.call('app.bsky.feed.getFeedGenerator', params: {'feed': feedUri}),
       ).thenAnswer((_) async => feedMetadata);
 
-      await repository.saveFeed(feedUri);
+      await repository.saveFeed(feedUri, ownerDid);
 
       verify(
         () => mockApi.call(
···
         () => mockApi.call('app.bsky.feed.getFeedGenerator', params: {'feed': feedUri}),
       ).thenAnswer((_) async => feedMetadata);
 
-      await repository.saveFeed(feedUri);
+      await repository.saveFeed(feedUri, ownerDid);
 
       final captured =
           verify(
···
       when(() => mockApi.isAuthenticated).thenReturn(false);
 
       expect(
-        () => repository.saveFeed('at://did:plc:abc/app.bsky.feed.generator/test'),
+        () => repository.saveFeed('at://did:plc:abc/app.bsky.feed.generator/test', ownerDid),
         throwsA(isA<Exception>()),
       );
     });
···
           creatorDid: 'did:plc:abc',
           sortOrder: 0,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.putPreferences', body: any(named: 'body')),
       ).thenAnswer((_) async => {});
 
-      await repository.removeFeed(feedUri);
+      await repository.removeFeed(feedUri, ownerDid);
 
       verify(
         () => mockApi.call(
···
         ),
       ).called(1);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNull);
     });
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenAnswer((_) async => currentPrefs);
 
-      await repository.removeFeed(feedUri);
+      await repository.removeFeed(feedUri, ownerDid);
 
       verifyNever(() => mockApi.call('app.bsky.actor.putPreferences', body: any(named: 'body')));
     });
···
       when(() => mockApi.isAuthenticated).thenReturn(false);
 
       expect(
-        () => repository.removeFeed('at://did:plc:abc/app.bsky.feed.generator/test'),
+        () => repository.removeFeed('at://did:plc:abc/app.bsky.feed.generator/test', ownerDid),
         throwsA(isA<Exception>()),
       );
     });
···
           creatorDid: 'did:plc:abc',
           sortOrder: 0,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
         SavedFeedsCompanion.insert(
           uri: feed2,
···
           creatorDid: 'did:plc:def',
           sortOrder: 1,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
         SavedFeedsCompanion.insert(
           uri: feed3,
···
           creatorDid: 'did:plc:ghi',
           sortOrder: 2,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       ]);
 
···
         () => mockApi.call('app.bsky.actor.putPreferences', body: any(named: 'body')),
       ).thenAnswer((_) async => {});
 
-      await repository.reorderFeeds([feed3, feed1, feed2]);
+      await repository.reorderFeeds([feed3, feed1, feed2], ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds[0].uri, feed3);
       expect(feeds[0].sortOrder, 0);
       expect(feeds[1].uri, feed1);
···
           creatorDid: 'did:plc:abc',
           sortOrder: 0,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
         SavedFeedsCompanion.insert(
           uri: feed2,
···
           creatorDid: 'did:plc:def',
           sortOrder: 1,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       ]);
 
···
         () => mockApi.call('app.bsky.actor.putPreferences', body: any(named: 'body')),
       ).thenAnswer((_) async => {});
 
-      await repository.reorderFeeds([feed2, feed1]);
+      await repository.reorderFeeds([feed2, feed1], ownerDid);
 
       verify(
         () => mockApi.call(
···
           creatorDid: 'did:plc:abc',
           sortOrder: 0,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
         SavedFeedsCompanion.insert(
           uri: feed2,
···
           creatorDid: 'did:plc:def',
           sortOrder: 1,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       ]);
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenThrow(Exception('Network error'));
 
-      await repository.reorderFeeds([feed2, feed1]);
+      await repository.reorderFeeds([feed2, feed1], ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds[0].uri, feed2);
       expect(feeds[1].uri, feed1);
 
-      final queue = await db.preferenceSyncQueueDao.getPendingItems();
+      final queue = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queue, hasLength(1));
       expect(queue.first.type, 'reorder');
       expect(queue.first.payload, '$feed2,$feed1');
···
       when(() => mockApi.isAuthenticated).thenReturn(false);
 
       expect(
-        () => repository.reorderFeeds(['at://did:plc:abc/app.bsky.feed.generator/test']),
+        () => repository.reorderFeeds(['at://did:plc:abc/app.bsky.feed.generator/test'], ownerDid),
         throwsA(isA<Exception>()),
       );
     });
···
   group('Feed URI Validation', () {
     test('rejects empty feed URI', () {
       expect(
-        () => repository.saveFeed(''),
+        () => repository.saveFeed('', ownerDid),
         throwsA(
           isA<ArgumentError>().having((e) => e.message, 'message', contains('cannot be empty')),
         ),
···
 
     test('rejects URI without at:// scheme', () {
       expect(
-        () => repository.saveFeed('did:plc:abc/app.bsky.feed.generator/test'),
+        () => repository.saveFeed('did:plc:abc/app.bsky.feed.generator/test', ownerDid),
         throwsA(
           isA<ArgumentError>().having(
             (e) => e.message,
···
 
     test('rejects URI with insufficient components', () {
       expect(
-        () => repository.saveFeed('at://did:plc:abc'),
+        () => repository.saveFeed('at://did:plc:abc', ownerDid),
         throwsA(
           isA<ArgumentError>().having((e) => e.message, 'message', contains('must have format')),
         ),
···
 
     test('rejects URI without valid DID', () {
       expect(
-        () => repository.saveFeed('at://invalid/app.bsky.feed.generator/test'),
+        () => repository.saveFeed('at://invalid/app.bsky.feed.generator/test', ownerDid),
         throwsA(
           isA<ArgumentError>().having(
             (e) => e.message,
···
 
     test('rejects URI with wrong collection', () {
       expect(
-        () => repository.saveFeed('at://did:plc:abc/app.bsky.post/test'),
+        () => repository.saveFeed('at://did:plc:abc/app.bsky.post/test', ownerDid),
         throwsA(
           isA<ArgumentError>().having(
             (e) => e.message,
···
 
     test('rejects URI with empty rkey', () {
       expect(
-        () => repository.saveFeed('at://did:plc:abc/app.bsky.feed.generator/'),
+        () => repository.saveFeed('at://did:plc:abc/app.bsky.feed.generator/', ownerDid),
         throwsA(
           isA<ArgumentError>().having(
             (e) => e.message,
···
         () => mockApi.call('app.bsky.feed.getFeedGenerator', params: {'feed': validUri}),
       ).thenAnswer((_) async => feedMetadata);
 
-      await repository.saveFeed(validUri);
+      await repository.saveFeed(validUri, ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(validUri);
+      final feed = await db.savedFeedsDao.getFeed(validUri, ownerDid);
       expect(feed, isNotNull);
       expect(feed!.displayName, 'Valid Feed');
     });

test/src/features/feeds/infrastructure/feed_repository_query_test.dart

···
   late AppDatabase db;
   late MockLogger mockLogger;
   late FeedRepository repository;
+  const ownerDid = 'did:web:tester';
 
   setUp(() {
     mockApi = MockXrpcClient();
···
           creatorDid: 'did:plc:abc',
           sortOrder: 0,
           lastSynced: oldDate,
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.feed.getFeedGenerator', params: {'feed': feedUri}),
       ).thenAnswer((_) async => updatedMetadata);
 
-      await repository.refreshStaleMetadata();
+      await repository.refreshStaleMetadata(ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed!.displayName, 'Updated Name');
       expect(feed.likeCount, 200);
     });
···
           creatorDid: 'did:plc:abc',
           sortOrder: 0,
           lastSynced: recentDate,
+          ownerDid: ownerDid,
         ),
       );
 
-      await repository.refreshStaleMetadata();
+      await repository.refreshStaleMetadata(ownerDid);
 
       verifyNever(
         () => mockApi.call('app.bsky.feed.getFeedGenerator', params: any(named: 'params')),
···
           creatorDid: 'did:plc:abc',
           sortOrder: 0,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
-      final stream = repository.watchAllFeeds();
+      final stream = repository.watchAllFeeds(ownerDid);
       expect(stream, emits(hasLength(1)));
     });
   });
···
           sortOrder: 0,
           isPinned: const Value(true),
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
         SavedFeedsCompanion.insert(
           uri: 'at://did:plc:def/app.bsky.feed.generator/unpinned',
···
           sortOrder: 1,
           isPinned: const Value(false),
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       ]);
 
-      final stream = repository.watchPinnedFeeds();
+      final stream = repository.watchPinnedFeeds(ownerDid);
       final feeds = await stream.first;
       expect(feeds, hasLength(1));
       expect(feeds[0].displayName, 'Pinned Feed');
···
           creatorDid: 'did:plc:abc',
           sortOrder: 0,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
-      final feed = await repository.getFeed(feedUri);
+      final feed = await repository.getFeed(feedUri, ownerDid);
       expect(feed, isNotNull);
       expect(feed!.displayName, 'Test Feed');
     });
···
           sortOrder: 0,
           isPinned: const Value(true),
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
         SavedFeedsCompanion.insert(
           uri: FeedRepository.kForYouFeedUri,
···
           sortOrder: 1,
           isPinned: const Value(true),
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
         SavedFeedsCompanion.insert(
           uri: FeedRepository.kDiscoverFeedUri,
···
           sortOrder: 2,
           isPinned: const Value(true),
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       ]);
 
-      await repository.seedDefaultFeeds();
+      await repository.seedDefaultFeeds(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, isEmpty);
     });
 
···
         ),
       ).thenAnswer((_) async => mockMetadata);
 
-      await repository.seedDefaultFeeds();
+      await repository.seedDefaultFeeds(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
       expect(feeds[0].uri, FeedRepository.kDiscoverFeedUri);
       expect(feeds[0].displayName, 'What\'s Hot');
···
         ),
       ).thenThrow(Exception('Network error'));
 
-      await repository.seedDefaultFeeds();
+      await repository.seedDefaultFeeds(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
       expect(feeds[0].uri, FeedRepository.kDiscoverFeedUri);
       expect(feeds[0].displayName, 'Discover');
···
           sortOrder: 0,
           isPinned: const Value(true),
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
-      await repository.seedDefaultFeeds();
+      await repository.seedDefaultFeeds(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
       expect(feeds[0].displayName, 'Existing Discover');
       verifyNever(
···
           creatorDid: 'did:plc:test',
           sortOrder: 0,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
···
         ),
       ).thenAnswer((_) async => mockMetadata);
 
-      await repository.seedDefaultFeeds();
+      await repository.seedDefaultFeeds(ownerDid);
 
-      final deprecatedFeed = await db.savedFeedsDao.getFeed(deprecatedUri);
+      final deprecatedFeed = await db.savedFeedsDao.getFeed(deprecatedUri, ownerDid);
       expect(deprecatedFeed, isNull);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
       expect(feeds[0].uri, FeedRepository.kDiscoverFeedUri);
     });
···
           sortOrder: 3,
           isPinned: const Value(true),
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
···
         ),
       ).thenAnswer((_) async => mockMetadata);
 
-      await repository.seedDefaultFeeds();
+      await repository.seedDefaultFeeds(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
       expect(feeds[0].uri, FeedRepository.kDiscoverFeedUri);
       expect(feeds[0].isPinned, true, reason: 'Pin status should be preserved');
···
           sortOrder: 5,
           isPinned: const Value(false),
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
···
         ),
       ).thenAnswer((_) async => mockMetadata);
 
-      await repository.seedDefaultFeeds();
+      await repository.seedDefaultFeeds(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
       expect(feeds[0].uri, FeedRepository.kDiscoverFeedUri);
       expect(feeds[0].isPinned, false, reason: 'Unpinned status should be preserved');
···
           sortOrder: 5,
           isPinned: const Value(true),
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
···
           sortOrder: 0,
           isPinned: const Value(false),
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
-      await repository.seedDefaultFeeds();
+      await repository.seedDefaultFeeds(ownerDid);
 
-      final deprecatedFeed = await db.savedFeedsDao.getFeed(deprecatedUri);
+      final deprecatedFeed = await db.savedFeedsDao.getFeed(deprecatedUri, ownerDid);
       expect(deprecatedFeed, isNull);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
       expect(feeds[0].uri, FeedRepository.kDiscoverFeedUri);
       expect(feeds[0].displayName, 'Existing Discover');
···
         ),
       ).thenAnswer((_) async => mockMetadata);
 
-      await repository.seedDefaultFeeds();
+      await repository.seedDefaultFeeds(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
       expect(feeds[0].uri, FeedRepository.kDiscoverFeedUri);
       expect(feeds[0].isPinned, true);

test/src/features/feeds/infrastructure/feed_repository_sync_test.dart

···
   late AppDatabase db;
   late MockLogger mockLogger;
   late FeedRepository repository;
+  const ownerDid = 'did:web:tester';
 
   setUp(() {
     mockApi = MockXrpcClient();
···
         ),
       ).thenAnswer((_) async => feed2Metadata);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(2));
       expect(feeds[0].uri, 'at://did:plc:abc/app.bsky.feed.generator/test1');
       expect(feeds[0].displayName, 'Test Feed 1');
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenAnswer((_) async => prefsResponse);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, isEmpty);
     });
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenAnswer((_) async => prefsResponse);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, isEmpty);
     });
 
     test('skips sync for unauthenticated user', () async {
       when(() => mockApi.isAuthenticated).thenReturn(false);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
       verifyNever(() => mockApi.call('app.bsky.actor.getPreferences'));
     });
···
         ),
       ).thenAnswer((_) async => feed2Metadata);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feeds = await db.savedFeedsDao.getAllFeeds();
+      final feeds = await db.savedFeedsDao.getAllFeeds(ownerDid);
       expect(feeds, hasLength(1));
       expect(feeds[0].displayName, 'Test Feed 2');
     });
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenThrow(Exception('Network error'));
 
-      await repository.saveFeed(feedUri);
+      await repository.saveFeed(feedUri, ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNotNull, reason: 'Local feed should be saved');
 
-      final queueItems = await db.preferenceSyncQueueDao.getPendingItems();
+      final queueItems = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queueItems, hasLength(1), reason: 'Should have queued sync operation');
       expect(queueItems[0].payload, feedUri);
       expect(queueItems[0].type, 'save');
···
         () => mockApi.call('app.bsky.actor.putPreferences', body: any(named: 'body')),
       ).thenAnswer((_) async => {});
 
-      await repository.saveFeed(feedUri);
+      await repository.saveFeed(feedUri, ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNotNull, reason: 'Local feed should be saved');
 
-      final queueItems = await db.preferenceSyncQueueDao.getPendingItems();
+      final queueItems = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queueItems, isEmpty, reason: 'Queue should be empty after successful sync');
     });
 
···
           creatorDid: 'did:plc:remove',
           sortOrder: 0,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenThrow(Exception('Network error'));
 
-      await repository.removeFeed(feedUri);
+      await repository.removeFeed(feedUri, ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNull, reason: 'Local feed should be deleted');
 
-      final queueItems = await db.preferenceSyncQueueDao.getPendingItems();
+      final queueItems = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queueItems, hasLength(1), reason: 'Should have queued sync operation');
       expect(queueItems[0].payload, feedUri);
       expect(queueItems[0].type, 'remove');
···
           creatorDid: 'did:plc:remove',
           sortOrder: 0,
           lastSynced: DateTime.now(),
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.putPreferences', body: any(named: 'body')),
       ).thenAnswer((_) async => {});
 
-      await repository.removeFeed(feedUri);
+      await repository.removeFeed(feedUri, ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNull, reason: 'Local feed should be deleted');
 
-      final queueItems = await db.preferenceSyncQueueDao.getPendingItems();
+      final queueItems = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queueItems, isEmpty, reason: 'Queue should be empty after successful sync');
     });
 
···
           'likeCount': 1,
         },
       };
-
       when(
         () => mockApi.call('app.bsky.feed.getFeedGenerator', params: {'feed': feedUri}),
       ).thenAnswer((_) async => feedMetadata);
 
-      expect(() => failingRepo.saveFeed(feedUri), throwsA(isA<Exception>()));
+      expect(() => failingRepo.saveFeed(feedUri, ownerDid), throwsA(isA<Exception>()));
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNull, reason: 'Local insert should be rolled back');
 
-      final queueItems = await db.preferenceSyncQueueDao.getPendingItems();
+      final queueItems = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queueItems, isEmpty, reason: 'Queue should remain empty on failure');
     });
   });
···
           type: 'save',
           payload: feedUri,
           createdAt: now,
+          ownerDid: ownerDid,
         ),
       );
 
···
           creatorDid: 'did:plc:test',
           sortOrder: 0,
           lastSynced: now,
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenThrow(Exception('Network error'));
 
-      await repository.processSyncQueue();
+      await repository.processSyncQueue(ownerDid);
 
-      final items = await db.preferenceSyncQueueDao.getPendingItems();
+      final items = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(items.length, 1);
       expect(items.first.retryCount, 1, reason: 'Retry count should be incremented');
     });
···
               payload: feedUri,
               createdAt: now,
               retryCount: const Value(5),
+              ownerDid: ownerDid,
             ),
           );
 
-      await repository.processSyncQueue();
+      await repository.processSyncQueue(ownerDid);
 
       verifyNever(() => mockApi.call('app.bsky.actor.getPreferences'));
 
-      final items = await db.preferenceSyncQueueDao.getPendingItems();
+      final items = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(items.length, 1);
       expect(items.first.retryCount, 5, reason: 'Retry count should not change');
     });
···
               payload: 'at://did:plc:test/app.bsky.feed.generator/old-failed',
               createdAt: now.subtract(const Duration(days: 45)),
               retryCount: const Value(5),
+              ownerDid: ownerDid,
             ),
           );
 
···
           type: 'save',
           payload: 'at://did:plc:test/app.bsky.feed.generator/recent',
           createdAt: now,
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenThrow(Exception('Network error'));
 
-      await repository.syncOnResume();
+      await repository.syncOnResume(ownerDid);
 
-      final items = await db.preferenceSyncQueueDao.getPendingItems();
+      final items = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(items.length, 1);
       expect(items.first.payload, 'at://did:plc:test/app.bsky.feed.generator/recent');
     });
···
           type: 'save',
           payload: 'at://did:plc:ok/app.bsky.feed.generator/retryable',
           createdAt: now,
+          ownerDid: ownerDid,
         ),
       );
 
···
           creatorDid: 'did:plc:ok',
           sortOrder: 0,
           lastSynced: now,
+          ownerDid: ownerDid,
         ),
       );
 
···
               payload: 'at://did:plc:fail/app.bsky.feed.generator/maxed',
               createdAt: now,
               retryCount: const Value(5),
+              ownerDid: ownerDid,
             ),
           );
 
···
         () => mockApi.call('app.bsky.actor.putPreferences', body: any(named: 'body')),
       ).thenAnswer((_) async => {});
 
-      await repository.processSyncQueue();
+      await repository.processSyncQueue(ownerDid);
 
-      final items = await db.preferenceSyncQueueDao.getPendingItems();
+      final items = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(items.length, 1, reason: 'Only the maxed-out item should remain');
       expect(items.first.payload, 'at://did:plc:fail/app.bsky.feed.generator/maxed');
     });
···
           isPinned: const Value(true),
           lastSynced: baseTime,
           localUpdatedAt: Value(baseTime.add(const Duration(hours: 1))),
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenAnswer((_) async => remotePrefs);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNotNull);
       expect(feed!.isPinned, true, reason: 'Local pin status should win');
       expect(feed.displayName, 'Local Name', reason: 'Local display name should be preserved');
-      final queue = await db.preferenceSyncQueueDao.getPendingItems();
+      final queue = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queue.any((q) => q.payload == feedUri && q.type == 'save'), true);
     });
 
···
           sortOrder: 5,
           isPinned: const Value(false),
           lastSynced: baseTime,
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenAnswer((_) async => remotePrefs);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNotNull);
       expect(feed!.isPinned, true, reason: 'Remote pin status should win');
       expect(feed.sortOrder, 0, reason: 'Should use remote sort order');
···
         () => mockApi.call('app.bsky.feed.getFeedGenerator', params: {'feed': newFeedUri}),
       ).thenAnswer((_) async => feedMetadata);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(newFeedUri);
+      final feed = await db.savedFeedsDao.getFeed(newFeedUri, ownerDid);
       expect(feed, isNotNull);
       expect(feed!.displayName, 'New Remote Feed');
       expect(feed.isPinned, true);
···
           creatorDid: 'did:plc:test',
           sortOrder: 0,
           lastSynced: baseTime,
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenAnswer((_) async => remotePrefs);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(deletedFeedUri);
+      final feed = await db.savedFeedsDao.getFeed(deletedFeedUri, ownerDid);
       expect(feed, isNull, reason: 'Remotely deleted feed should be removed locally');
     });
 
···
           isPinned: const Value(true),
           lastSynced: baseTime,
           localUpdatedAt: Value(baseTime.add(const Duration(hours: 1))),
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenAnswer((_) async => remotePrefs);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(localOnlyFeedUri);
+      final feed = await db.savedFeedsDao.getFeed(localOnlyFeedUri, ownerDid);
       expect(feed, isNotNull, reason: 'Local-only feed with modifications should be kept');
 
-      final queue = await db.preferenceSyncQueueDao.getPendingItems();
+      final queue = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(
         queue.any((q) => q.payload == localOnlyFeedUri && q.type == 'save'),
         true,
···
           isPinned: const Value(true),
           lastSynced: baseTime,
           localUpdatedAt: Value(baseTime.add(const Duration(hours: 1))),
+          ownerDid: ownerDid,
         ),
       );
 
···
         () => mockApi.call('app.bsky.actor.getPreferences'),
       ).thenAnswer((_) async => remotePrefs);
 
-      await repository.syncPreferences();
+      await repository.syncPreferences(ownerDid);
 
-      final feed = await db.savedFeedsDao.getFeed(feedUri);
+      final feed = await db.savedFeedsDao.getFeed(feedUri, ownerDid);
       expect(feed, isNotNull);
       expect(feed!.isPinned, true, reason: 'Local pin status should be preserved (newer)');
     });

test/src/features/feeds/presentation/screens/feed_discovery_screen_test.dart

···
       ),
     ).thenAnswer((_) async => kTrendingFeeds);
 
-    when(() => mockRepository.saveFeed(any(), pin: any(named: 'pin'))).thenAnswer((_) async => {});
-    when(() => mockRepository.watchAllFeeds()).thenAnswer((_) async* {
+    when(
+      () => mockRepository.saveFeed(any(), any(), pin: any(named: 'pin')),
+    ).thenAnswer((_) async => {});
+    when(() => mockRepository.watchAllFeeds(any())).thenAnswer((_) async* {
       yield [];
     });
 
     final mockContentRepository = MockFeedContentRepository();
     when(
-      () => mockContentRepository.watchFeedContent(feedKey: any(named: 'feedKey')),
+      () => mockContentRepository.watchFeedContent(
+        feedKey: any(named: 'feedKey'),
+        ownerDid: any(named: 'ownerDid'),
+      ),
     ).thenAnswer((_) => Stream.value([]));
     when(
-      () => mockContentRepository.fetchAndCacheFeed(feedUri: any(named: 'feedUri')),
+      () => mockContentRepository.fetchAndCacheFeed(
+        feedUri: any(named: 'feedUri'),
+        ownerDid: any(named: 'ownerDid'),
+      ),
     ).thenAnswer((_) async {});
-    when(() => mockRepository.watchAllFeeds()).thenAnswer((_) => Stream.value([]));
+    when(() => mockRepository.watchAllFeeds(any())).thenAnswer((_) => Stream.value([]));
 
     await tester.pumpWidget(
       ProviderScope(

test/src/features/feeds/presentation/screens/feed_management_screen_test.dart

···
       ),
     ];
 
-    when(() => mockRepository.saveFeed(any(), pin: any(named: 'pin'))).thenAnswer((_) async => {});
-
-    when(() => mockRepository.removeFeed(any())).thenAnswer((_) async => {});
+    when(
+      () => mockRepository.saveFeed(any(), any(), pin: any(named: 'pin')),
+    ).thenAnswer((_) async => {});
+    when(() => mockRepository.removeFeed(any(), any())).thenAnswer((_) async => {});
 
     await tester.pumpWidget(
       ProviderScope(
···
     expect(find.text('Saved'), findsOneWidget);
 
     await tester.tap(find.widgetWithIcon(IconButton, Icons.push_pin).first);
-    verify(() => mockRepository.saveFeed('at://did:1/feed/saved1', pin: false)).called(1);
+    verify(() => mockRepository.saveFeed('at://did:1/feed/saved1', any(), pin: false)).called(1);
 
     final deleteButtons = find.widgetWithIcon(IconButton, Icons.delete_outline);
     await tester.tap(deleteButtons.last);
 
-    verify(() => mockRepository.removeFeed('at://did:1/feed/saved2')).called(1);
+    verify(() => mockRepository.removeFeed('at://did:1/feed/saved2', any())).called(1);
   });
 
   testWidgets('FeedManagementScreen renders drag handles for reordering', (tester) async {
···
       ),
     ];
 
-    when(() => mockRepository.saveFeed(any(), pin: any(named: 'pin'))).thenAnswer((_) async => {});
-    when(() => mockRepository.removeFeed(any())).thenAnswer((_) async => {});
-    when(() => mockRepository.reorderFeeds(any())).thenAnswer((_) async => {});
+    when(
+      () => mockRepository.saveFeed(any(), any(), pin: any(named: 'pin')),
+    ).thenAnswer((_) async => {});
+    when(() => mockRepository.removeFeed(any(), any())).thenAnswer((_) async => {});
+    when(() => mockRepository.reorderFeeds(any(), any())).thenAnswer((_) async => {});
 
     await tester.pumpWidget(
       ProviderScope(

test/src/features/feeds/presentation/screens/feed_screen_test.dart

···
 import '../../../../../helpers/mocks.dart';
 
 void main() {
+  const ownerDid = 'did:web:tester';
   late MockFeedContentRepository mockContentRepository;
 
   setUp(() {
     mockContentRepository = MockFeedContentRepository();
 
-    when(() => mockContentRepository.cleanupCache()).thenAnswer((_) async {});
-    when(() => mockContentRepository.getCursor(any())).thenAnswer((_) async => null);
+    when(() => mockContentRepository.cleanupCache(ownerDid)).thenAnswer((_) async {});
+    when(() => mockContentRepository.getCursor(any(), ownerDid)).thenAnswer((_) async => null);
     when(
-      () => mockContentRepository.watchFeedContent(feedKey: any(named: 'feedKey')),
+      () => mockContentRepository.watchFeedContent(
+        feedKey: any(named: 'feedKey'),
+        ownerDid: ownerDid,
+      ),
     ).thenAnswer((_) => Stream.value([]));
     when(
-      () => mockContentRepository.fetchAndCacheFeed(feedUri: any(named: 'feedUri')),
+      () => mockContentRepository.fetchAndCacheFeed(
+        feedUri: any(named: 'feedUri'),
+        ownerDid: ownerDid,
+      ),
     ).thenAnswer((_) async {});
   });
 
···
 
     await tester.pump();
     await tester.pump(Duration.zero);
-    verify(() => mockContentRepository.fetchAndCacheFeed(feedUri: activeFeed)).called(1);
+    verify(
+      () => mockContentRepository.fetchAndCacheFeed(feedUri: activeFeed, ownerDid: ownerDid),
+    ).called(1);
   });
 
   testWidgets('FeedScreen refresh triggers fetch', (tester) async {
···
 
     await tester.drag(find.byType(CustomScrollView), const Offset(0, 300));
     await tester.pumpAndSettle();
-    verify(() => mockContentRepository.fetchAndCacheFeed(feedUri: activeFeed)).called(2);
+    verify(
+      () => mockContentRepository.fetchAndCacheFeed(feedUri: activeFeed, ownerDid: ownerDid),
+    ).called(2);
   });
 }

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

···
 import '../../../../../helpers/mocks.dart';
 
 void main() {
+  const ownerDid = 'did:web:tester';
   late MockFeedRepository mockFeedRepository;
   late MockFeedContentRepository mockFeedContentRepository;
 
···
     ];
 
     when(
-      () => mockFeedContentRepository.watchFeedContent(feedKey: any(named: 'feedKey')),
+      () => mockFeedContentRepository.watchFeedContent(
+        feedKey: any(named: 'feedKey'),
+        ownerDid: ownerDid,
+      ),
     ).thenAnswer((_) => Stream.value(posts));
     when(
-      () => mockFeedContentRepository.fetchAndCacheFeed(feedUri: feedUri),
+      () => mockFeedContentRepository.fetchAndCacheFeed(feedUri: feedUri, ownerDid: ownerDid),
     ).thenAnswer((_) async {});
-    when(() => mockFeedRepository.watchAllFeeds()).thenAnswer((_) => Stream.value([]));
+    when(() => mockFeedRepository.watchAllFeeds(ownerDid)).thenAnswer((_) => Stream.value([]));
 
     await tester.pumpWidget(
       ProviderScope(
···
     const feedUri = 'at://did:1/feed/test';
 
     when(
-      () => mockFeedContentRepository.watchFeedContent(feedKey: any(named: 'feedKey')),
+      () => mockFeedContentRepository.watchFeedContent(
+        feedKey: any(named: 'feedKey'),
+        ownerDid: ownerDid,
+      ),
     ).thenAnswer((_) => Stream.value([]));
     when(
-      () => mockFeedContentRepository.fetchAndCacheFeed(feedUri: feedUri),
+      () => mockFeedContentRepository.fetchAndCacheFeed(feedUri: feedUri, ownerDid: ownerDid),
     ).thenAnswer((_) async {});
-    when(() => mockFeedRepository.watchAllFeeds()).thenAnswer((_) => Stream.value([]));
+    when(() => mockFeedRepository.watchAllFeeds(ownerDid)).thenAnswer((_) => Stream.value([]));
     when(
-      () => mockFeedRepository.saveFeed(any(), pin: any(named: 'pin')),
+      () => mockFeedRepository.saveFeed(any(), ownerDid, pin: any(named: 'pin')),
     ).thenAnswer((_) async {});
 
     await tester.pumpWidget(
···
     await tester.tap(find.text('Save'));
     await tester.pump();
 
-    verify(() => mockFeedRepository.saveFeed(feedUri, pin: false)).called(1);
+    verify(() => mockFeedRepository.saveFeed(feedUri, ownerDid, pin: false)).called(1);
   });
 }

test/src/features/notifications/application/mark_as_seen_service_test.dart

···
 class MockNotificationsSyncQueueDao extends Mock implements NotificationsSyncQueueDao {}
 
 void main() {
+  const ownerDid = 'did:web:tester';
   late MockNotificationsRepository mockRepository;
   late MockNotificationsSyncQueueDao mockSyncQueue;
   late MockLogger mockLogger;
···
         final timestamp2 = DateTime.parse('2026-01-07T12:01:00.000Z');
         final timestamp3 = DateTime.parse('2026-01-07T12:02:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenAnswer((_) async {});
 
-        service.markAsSeen(timestamp1);
-        service.markAsSeen(timestamp2);
-        service.markAsSeen(timestamp3);
+        service.markAsSeen(timestamp1, ownerDid);
+        service.markAsSeen(timestamp2, ownerDid);
+        service.markAsSeen(timestamp3, ownerDid);
 
         await Future.delayed(const Duration(seconds: 3));
 
-        verify(() => mockRepository.markAsSeenLocally(timestamp3)).called(1);
+        verify(() => mockRepository.markAsSeenLocally(timestamp3, ownerDid)).called(1);
         verify(() => mockRepository.updateSeen(timestamp3)).called(1);
       });
 
···
         final later = DateTime.parse('2026-01-07T12:05:00.000Z');
         final middle = DateTime.parse('2026-01-07T12:02:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenAnswer((_) async {});
 
-        service.markAsSeen(middle);
-        service.markAsSeen(earlier);
-        service.markAsSeen(later);
+        service.markAsSeen(middle, ownerDid);
+        service.markAsSeen(earlier, ownerDid);
+        service.markAsSeen(later, ownerDid);
 
         await Future.delayed(const Duration(seconds: 3));
 
-        verify(() => mockRepository.markAsSeenLocally(later)).called(1);
+        verify(() => mockRepository.markAsSeenLocally(later, ownerDid)).called(1);
         verify(() => mockRepository.updateSeen(later)).called(1);
       });
 
···
         final timestamp1 = DateTime.parse('2026-01-07T12:00:00.000Z');
         final timestamp2 = DateTime.parse('2026-01-07T12:01:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenAnswer((_) async {});
 
-        service.markAsSeen(timestamp1);
+        service.markAsSeen(timestamp1, ownerDid);
 
         await Future.delayed(const Duration(seconds: 1));
 
-        service.markAsSeen(timestamp2);
+        service.markAsSeen(timestamp2, ownerDid);
 
         await Future.delayed(const Duration(milliseconds: 2500));
 
-        verify(() => mockRepository.markAsSeenLocally(timestamp2)).called(1);
+        verify(() => mockRepository.markAsSeenLocally(timestamp2, ownerDid)).called(1);
       });
     });
 
···
       test('immediately flushes pending operations', () async {
         final timestamp = DateTime.parse('2026-01-07T12:00:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenAnswer((_) async {});
 
-        service.markAsSeen(timestamp);
+        service.markAsSeen(timestamp, ownerDid);
 
         await service.flush();
 
-        verify(() => mockRepository.markAsSeenLocally(timestamp)).called(1);
+        verify(() => mockRepository.markAsSeenLocally(timestamp, ownerDid)).called(1);
         verify(() => mockRepository.updateSeen(timestamp)).called(1);
       });
 
       test('does nothing when no pending operations', () async {
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenAnswer((_) async {});
 
         await service.flush();
 
-        verifyNever(() => mockRepository.markAsSeenLocally(any()));
+        verifyNever(() => mockRepository.markAsSeenLocally(any(), any()));
         verifyNever(() => mockRepository.updateSeen(any()));
       });
 
       test('cancels pending timer', () async {
         final timestamp = DateTime.parse('2026-01-07T12:00:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenAnswer((_) async {});
 
-        service.markAsSeen(timestamp);
+        service.markAsSeen(timestamp, ownerDid);
         await service.flush();
 
         await Future.delayed(const Duration(seconds: 3));
 
-        verify(() => mockRepository.markAsSeenLocally(timestamp)).called(1);
+        verify(() => mockRepository.markAsSeenLocally(timestamp, ownerDid)).called(1);
         verify(() => mockRepository.updateSeen(timestamp)).called(1);
       });
     });
···
       test('updates local cache even when API fails', () async {
         final timestamp = DateTime.parse('2026-01-07T12:00:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenThrow(Exception('Network error'));
-        when(() => mockSyncQueue.enqueueMarkSeen(any())).thenAnswer((_) async => 1);
+        when(() => mockSyncQueue.enqueueMarkSeen(any(), any())).thenAnswer((_) async => 1);
 
-        service.markAsSeen(timestamp);
+        service.markAsSeen(timestamp, ownerDid);
         await Future.delayed(const Duration(seconds: 3));
 
-        verify(() => mockRepository.markAsSeenLocally(timestamp)).called(1);
+        verify(() => mockRepository.markAsSeenLocally(timestamp, ownerDid)).called(1);
         verify(() => mockRepository.updateSeen(timestamp)).called(1);
         verify(() => mockLogger.error(any(), any(), any())).called(1);
       });
···
       test('does not retry failed operations automatically', () async {
         final timestamp = DateTime.parse('2026-01-07T12:00:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenThrow(Exception('Network error'));
-        when(() => mockSyncQueue.enqueueMarkSeen(any())).thenAnswer((_) async => 1);
+        when(() => mockSyncQueue.enqueueMarkSeen(any(), any())).thenAnswer((_) async => 1);
 
-        service.markAsSeen(timestamp);
+        service.markAsSeen(timestamp, ownerDid);
         await Future.delayed(const Duration(seconds: 3));
 
         verify(() => mockRepository.updateSeen(timestamp)).called(1);
···
       test('enqueues failed operation to sync queue', () async {
         final timestamp = DateTime.parse('2026-01-07T12:00:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenThrow(Exception('Network error'));
-        when(() => mockSyncQueue.enqueueMarkSeen(any())).thenAnswer((_) async => 1);
+        when(() => mockSyncQueue.enqueueMarkSeen(any(), any())).thenAnswer((_) async => 1);
 
-        service.markAsSeen(timestamp);
+        service.markAsSeen(timestamp, ownerDid);
         await Future.delayed(const Duration(seconds: 3));
 
-        verify(() => mockSyncQueue.enqueueMarkSeen(timestamp)).called(1);
+        verify(() => mockSyncQueue.enqueueMarkSeen(timestamp, ownerDid)).called(1);
       });
 
       test('logs error if queueing fails', () async {
         final timestamp = DateTime.parse('2026-01-07T12:00:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenThrow(Exception('Network error'));
-        when(() => mockSyncQueue.enqueueMarkSeen(any())).thenThrow(Exception('Queue error'));
-
-        service.markAsSeen(timestamp);
+        when(
+          () => mockSyncQueue.enqueueMarkSeen(any(), any()),
+        ).thenThrow(Exception('Queue error'));
+        service.markAsSeen(timestamp, ownerDid);
         await Future.delayed(const Duration(seconds: 3));
 
         verify(() => mockLogger.error(any(), any(), any())).called(2);
···
       test('does not enqueue when flush succeeds', () async {
         final timestamp = DateTime.parse('2026-01-07T12:00:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenAnswer((_) async {});
 
-        service.markAsSeen(timestamp);
+        service.markAsSeen(timestamp, ownerDid);
         await Future.delayed(const Duration(seconds: 3));
 
-        verifyNever(() => mockSyncQueue.enqueueMarkSeen(any()));
+        verifyNever(() => mockSyncQueue.enqueueMarkSeen(any(), any()));
       });
     });
 
···
       test('cancels pending timer', () async {
         final timestamp = DateTime.parse('2026-01-07T12:00:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(() => mockRepository.updateSeen(any())).thenAnswer((_) async {});
 
-        service.markAsSeen(timestamp);
+        service.markAsSeen(timestamp, ownerDid);
         service.dispose();
 
         await Future.delayed(const Duration(seconds: 3));
 
-        verifyNever(() => mockRepository.markAsSeenLocally(any()));
+        verifyNever(() => mockRepository.markAsSeenLocally(any(), any()));
         verifyNever(() => mockRepository.updateSeen(any()));
       });
     });
···
       test('prevents concurrent flush operations', () async {
         final timestamp = DateTime.parse('2026-01-07T12:00:00.000Z');
 
-        when(() => mockRepository.markAsSeenLocally(any())).thenAnswer((_) async {});
+        when(() => mockRepository.markAsSeenLocally(any(), any())).thenAnswer((_) async {});
         when(
           () => mockRepository.updateSeen(any()),
         ).thenAnswer((_) async => Future.delayed(const Duration(milliseconds: 100)));
 
-        service.markAsSeen(timestamp);
+        service.markAsSeen(timestamp, ownerDid);
 
         final flush1 = service.flush();
         final flush2 = service.flush();
 
         await Future.wait([flush1, flush2]);
 
-        verify(() => mockRepository.markAsSeenLocally(timestamp)).called(1);
+        verify(() => mockRepository.markAsSeenLocally(timestamp, ownerDid)).called(1);
         verify(() => mockRepository.updateSeen(timestamp)).called(1);
       });
     });

test/src/features/notifications/application/notifications_notifier_test.dart

···
     when(() => mockLogger.info(any(), any())).thenReturn(null);
     when(() => mockLogger.error(any(), any(), any())).thenReturn(null);
 
-    when(() => mockRepository.watchNotifications()).thenAnswer((_) => Stream.value([]));
+    when(
+      () => mockRepository.watchNotifications(any(named: 'ownerDid')),
+    ).thenAnswer((_) => Stream.value([]));
     when(
       () => mockRepository.fetchNotifications(
         cursor: any(named: 'cursor'),
         limit: any(named: 'limit'),
+        ownerDid: any(named: 'ownerDid'),
       ),
     ).thenAnswer((_) async {});
-    when(() => mockRepository.fetchNotifications()).thenAnswer((_) async {});
-    when(() => mockRepository.getCursor()).thenAnswer((_) async => null);
-    when(() => mockRepository.markAllAsRead()).thenAnswer((_) async {});
+    when(
+      () => mockRepository.fetchNotifications(ownerDid: any(named: 'ownerDid')),
+    ).thenAnswer((_) async {});
+    when(() => mockRepository.getCursor(any(named: 'ownerDid'))).thenAnswer((_) async => null);
+    when(() => mockRepository.markAllAsRead(any(named: 'ownerDid'))).thenAnswer((_) async {});
     when(() => mockRepository.updateSeen(any())).thenAnswer((_) async {});
     when(() => mockMarkAsSeenService.flush()).thenAnswer((_) async {});
 
···
 
       await Future.delayed(Duration.zero);
 
-      verify(() => mockRepository.watchNotifications()).called(1);
+      verify(() => mockRepository.watchNotifications(any(named: 'ownerDid'))).called(1);
     });
 
     test('refresh calls repository fetchNotifications when authenticated', () async {
···
 
       await container.read(notificationsProvider.notifier).refresh();
 
-      verify(() => mockRepository.fetchNotifications()).called(1);
+      verify(() => mockRepository.fetchNotifications(ownerDid: any(named: 'ownerDid'))).called(1);
     });
 
     test('refresh skips fetch when not authenticated', () async {
···
 
       await container.read(notificationsProvider.notifier).refresh();
 
-      verifyNever(() => mockRepository.fetchNotifications());
+      verifyNever(() => mockRepository.fetchNotifications(ownerDid: any(named: 'ownerDid')));
     });
 
     test('loadMore fetches next page using cursor', () async {
-      when(() => mockRepository.getCursor()).thenAnswer((_) async => 'next_cursor');
       when(
-        () => mockRepository.fetchNotifications(cursor: 'next_cursor'),
+        () => mockRepository.getCursor(any(named: 'ownerDid')),
+      ).thenAnswer((_) async => 'next_cursor');
+      when(
+        () => mockRepository.fetchNotifications(
+          cursor: 'next_cursor',
+          ownerDid: any(named: 'ownerDid'),
+        ),
       ).thenAnswer((_) async {});
 
       final container = createContainer();
···
 
       await container.read(notificationsProvider.notifier).loadMore();
 
-      verify(() => mockRepository.getCursor()).called(1);
-      verify(() => mockRepository.fetchNotifications(cursor: 'next_cursor')).called(1);
+      verify(() => mockRepository.getCursor(any(named: 'ownerDid'))).called(1);
+      verify(
+        () => mockRepository.fetchNotifications(
+          cursor: 'next_cursor',
+          ownerDid: any(named: 'ownerDid'),
+        ),
+      ).called(1);
     });
 
     test('loadMore does nothing without cursor', () async {
-      when(() => mockRepository.getCursor()).thenAnswer((_) async => null);
+      when(() => mockRepository.getCursor(any(named: 'ownerDid'))).thenAnswer((_) async => null);
 
       final container = createContainer();
       addTearDown(container.dispose);
 
       await container.read(notificationsProvider.notifier).loadMore();
 
-      verify(() => mockRepository.getCursor()).called(1);
-      verifyNever(() => mockRepository.fetchNotifications(cursor: any(named: 'cursor')));
+      verify(() => mockRepository.getCursor(any(named: 'ownerDid'))).called(1);
+      verifyNever(
+        () => mockRepository.fetchNotifications(
+          cursor: any(named: 'cursor'),
+          ownerDid: any(named: 'ownerDid'),
+        ),
+      );
     });
 
     test('loadMore skips when not authenticated', () async {
···
 
       await container.read(notificationsProvider.notifier).loadMore();
 
-      verifyNever(() => mockRepository.getCursor());
+      verifyNever(() => mockRepository.getCursor(any(named: 'ownerDid')));
     });
 
     test('markAllAsRead flushes service and syncs with server', () async {
···
 
       verifyInOrder([
         () => mockMarkAsSeenService.flush(),
-        () => mockRepository.markAllAsRead(),
+        () => mockRepository.markAllAsRead(any(named: 'ownerDid')),
         () => mockRepository.updateSeen(any()),
       ]);
     });
 
     test('markAllAsRead rethrows errors', () async {
       when(() => mockMarkAsSeenService.flush()).thenAnswer((_) async {});
-      when(() => mockRepository.markAllAsRead()).thenThrow(Exception('DB error'));
+      when(
+        () => mockRepository.markAllAsRead(any(named: 'ownerDid')),
+      ).thenThrow(Exception('DB error'));
 
       final container = createContainer();
       addTearDown(container.dispose);
···
     });
 
     test('refresh rethrows errors', () async {
-      when(() => mockRepository.fetchNotifications()).thenThrow(Exception('Network error'));
+      when(
+        () => mockRepository.fetchNotifications(ownerDid: any(named: 'ownerDid')),
+      ).thenThrow(Exception('Network error'));
 
       final container = createContainer();
       addTearDown(container.dispose);
···
       );
 
       when(
-        () => mockRepository.watchNotifications(),
+        () => mockRepository.watchNotifications(any(named: 'ownerDid')),
       ).thenAnswer((_) => Stream.value([testNotification]));
 
       final container = createContainer();
···
 
       await Future.delayed(Duration.zero);
 
-      verify(() => mockRepository.watchNotifications()).called(1);
+      verify(() => mockRepository.watchNotifications(any(named: 'ownerDid'))).called(1);
     });
   });
 }

test/src/features/notifications/application/unread_count_notifier_test.dart

···
     when(() => mockLogger.info(any(), any())).thenReturn(null);
     when(() => mockLogger.error(any(), any(), any())).thenReturn(null);
 
-    when(() => mockRepository.watchUnreadCount()).thenAnswer((_) => Stream.value(0));
+    when(
+      () => mockRepository.watchUnreadCount(any(named: 'ownerDid')),
+    ).thenAnswer((_) => Stream.value(0));
   });
 
   group('UnreadCountNotifier', () {
···
 
       await pumpEventQueue();
 
-      verify(() => mockRepository.watchUnreadCount()).called(1);
+      verify(() => mockRepository.watchUnreadCount(any(named: 'ownerDid'))).called(1);
     });
 
     test('build returns 0 when not authenticated', () async {
···
       await pumpEventQueue();
 
       expect(emittedValue, 0);
-      verifyNever(() => mockRepository.watchUnreadCount());
+      verifyNever(() => mockRepository.watchUnreadCount(any(named: 'ownerDid')));
     });
 
     test('stream emits unread count from repository', () async {
-      when(() => mockRepository.watchUnreadCount()).thenAnswer((_) => Stream.value(5));
+      when(
+        () => mockRepository.watchUnreadCount(any(named: 'ownerDid')),
+      ).thenAnswer((_) => Stream.value(5));
 
       final container = createContainer();
       addTearDown(container.dispose);
···
       await pumpEventQueue();
 
       expect(emittedValue, 5);
-      verify(() => mockRepository.watchUnreadCount()).called(1);
+      verify(() => mockRepository.watchUnreadCount(any(named: 'ownerDid'))).called(1);
     });
 
     test('stream emits multiple updates as count changes', () async {
       final controller = StreamController<int>();
-      when(() => mockRepository.watchUnreadCount()).thenAnswer((_) => controller.stream);
+      when(
+        () => mockRepository.watchUnreadCount(any(named: 'ownerDid')),
+      ).thenAnswer((_) => controller.stream);
 
       final container = createContainer();
       addTearDown(() {
···
     });
 
     test('stream handles zero unread count', () async {
-      when(() => mockRepository.watchUnreadCount()).thenAnswer((_) => Stream.value(0));
+      when(
+        () => mockRepository.watchUnreadCount(any(named: 'ownerDid')),
+      ).thenAnswer((_) => Stream.value(0));
 
       final container = createContainer();
       addTearDown(container.dispose);
···
       await pumpEventQueue();
 
       expect(emittedValue, 0);
-      verify(() => mockRepository.watchUnreadCount()).called(1);
+      verify(() => mockRepository.watchUnreadCount(any(named: 'ownerDid'))).called(1);
     });
 
     test('stream handles large unread counts', () async {
-      when(() => mockRepository.watchUnreadCount()).thenAnswer((_) => Stream.value(9999));
+      when(
+        () => mockRepository.watchUnreadCount(any(named: 'ownerDid')),
+      ).thenAnswer((_) => Stream.value(9999));
 
       final container = createContainer();
       addTearDown(container.dispose);

test/src/features/notifications/infrastructure/notifications_repository_test.dart

···
   late MockNotificationsSyncQueueDao mockSyncQueue;
   late MockLogger mockLogger;
   late NotificationsRepository repository;
+  const ownerDid = 'did:web:tester';
 
   setUp(() {
     mockApi = MockXrpcClient();
···
             newNotifications: any(named: 'newNotifications'),
             newProfiles: any(named: 'newProfiles'),
             newCursor: any(named: 'newCursor'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((_) async {});
 
-        await repository.fetchNotifications();
+        await repository.fetchNotifications(ownerDid: ownerDid);
 
         verify(
           () => mockApi.call(
···
             newNotifications: any(named: 'newNotifications'),
             newProfiles: any(named: 'newProfiles'),
             newCursor: any(named: 'newCursor'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((_) async {});
 
-        await repository.fetchNotifications(cursor: 'test_cursor');
+        await repository.fetchNotifications(cursor: 'test_cursor', ownerDid: ownerDid);
 
         verify(
           () => mockApi.call(
···
             newNotifications: any(named: 'newNotifications'),
             newProfiles: any(named: 'newProfiles'),
             newCursor: any(named: 'newCursor'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((invocation) async {
           capturedNotifications = invocation.namedArguments[#newNotifications] as List;
           capturedProfiles = invocation.namedArguments[#newProfiles] as List;
         });
 
-        await repository.fetchNotifications();
+        await repository.fetchNotifications(ownerDid: ownerDid);
 
         expect(capturedNotifications, hasLength(2));
         expect(capturedProfiles, hasLength(2));
···
             newNotifications: any(named: 'newNotifications'),
             newProfiles: any(named: 'newProfiles'),
             newCursor: 'next_cursor',
+            ownerDid: ownerDid,
           ),
         ).called(1);
       });
···
             newNotifications: any(named: 'newNotifications'),
             newProfiles: any(named: 'newProfiles'),
             newCursor: any(named: 'newCursor'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((invocation) async {
           capturedNotifications = invocation.namedArguments[#newNotifications] as List;
         });
 
-        await repository.fetchNotifications();
+        await repository.fetchNotifications(ownerDid: ownerDid);
 
         expect(capturedNotifications, isEmpty);
       });
···
             newNotifications: any(named: 'newNotifications'),
             newProfiles: any(named: 'newProfiles'),
             newCursor: any(named: 'newCursor'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((invocation) async {
           capturedNotifications = invocation.namedArguments[#newNotifications] as List;
         });
 
-        await repository.fetchNotifications();
+        await repository.fetchNotifications(ownerDid: ownerDid);
 
         expect(capturedNotifications, isEmpty);
       });
···
             newNotifications: any(named: 'newNotifications'),
             newProfiles: any(named: 'newProfiles'),
             newCursor: any(named: 'newCursor'),
+            ownerDid: any(named: 'ownerDid'),
           ),
         ).thenAnswer((invocation) async {
           capturedNotifications = invocation.namedArguments[#newNotifications] as List;
         });
 
-        await repository.fetchNotifications();
+        await repository.fetchNotifications(ownerDid: ownerDid);
 
         expect(capturedNotifications, hasLength(1));
       });
···
           () => mockApi.call(any(), params: any(named: 'params')),
         ).thenThrow(Exception('Network error'));
 
-        expect(() => repository.fetchNotifications(), throwsException);
+        expect(() => repository.fetchNotifications(ownerDid: ownerDid), throwsException);
 
         verify(() => mockLogger.error(any(), any(), any())).called(1);
       });
···
 
     group('watchNotifications', () {
       test('returns stream from DAO mapped to domain models', () async {
-        when(() => mockDao.watchNotifications()).thenAnswer((_) => Stream.value([]));
+        when(() => mockDao.watchNotifications(any())).thenAnswer((_) => Stream.value([]));
 
-        final stream = repository.watchNotifications();
+        final stream = repository.watchNotifications(ownerDid);
         final result = await stream.first;
 
         expect(result, isEmpty);
-        verify(() => mockDao.watchNotifications()).called(1);
+        verify(() => mockDao.watchNotifications(ownerDid)).called(1);
       });
     });
 
     group('getCursor', () {
       test('returns cursor from DAO', () async {
-        when(() => mockDao.getCursor()).thenAnswer((_) async => 'test_cursor');
+        when(() => mockDao.getCursor(any())).thenAnswer((_) async => 'test_cursor');
 
-        final cursor = await repository.getCursor();
+        final cursor = await repository.getCursor(ownerDid);
 
         expect(cursor, 'test_cursor');
-        verify(() => mockDao.getCursor()).called(1);
+        verify(() => mockDao.getCursor(ownerDid)).called(1);
       });
     });
 
     group('clearNotifications', () {
       test('calls DAO clearNotifications', () async {
-        when(() => mockDao.clearNotifications()).thenAnswer((_) async {});
+        when(() => mockDao.clearNotifications(any())).thenAnswer((_) async {});
 
-        await repository.clearNotifications();
+        await repository.clearNotifications(ownerDid);
 
-        verify(() => mockDao.clearNotifications()).called(1);
+        verify(() => mockDao.clearNotifications(ownerDid)).called(1);
       });
     });
 
     group('markAllAsRead', () {
       test('calls DAO markAllAsRead', () async {
-        when(() => mockDao.markAllAsRead()).thenAnswer((_) async {});
+        when(() => mockDao.markAllAsRead(any())).thenAnswer((_) async {});
 
-        await repository.markAllAsRead();
+        await repository.markAllAsRead(ownerDid);
 
-        verify(() => mockDao.markAllAsRead()).called(1);
+        verify(() => mockDao.markAllAsRead(ownerDid)).called(1);
       });
     });
 
···
     group('markAsSeenLocally', () {
       test('calls DAO markAsSeenBefore with timestamp', () async {
         final seenAt = DateTime.parse('2026-01-07T12:30:00.000Z');
-        when(() => mockDao.markAsSeenBefore(any())).thenAnswer((_) async {});
+        when(() => mockDao.markAsSeenBefore(any(), any())).thenAnswer((_) async {});
 
-        await repository.markAsSeenLocally(seenAt);
+        await repository.markAsSeenLocally(seenAt, ownerDid);
 
-        verify(() => mockDao.markAsSeenBefore(seenAt)).called(1);
+        verify(() => mockDao.markAsSeenBefore(seenAt, ownerDid)).called(1);
       });
     });
 
     group('watchUnreadCount', () {
       test('returns stream from DAO', () async {
-        when(() => mockDao.watchUnreadCount()).thenAnswer((_) => Stream.value(5));
+        when(() => mockDao.watchUnreadCount(any())).thenAnswer((_) => Stream.value(5));
 
-        final stream = repository.watchUnreadCount();
+        final stream = repository.watchUnreadCount(ownerDid);
         final result = await stream.first;
 
         expect(result, 5);
-        verify(() => mockDao.watchUnreadCount()).called(1);
+        verify(() => mockDao.watchUnreadCount(ownerDid)).called(1);
       });
     });
 
     group('processSyncQueue', () {
       test('does nothing when queue is empty', () async {
         when(() => mockSyncQueue.cleanupOldFailedItems(any())).thenAnswer((_) async => 0);
-        when(() => mockSyncQueue.getLatestSeenAt()).thenAnswer((_) async => null);
+        when(() => mockSyncQueue.getLatestSeenAt(any())).thenAnswer((_) async => null);
 
-        await repository.processSyncQueue();
+        await repository.processSyncQueue(ownerDid);
 
         verify(() => mockSyncQueue.cleanupOldFailedItems(any())).called(1);
-        verify(() => mockSyncQueue.getLatestSeenAt()).called(1);
-        verifyNever(() => mockDao.markAsSeenBefore(any()));
+        verify(() => mockSyncQueue.getLatestSeenAt(ownerDid)).called(1);
+        verifyNever(() => mockDao.markAsSeenBefore(any(), any()));
         verifyNever(() => mockApi.call(any(), body: any(named: 'body')));
       });
 
···
         final latestSeenAt = DateTime.parse('2026-01-07T12:30:00.000Z');
 
         when(() => mockSyncQueue.cleanupOldFailedItems(any())).thenAnswer((_) async => 0);
-        when(() => mockSyncQueue.getLatestSeenAt()).thenAnswer((_) async => latestSeenAt);
-        when(() => mockSyncQueue.getRetryableItems()).thenAnswer((_) async => []);
-        when(() => mockDao.markAsSeenBefore(any())).thenAnswer((_) async {});
+        when(() => mockSyncQueue.getLatestSeenAt(any())).thenAnswer((_) async => latestSeenAt);
+        when(() => mockSyncQueue.getRetryableItems(any())).thenAnswer((_) async => []);
+        when(() => mockDao.markAsSeenBefore(any(), any())).thenAnswer((_) async {});
         when(() => mockApi.call(any(), body: any(named: 'body'))).thenAnswer((_) async => {});
-        when(() => mockSyncQueue.deleteItemsUpTo(any())).thenAnswer((_) async => 2);
+        when(() => mockSyncQueue.deleteItemsUpTo(any(), any())).thenAnswer((_) async => 2);
 
-        await repository.processSyncQueue();
+        await repository.processSyncQueue(ownerDid);
 
-        verify(() => mockDao.markAsSeenBefore(latestSeenAt)).called(1);
+        verify(() => mockDao.markAsSeenBefore(latestSeenAt, ownerDid)).called(1);
         verify(
           () => mockApi.call(
             'app.bsky.notification.updateSeen',
             body: {'seenAt': latestSeenAt.toIso8601String()},
           ),
         ).called(1);
-        verify(() => mockSyncQueue.deleteItemsUpTo(latestSeenAt)).called(1);
+        verify(() => mockSyncQueue.deleteItemsUpTo(latestSeenAt, ownerDid)).called(1);
       });
 
       test('increments retry count on failure', () async {
···
           seenAt: latestSeenAt.toIso8601String(),
           createdAt: now,
           retryCount: 0,
+          ownerDid: ownerDid,
         );
         final mockItem2 = NotificationsSyncQueueData(
           id: 2,
···
           seenAt: latestSeenAt.toIso8601String(),
           createdAt: now,
           retryCount: 1,
+          ownerDid: ownerDid,
         );
 
         when(() => mockSyncQueue.cleanupOldFailedItems(any())).thenAnswer((_) async => 0);
-        when(() => mockSyncQueue.getLatestSeenAt()).thenAnswer((_) async => latestSeenAt);
+        when(() => mockSyncQueue.getLatestSeenAt(any())).thenAnswer((_) async => latestSeenAt);
         when(
-          () => mockSyncQueue.getRetryableItems(),
+          () => mockSyncQueue.getRetryableItems(any()),
         ).thenAnswer((_) async => [mockItem1, mockItem2]);
-        when(() => mockDao.markAsSeenBefore(any())).thenAnswer((_) async {});
+        when(() => mockDao.markAsSeenBefore(any(), any())).thenAnswer((_) async {});
         when(
           () => mockApi.call(any(), body: any(named: 'body')),
         ).thenThrow(Exception('Network error'));
         when(() => mockSyncQueue.incrementRetryCount(any())).thenAnswer((_) async => 1);
 
-        await repository.processSyncQueue();
+        await repository.processSyncQueue(ownerDid);
 
         verify(() => mockSyncQueue.incrementRetryCount(1)).called(1);
         verify(() => mockSyncQueue.incrementRetryCount(2)).called(1);
-        verifyNever(() => mockSyncQueue.deleteItemsUpTo(any()));
+        verifyNever(() => mockSyncQueue.deleteItemsUpTo(any(), any()));
       });
 
       test('cleans up old failed items', () async {
         when(() => mockSyncQueue.cleanupOldFailedItems(any())).thenAnswer((_) async => 3);
-        when(() => mockSyncQueue.getLatestSeenAt()).thenAnswer((_) async => null);
+        when(() => mockSyncQueue.getLatestSeenAt(any())).thenAnswer((_) async => null);
 
-        await repository.processSyncQueue();
+        await repository.processSyncQueue(ownerDid);
 
         verify(() => mockSyncQueue.cleanupOldFailedItems(any())).called(1);
         verify(() => mockLogger.info(any(), any())).called(greaterThanOrEqualTo(1));

test/src/features/notifications/notifications_screen_test.dart

···
 
     if (throwError) {
       when(
-        () => mockRepository.watchNotifications(),
+        () => mockRepository.watchNotifications(any(named: 'ownerDid')),
       ).thenAnswer((_) => Stream.error(Exception('Network error')));
     } else {
       when(
-        () => mockRepository.watchNotifications(),
+        () => mockRepository.watchNotifications(any(named: 'ownerDid')),
       ).thenAnswer((_) => Stream.value(notifications));
     }
 
···
     when(() => mockLogger.info(any(), any())).thenReturn(null);
     when(() => mockLogger.error(any(), any(), any())).thenReturn(null);
 
-    when(() => mockRepository.watchNotifications()).thenAnswer((_) => Stream.value([]));
+    when(
+      () => mockRepository.watchNotifications(any(named: 'ownerDid')),
+    ).thenAnswer((_) => Stream.value([]));
     when(
       () => mockRepository.fetchNotifications(
         cursor: any(named: 'cursor'),
         limit: any(named: 'limit'),
+        ownerDid: any(named: 'ownerDid'),
       ),
     ).thenAnswer((_) async {});
-    when(() => mockRepository.fetchNotifications()).thenAnswer((_) async {});
-    when(() => mockRepository.getCursor()).thenAnswer((_) async => null);
-    when(() => mockRepository.markAllAsRead()).thenAnswer((_) async {});
+    when(
+      () => mockRepository.fetchNotifications(ownerDid: any(named: 'ownerDid')),
+    ).thenAnswer((_) async {});
+    when(() => mockRepository.getCursor(any(named: 'ownerDid'))).thenAnswer((_) async => null);
+    when(() => mockRepository.markAllAsRead(any(named: 'ownerDid'))).thenAnswer((_) async {});
     when(() => mockRepository.updateSeen(any())).thenAnswer((_) async {});
     when(() => mockMarkAsSeenService.flush()).thenAnswer((_) async {});
 
···
       await tester.pump();
       await tester.pump(const Duration(milliseconds: 100));
 
-      verify(() => mockRepository.fetchNotifications()).called(1);
+      verify(() => mockRepository.fetchNotifications(ownerDid: any(named: 'ownerDid'))).called(1);
     });
 
     testWidgets('mark all as read button is visible when authenticated', (tester) async {
···
       await tester.tap(find.byIcon(Icons.done_all));
       await tester.pump();
 
-      verify(() => mockRepository.markAllAsRead()).called(1);
+      verify(() => mockRepository.markAllAsRead(any(named: 'ownerDid'))).called(1);
     });
   });
 }

test/src/features/notifications/presentation/widgets/grouped_notification_item_test.dart

···
     mockRepository = MockNotificationsRepository();
 
     registerFallbackValue(DateTime.now());
-    when(() => mockMarkAsSeenService.markAsSeen(any())).thenReturn(null);
+    when(() => mockMarkAsSeenService.markAsSeen(any(), any(named: 'ownerDid'))).thenReturn(null);
   });
 
   group('GroupedNotificationItem', () {

test/src/features/profile/application/profile_notifier_test.dart

···
       ],
     );
 
-    when(() => mockRepository.getProfile(testDid)).thenAnswer((_) async => testProfile);
+    when(() => mockRepository.getProfile(testDid, any())).thenAnswer((_) async => testProfile);
   });
 
   tearDown(() {
···
       when(() => mockRepository.muteActor(myDid, testDid)).thenAnswer((_) async {});
 
       final notifier = container.read(profileProvider(testDid).notifier);
-      await container.read(profileProvider(testDid).future); // Wait for build
+      await container.read(profileProvider(testDid).future);
 
       await notifier.toggleMute();
 
···
 
     test('toggleMute un-mutes if already muted', () async {
       final mutedProfile = testProfile.copyWith(viewerMuted: true);
-      when(() => mockRepository.getProfile(testDid)).thenAnswer((_) async => mutedProfile);
+      when(() => mockRepository.getProfile(testDid, any())).thenAnswer((_) async => mutedProfile);
       when(() => mockRepository.unmuteActor(myDid, testDid)).thenAnswer((_) async {});
 
       final notifier = container.read(profileProvider(testDid).notifier);
···
       const blockUri = 'at://...';
       final blockedProfile = testProfile.copyWith(viewerBlockingUri: blockUri);
 
-      when(() => mockRepository.getProfile(testDid)).thenAnswer((_) async => blockedProfile);
+      when(
+        () => mockRepository.getProfile(testDid, any()),
+      ).thenAnswer((_) async => blockedProfile);
       when(
         () => mockRepository.unblockActor(myDid, blockUri, subjectDid: any(named: 'subjectDid')),
       ).thenAnswer((_) async {});

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

···
         },
       );
 
-      final profile = await repository.getProfile('test.bsky.social');
+      final profile = await repository.getProfile('test.bsky.social', any());
 
       expect(profile.pinnedPostUri, 'at://did:plc:test123/app.bsky.feed.post/pinned123');
 
···
         () => 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');
+      final profile = await repository.getProfile('test.bsky.social', any());
 
       expect(profile.pinnedPostUri, isNull);
     });

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

···
           () => mockApi.call(any(), params: any(named: 'params')),
         ).thenAnswer((_) async => _mockProfileResponse(withViewer: true));
 
-        final profile = await repository.getProfile('testuser.bsky.social');
+        final profile = await repository.getProfile('testuser.bsky.social', any());
 
         expect(profile.did, 'did:plc:test123');
         expect(profile.handle, 'testuser.bsky.social');
···
         expect(cached, isNotNull);
         expect(cached!.handle, 'testuser.bsky.social');
 
-        final relationship = await db.profileRelationshipDao.getRelationship('did:plc:test123');
+        final relationship = await db.profileRelationshipDao.getRelationship(
+          'did:plc:test123',
+          any(),
+        );
         expect(relationship, isNotNull);
         expect(relationship!.following, true);
         expect(relationship.followingUri, 'at://did:plc:viewer/app.bsky.graph.follow/abc123');
···
           () => mockApi.call(any(), params: any(named: 'params')),
         ).thenAnswer((_) async => {'did': 'did:plc:minimal', 'handle': 'minimal.bsky.social'});
 
-        final profile = await repository.getProfile('minimal.bsky.social');
+        final profile = await repository.getProfile('minimal.bsky.social', any());
 
         expect(profile.did, 'did:plc:minimal');
         expect(profile.handle, 'minimal.bsky.social');
···
         final exception = Exception('Network error');
         when(() => mockApi.call(any(), params: any(named: 'params'))).thenThrow(exception);
 
-        expect(() => repository.getProfile('testuser'), throwsA(isA<Exception>()));
+        expect(() => repository.getProfile('testuser', any()), throwsA(isA<Exception>()));
 
         verify(() => mockLogger.error(any(), exception, any())).called(1);
       });
···
           () => mockApi.call(any(), params: any(named: 'params')),
         ).thenAnswer((_) async => _mockProfileResponse());
 
-        await repository.getProfile('testuser.bsky.social');
+        await repository.getProfile('testuser.bsky.social', any());
 
         final result = await repository.getCachedProfile('did:plc:test123');
 
···
           () => mockApi.call(any(), params: any(named: 'params')),
         ).thenAnswer((_) async => _mockProfileResponse());
 
-        await repository.getProfile('testuser.bsky.social');
+        await repository.getProfile('testuser.bsky.social', any());
 
         final result = await repository.watchProfile('did:plc:test123').first;
         expect(result, isNotNull);
···
           () => mockApi.call(any(), params: any(named: 'params')),
         ).thenAnswer((_) async => _mockProfileResponse(withViewer: true));
 
-        final profile = await repository.getProfile('testuser');
+        final profile = await repository.getProfile('testuser', any());
 
         expect(profile.viewerFollowing, isTrue);
         expect(profile.viewerFollowUri, 'at://did:plc:viewer/app.bsky.graph.follow/abc123');
···
           () => mockApi.call(any(), params: any(named: 'params')),
         ).thenAnswer((_) async => _mockProfileResponse());
 
-        final profile = await repository.getProfile('testuser');
+        final profile = await repository.getProfile('testuser', any());
 
         expect(profile.viewerFollowing, isFalse);
         expect(profile.viewerFollowUri, isNull);
···
           ProfileRelationshipsCompanion.insert(
             profileDid: 'did:plc:subject',
             updatedAt: DateTime.now(),
+            ownerDid: 'did:plc:actor',
           ),
         );
 
···
         final uri = await repository.blockActor('did:plc:actor', 'did:plc:subject');
         expect(uri, 'at://did:plc:actor/app.bsky.graph.block/rkey123');
 
-        final rel = await db.profileRelationshipDao.getRelationship('did:plc:subject');
+        final rel = await db.profileRelationshipDao.getRelationship(
+          'did:plc:subject',
+          'did:plc:actor',
+        );
         expect(rel, isNotNull);
         expect(rel!.blocked, isTrue);
         expect(rel.blockingUri, uri);
···
             blocked: const Value(true),
             blockingUri: const Value('at://did:plc:actor/app.bsky.graph.block/rkey123'),
             updatedAt: DateTime.now(),
+            ownerDid: 'did:plc:actor',
           ),
         );
 
···
           ),
         ).called(1);
 
-        final rel = await db.profileRelationshipDao.getRelationship('did:plc:subject');
+        final rel = await db.profileRelationshipDao.getRelationship(
+          'did:plc:subject',
+          'did:plc:actor',
+        );
         expect(rel, isNotNull);
         expect(rel!.blocked, isFalse);
         expect(rel.blockingUri, isNull);
···
             blocked: const Value(true),
             blockingUri: const Value('at://did:plc:actor/app.bsky.graph.block/rkey123'),
             updatedAt: DateTime.now(),
+            ownerDid: 'did:plc:actor',
           ),
         );
 
···
           'at://did:plc:actor/app.bsky.graph.block/rkey123',
         );
 
-        final rel = await db.profileRelationshipDao.getRelationship('did:plc:subject');
+        final rel = await db.profileRelationshipDao.getRelationship(
+          'did:plc:subject',
+          'did:plc:actor',
+        );
         expect(rel, isNotNull);
         expect(rel!.blocked, isTrue);
       });

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

···
   setUp(() {
     mockProfileRepository = MockProfileRepository();
     when(
-      () => mockProfileRepository.getProfile(any()),
+      () => mockProfileRepository.getProfile(any(), any()),
     ).thenAnswer((_) async => ProfileData(did: 'did:plc:test', handle: 'test.bsky.social'));
     when(() => mockProfileRepository.watchProfile(any())).thenAnswer((_) => Stream.value(null));
     when(

test/src/features/settings/application/preference_sync_controller_test.dart

···
   setUp(() {
     mockRepository = MockBlueskyPreferencesRepository();
 
-    when(() => mockRepository.syncPreferencesFromRemote()).thenAnswer((_) async {});
-    when(() => mockRepository.processSyncQueue()).thenAnswer((_) async {});
-    when(() => mockRepository.clearAll()).thenAnswer((_) async {});
+    when(() => mockRepository.syncPreferencesFromRemote(any())).thenAnswer((_) async {});
+    when(() => mockRepository.processSyncQueue(any())).thenAnswer((_) async {});
+    when(() => mockRepository.clearAll(any())).thenAnswer((_) async {});
   });
 
   group('PreferenceSyncController', () {
···
         container.read(preferenceSyncControllerProvider);
         await Future<void>.delayed(Duration.zero);
 
-        verify(() => mockRepository.syncPreferencesFromRemote()).called(1);
-        verify(() => mockRepository.processSyncQueue()).called(1);
+        verify(() => mockRepository.syncPreferencesFromRemote(any())).called(1);
+        verify(() => mockRepository.processSyncQueue(any())).called(1);
       });
 
       test('does not sync when user is not authenticated', () async {
···
         container.read(preferenceSyncControllerProvider);
         await Future<void>.delayed(Duration.zero);
 
-        verifyNever(() => mockRepository.syncPreferencesFromRemote());
-        verifyNever(() => mockRepository.processSyncQueue());
+        verifyNever(() => mockRepository.syncPreferencesFromRemote(any()));
+        verifyNever(() => mockRepository.processSyncQueue(any()));
       });
     });
 
···
         final authState = AuthStateAuthenticated(fakeSession);
 
         when(
-          () => mockRepository.syncPreferencesFromRemote(),
+          () => mockRepository.syncPreferencesFromRemote(any()),
         ).thenThrow(Exception('Network error'));
 
         final container = ProviderContainer(
···
         expect(() => container.read(preferenceSyncControllerProvider), returnsNormally);
         await Future<void>.delayed(Duration.zero);
 
-        verify(() => mockRepository.syncPreferencesFromRemote()).called(1);
+        verify(() => mockRepository.syncPreferencesFromRemote(any())).called(1);
       });
 
       test('handles queue processing errors gracefully', () async {
         final fakeSession = _createFakeSession();
         final authState = AuthStateAuthenticated(fakeSession);
 
-        when(() => mockRepository.processSyncQueue()).thenThrow(Exception('Queue error'));
+        when(() => mockRepository.processSyncQueue(any())).thenThrow(Exception('Queue error'));
 
         final container = ProviderContainer(
           overrides: [
···
       });
 
       test('does not crash when clearAll fails on logout', () async {
-        when(() => mockRepository.clearAll()).thenThrow(Exception('Clear failed'));
+        when(() => mockRepository.clearAll(any())).thenThrow(Exception('Clear failed'));
 
         const authState = AuthStateUnauthenticated();
 
···
 
         container.read(preferenceSyncControllerProvider);
         await Future<void>.delayed(Duration.zero);
-        verify(() => mockRepository.syncPreferencesFromRemote()).called(1);
+        verify(() => mockRepository.syncPreferencesFromRemote(any())).called(1);
       });
     });
   });

test/src/features/settings/application/settings_providers_test.dart

···
     test('adultContentPrefProvider calls repository watch method', () {
       const expectedPref = AdultContentPref(enabled: true);
       when(
-        () => mockRepository.watchAdultContentPref(),
+        () => mockRepository.watchAdultContentPref(any()),
       ).thenAnswer((_) => Stream.value(expectedPref));
 
       container.listen(adultContentPrefProvider, (prev, next) {});
 
-      verify(() => mockRepository.watchAdultContentPref()).called(1);
+      verify(() => mockRepository.watchAdultContentPref(any())).called(1);
     });
 
     test('contentLabelPrefsProvider calls repository watch method', () {
       const expectedPrefs = ContentLabelPrefs.empty;
       when(
-        () => mockRepository.watchContentLabelPrefs(),
+        () => mockRepository.watchContentLabelPrefs(any()),
       ).thenAnswer((_) => Stream.value(expectedPrefs));
 
       container.listen(contentLabelPrefsProvider, (prev, next) {});
 
-      verify(() => mockRepository.watchContentLabelPrefs()).called(1);
+      verify(() => mockRepository.watchContentLabelPrefs(any())).called(1);
     });
 
     test('labelersPrefProvider calls repository watch method', () {
       const expectedPref = LabelersPref.empty;
-      when(() => mockRepository.watchLabelersPref()).thenAnswer((_) => Stream.value(expectedPref));
+      when(
+        () => mockRepository.watchLabelersPref(any()),
+      ).thenAnswer((_) => Stream.value(expectedPref));
 
       container.listen(labelersPrefProvider, (prev, next) {});
 
-      verify(() => mockRepository.watchLabelersPref()).called(1);
+      verify(() => mockRepository.watchLabelersPref(any())).called(1);
     });
 
     test('feedViewPrefProvider calls repository watch method', () {
       const expectedPref = FeedViewPref.defaultPref;
-      when(() => mockRepository.watchFeedViewPref()).thenAnswer((_) => Stream.value(expectedPref));
+      when(
+        () => mockRepository.watchFeedViewPref(any()),
+      ).thenAnswer((_) => Stream.value(expectedPref));
 
       container.listen(feedViewPrefProvider, (prev, next) {});
 
-      verify(() => mockRepository.watchFeedViewPref()).called(1);
+      verify(() => mockRepository.watchFeedViewPref(any())).called(1);
     });
 
     test('threadViewPrefProvider calls repository watch method', () {
       const expectedPref = ThreadViewPref.defaultPref;
       when(
-        () => mockRepository.watchThreadViewPref(),
+        () => mockRepository.watchThreadViewPref(any()),
       ).thenAnswer((_) => Stream.value(expectedPref));
 
       container.listen(threadViewPrefProvider, (prev, next) {});
 
-      verify(() => mockRepository.watchThreadViewPref()).called(1);
+      verify(() => mockRepository.watchThreadViewPref(any())).called(1);
     });
 
     test('mutedWordsPrefProvider calls repository watch method', () {
       const expectedPref = MutedWordsPref.empty;
       when(
-        () => mockRepository.watchMutedWordsPref(),
+        () => mockRepository.watchMutedWordsPref(any()),
       ).thenAnswer((_) => Stream.value(expectedPref));
 
       container.listen(mutedWordsPrefProvider, (prev, next) {});
 
-      verify(() => mockRepository.watchMutedWordsPref()).called(1);
+      verify(() => mockRepository.watchMutedWordsPref(any())).called(1);
     });
   });
 }

test/src/features/settings/presentation/screens/content_moderation_screen_test.dart

···
     mockRepository = MockBlueskyPreferencesRepository();
 
     when(
-      () => mockRepository.watchAdultContentPref(),
+      () => mockRepository.watchAdultContentPref(any()),
     ).thenAnswer((_) => Stream.value(const AdultContentPref(enabled: false)));
     when(
-      () => mockRepository.watchContentLabelPrefs(),
+      () => mockRepository.watchContentLabelPrefs(any()),
     ).thenAnswer((_) => Stream.value(ContentLabelPrefs.empty));
     when(
-      () => mockRepository.watchLabelersPref(),
+      () => mockRepository.watchLabelersPref(any()),
     ).thenAnswer((_) => Stream.value(LabelersPref.empty));
-    when(() => mockRepository.updateAdultContentPref(any())).thenAnswer((_) async {});
-    when(() => mockRepository.updateContentLabelPrefs(any())).thenAnswer((_) async {});
+    when(() => mockRepository.updateAdultContentPref(any(), any())).thenAnswer((_) async {});
+    when(() => mockRepository.updateContentLabelPrefs(any(), any())).thenAnswer((_) async {});
   });
 
   setUpAll(() {
···
     ContentLabelPrefs labelPrefs = ContentLabelPrefs.empty,
     LabelersPref labelersPref = LabelersPref.empty,
   }) {
-    when(() => mockRepository.watchAdultContentPref()).thenAnswer((_) => Stream.value(adultPref));
+    when(
+      () => mockRepository.watchAdultContentPref(any()),
+    ).thenAnswer((_) => Stream.value(adultPref));
     when(
-      () => mockRepository.watchContentLabelPrefs(),
+      () => mockRepository.watchContentLabelPrefs(any()),
     ).thenAnswer((_) => Stream.value(labelPrefs));
-    when(() => mockRepository.watchLabelersPref()).thenAnswer((_) => Stream.value(labelersPref));
+    when(
+      () => mockRepository.watchLabelersPref(any()),
+    ).thenAnswer((_) => Stream.value(labelersPref));
 
     return ProviderScope(
       overrides: [
         blueskyPreferencesRepositoryProvider.overrideWithValue(mockRepository),
-        adultContentPrefProvider.overrideWith((ref) => mockRepository.watchAdultContentPref()),
-        contentLabelPrefsProvider.overrideWith((ref) => mockRepository.watchContentLabelPrefs()),
-        labelersPrefProvider.overrideWith((ref) => mockRepository.watchLabelersPref()),
+        adultContentPrefProvider.overrideWith(
+          (ref) => mockRepository.watchAdultContentPref(any()),
+        ),
+        contentLabelPrefsProvider.overrideWith(
+          (ref) => mockRepository.watchContentLabelPrefs(any()),
+        ),
+        labelersPrefProvider.overrideWith((ref) => mockRepository.watchLabelersPref(any())),
       ],
       child: const MaterialApp(home: ContentModerationScreen()),
     );
···
       verify(
         () => mockRepository.updateAdultContentPref(
           any(that: predicate<AdultContentPref>((p) => p.enabled == true)),
+          any(),
         ),
       ).called(1);
     });
···
       await tester.tap(hideButtons.first);
       await tester.pumpAndSettle();
 
-      verify(() => mockRepository.updateContentLabelPrefs(any())).called(1);
+      verify(() => mockRepository.updateContentLabelPrefs(any(), any())).called(1);
     });
 
     testWidgets('shows current label preferences', (tester) async {

test/src/features/settings/presentation/screens/feed_preferences_screen_test.dart

···
     mockRepository = MockBlueskyPreferencesRepository();
 
     when(
-      () => mockRepository.watchFeedViewPref(),
+      () => mockRepository.watchFeedViewPref(any()),
     ).thenAnswer((_) => Stream.value(FeedViewPref.defaultPref));
     when(
-      () => mockRepository.watchThreadViewPref(),
+      () => mockRepository.watchThreadViewPref(any()),
     ).thenAnswer((_) => Stream.value(ThreadViewPref.defaultPref));
-    when(() => mockRepository.updateFeedViewPref(any())).thenAnswer((_) async {});
-    when(() => mockRepository.updateThreadViewPref(any())).thenAnswer((_) async {});
+    when(() => mockRepository.updateFeedViewPref(any(), any())).thenAnswer((_) async {});
+    when(() => mockRepository.updateThreadViewPref(any(), any())).thenAnswer((_) async {});
   });
 
   setUpAll(() {
···
     FeedViewPref feedPref = FeedViewPref.defaultPref,
     ThreadViewPref threadPref = ThreadViewPref.defaultPref,
   }) {
-    when(() => mockRepository.watchFeedViewPref()).thenAnswer((_) => Stream.value(feedPref));
-    when(() => mockRepository.watchThreadViewPref()).thenAnswer((_) => Stream.value(threadPref));
+    when(() => mockRepository.watchFeedViewPref(any())).thenAnswer((_) => Stream.value(feedPref));
+    when(
+      () => mockRepository.watchThreadViewPref(any()),
+    ).thenAnswer((_) => Stream.value(threadPref));
 
     return ProviderScope(
       overrides: [
         blueskyPreferencesRepositoryProvider.overrideWithValue(mockRepository),
-        feedViewPrefProvider.overrideWith((ref) => mockRepository.watchFeedViewPref()),
-        threadViewPrefProvider.overrideWith((ref) => mockRepository.watchThreadViewPref()),
+        feedViewPrefProvider.overrideWith((ref) => mockRepository.watchFeedViewPref(any())),
+        threadViewPrefProvider.overrideWith((ref) => mockRepository.watchThreadViewPref(any())),
       ],
       child: const MaterialApp(home: FeedPreferencesScreen()),
     );
···
       verify(
         () => mockRepository.updateFeedViewPref(
           any(that: predicate<FeedViewPref>((p) => p.hideReplies == true)),
+          any(),
         ),
       ).called(1);
     });
···
       verify(
         () => mockRepository.updateFeedViewPref(
           any(that: predicate<FeedViewPref>((p) => p.hideReposts == true)),
+          any(),
         ),
       ).called(1);
     });
···
       verify(
         () => mockRepository.updateFeedViewPref(
           any(that: predicate<FeedViewPref>((p) => p.hideQuotePosts == true)),
+          any(),
         ),
       ).called(1);
     });
···
       verify(
         () => mockRepository.updateThreadViewPref(
           any(that: predicate<ThreadViewPref>((p) => p.sort == ThreadSortOrder.newest)),
+          any(),
         ),
       ).called(1);
     });
···
       verify(
         () => mockRepository.updateThreadViewPref(
           any(that: predicate<ThreadViewPref>((p) => p.prioritizeFollowedUsers == false)),
+          any(),
         ),
       ).called(1);
     });

test/src/features/settings/presentation/screens/muted_words_screen_test.dart

···
     mockRepository = MockBlueskyPreferencesRepository();
 
     when(
-      () => mockRepository.watchMutedWordsPref(),
+      () => mockRepository.watchMutedWordsPref(any()),
     ).thenAnswer((_) => Stream.value(MutedWordsPref.empty));
-    when(() => mockRepository.updateMutedWordsPref(any())).thenAnswer((_) async {});
+    when(() => mockRepository.updateMutedWordsPref(any(), any())).thenAnswer((_) async {});
   });
 
   setUpAll(() {
···
   });
 
   Widget buildTestWidget({MutedWordsPref pref = MutedWordsPref.empty}) {
-    when(() => mockRepository.watchMutedWordsPref()).thenAnswer((_) => Stream.value(pref));
+    when(() => mockRepository.watchMutedWordsPref(any())).thenAnswer((_) => Stream.value(pref));
 
     return ProviderScope(
       overrides: [
         blueskyPreferencesRepositoryProvider.overrideWithValue(mockRepository),
-        mutedWordsPrefProvider.overrideWith((ref) => mockRepository.watchMutedWordsPref()),
+        mutedWordsPrefProvider.overrideWith((ref) => mockRepository.watchMutedWordsPref(any())),
       ],
       child: const MaterialApp(home: MutedWordsScreen()),
     );

test/src/features/thread/application/thread_notifier_test.dart

···
 
   group('ThreadNotifier', () {
     test('build fetches thread successfully', () async {
-      when(() => mockRepository.getPostThread(postUri)).thenAnswer((_) async => expectedThread);
+      when(
+        () => mockRepository.getPostThread(postUri, any()),
+      ).thenAnswer((_) async => expectedThread);
 
       final result = await container.read(threadProvider(postUri).future);
 
       expect(result, expectedThread);
-      verify(() => mockRepository.getPostThread(postUri)).called(1);
+      verify(() => mockRepository.getPostThread(postUri, any())).called(1);
     });
 
     test('refresh re-fetches thread', () async {
-      when(() => mockRepository.getPostThread(postUri)).thenAnswer((_) async => expectedThread);
+      when(
+        () => mockRepository.getPostThread(postUri, any()),
+      ).thenAnswer((_) async => expectedThread);
 
       await container.read(threadProvider(postUri).future);
 
       await container.read(threadProvider(postUri).notifier).refresh();
 
-      verify(() => mockRepository.getPostThread(postUri)).called(2);
+      verify(() => mockRepository.getPostThread(postUri, any())).called(2);
     });
   });
 }

test/src/features/thread/infrastructure/thread_repository_test.dart

···
         () => mockApi.call(any(), params: any(named: 'params')),
       ).thenAnswer((_) async => mockResponse);
 
-      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1');
+      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1', 'did:1');
 
       verify(
         () => mockApi.call(
···
       expect(thread.replies.first.post.uri, 'at://did:2/app.bsky.feed.post/2');
 
       final cached = await db.feedContentDao
-          .watchFeedContent('thread:at://did:1/app.bsky.feed.post/1')
+          .watchFeedContent('thread:at://did:1/app.bsky.feed.post/1', 'did:1')
           .first;
       expect(cached, hasLength(2));
       expect(
···
         () => mockApi.call(any(), params: any(named: 'params')),
       ).thenAnswer((_) async => mockResponse);
 
-      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1');
+      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1', 'did:1');
       expect(thread.replies, hasLength(2));
       expect(thread.replies.first.post.placeholderReason, 'Post blocked');
       expect(thread.replies.last.post.placeholderReason, 'Post not found');
···
         () => mockApi.call(any(), params: any(named: 'params')),
       ).thenAnswer((_) async => mockResponse);
 
-      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1');
+      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1', 'did:1');
 
       expect(thread.post.viewerLikeUri, 'at://did:viewer/app.bsky.feed.like/abc');
       expect(thread.post.viewerRepostUri, 'at://did:viewer/app.bsky.feed.repost/def');
···
         () => mockApi.call(any(), params: any(named: 'params')),
       ).thenAnswer((_) async => mockResponse);
 
-      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1');
+      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1', 'did:1');
 
       expect(thread.threadgate, isNotNull);
       expect(thread.threadgate!.uri, 'at://did:1/app.bsky.feed.threadgate/1');
···
         () => mockApi.call(any(), params: any(named: 'params')),
       ).thenAnswer((_) async => mockResponse);
 
-      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1');
+      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1', 'did:1');
 
       expect(thread.replies.first.isBlocked, true);
       expect(thread.replies.first.post.isBlocked, true);
···
         () => mockApi.call(any(), params: any(named: 'params')),
       ).thenAnswer((_) async => mockResponse);
 
-      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1');
+      final thread = await repository.getPostThread('at://did:1/app.bsky.feed.post/1', 'did:1');
 
       expect(thread.replies.first.isNotFound, true);
       expect(thread.replies.first.post.isNotFound, true);

test/src/features/thread/presentation/thread_screen_test.dart

···
     const testUri = 'at://did:test/app.bsky.feed.post/1';
 
     testWidgets('renders thread with focal post highlighted', (tester) async {
-      when(() => mockRepo.getPostThread(testUri)).thenAnswer(
+      when(() => mockRepo.getPostThread(testUri, any())).thenAnswer(
         (_) async => ThreadViewPost(
           post: ThreadPost(
             uri: testUri,
···
         ),
       );
 
-      when(() => mockRepo.getPostThread(testUri)).thenAnswer(
+      when(() => mockRepo.getPostThread(testUri, any())).thenAnswer(
         (_) async => ThreadViewPost(
           post: ThreadPost(
             uri: testUri,
···
     });
 
     testWidgets('renders replies correctly', (tester) async {
-      when(() => mockRepo.getPostThread(testUri)).thenAnswer(
+      when(() => mockRepo.getPostThread(testUri, any())).thenAnswer(
         (_) async => ThreadViewPost(
           post: ThreadPost(
             uri: testUri,
···
     });
 
     testWidgets('displays BlockedPostCard for blocked posts', (tester) async {
-      when(() => mockRepo.getPostThread(testUri)).thenAnswer(
+      when(() => mockRepo.getPostThread(testUri, any())).thenAnswer(
         (_) async => ThreadViewPost(
           post: ThreadPost(
             uri: testUri,
···
     });
 
     testWidgets('displays NotFoundPostCard for deleted posts', (tester) async {
-      when(() => mockRepo.getPostThread(testUri)).thenAnswer(
+      when(() => mockRepo.getPostThread(testUri, any())).thenAnswer(
         (_) async => ThreadViewPost(
           post: ThreadPost(
             uri: testUri,
···
     });
 
     testWidgets('displays ThreadgateIndicator when threadgate is present', (tester) async {
-      when(() => mockRepo.getPostThread(testUri)).thenAnswer(
+      when(() => mockRepo.getPostThread(testUri, any())).thenAnswer(
         (_) async => ThreadViewPost(
           post: ThreadPost(
             uri: testUri,
···
     });
 
     testWidgets('toggles between tree and flattened view', (tester) async {
-      when(() => mockRepo.getPostThread(testUri)).thenAnswer(
+      when(() => mockRepo.getPostThread(testUri, any())).thenAnswer(
         (_) async => ThreadViewPost(
           post: ThreadPost(
             uri: testUri,

test/src/infrastructure/db/daos/bluesky_preferences_dao_test.dart

···
 void main() {
   late AppDatabase db;
   late BlueskyPreferencesDao dao;
+  const ownerDid = 'did:web:tester';
 
   setUp(() {
     db = AppDatabase(NativeDatabase.memory());
···
 
   group('getPreferenceByType', () {
     test('returns null for missing type', () async {
-      final result = await dao.getPreferenceByType('nonexistent');
+      final result = await dao.getPreferenceByType('nonexistent', ownerDid);
       expect(result, isNull);
     });
 
···
         type: 'adultContent',
         data: '{"enabled":true}',
         lastSynced: DateTime.now(),
+        ownerDid: ownerDid,
       );
-      final result = await dao.getPreferenceByType('adultContent');
+      final result = await dao.getPreferenceByType('adultContent', ownerDid);
       expect(result, isNotNull);
       expect(result!.type, 'adultContent');
       expect(result.data, '{"enabled":true}');
···
 
   group('upsertPreference', () {
     test('inserts a new preference', () async {
-      await dao.upsertPreference(type: 'contentLabels', data: '[]', lastSynced: DateTime.now());
-      final result = await dao.getPreferenceByType('contentLabels');
+      await dao.upsertPreference(
+        type: 'contentLabels',
+        data: '[]',
+        lastSynced: DateTime.now(),
+        ownerDid: ownerDid,
+      );
+      final result = await dao.getPreferenceByType('contentLabels', ownerDid);
       expect(result, isNotNull);
       expect(result!.data, '[]');
     });
···
         type: 'feedView',
         data: '{"hideReplies":false}',
         lastSynced: firstSync,
+        ownerDid: ownerDid,
       );
       await dao.upsertPreference(
         type: 'feedView',
         data: '{"hideReplies":true}',
         lastSynced: secondSync,
+        ownerDid: ownerDid,
       );
 
-      final result = await dao.getPreferenceByType('feedView');
+      final result = await dao.getPreferenceByType('feedView', ownerDid);
       expect(result, isNotNull);
       expect(result!.data, '{"hideReplies":true}');
       expect(result.lastSynced, secondSync);
···
 
   group('getAllPreferences', () {
     test('returns empty list when no preferences exist', () async {
-      final result = await dao.getAllPreferences();
+      final result = await dao.getAllPreferences(ownerDid);
       expect(result, isEmpty);
     });
 
     test('returns all stored preferences', () async {
       final now = DateTime.now();
-      await dao.upsertPreference(type: 'adultContent', data: '{"enabled":false}', lastSynced: now);
-      await dao.upsertPreference(type: 'threadView', data: '{"sort":"oldest"}', lastSynced: now);
+      await dao.upsertPreference(
+        type: 'adultContent',
+        data: '{"enabled":false}',
+        lastSynced: now,
+        ownerDid: ownerDid,
+      );
+      await dao.upsertPreference(
+        type: 'threadView',
+        data: '{"sort":"oldest"}',
+        lastSynced: now,
+        ownerDid: ownerDid,
+      );
 
-      final result = await dao.getAllPreferences();
+      final result = await dao.getAllPreferences(ownerDid);
       expect(result, hasLength(2));
       expect(result.map((p) => p.type), containsAll(['adultContent', 'threadView']));
     });
···
 
   group('watchPreferenceByType', () {
     test('emits null for missing type', () async {
-      final result = await dao.watchPreferenceByType('nonexistent').first;
+      final result = await dao.watchPreferenceByType('nonexistent', ownerDid).first;
       expect(result, isNull);
     });
 
···
         type: 'labelers',
         data: '{"labelers":[]}',
         lastSynced: DateTime.now(),
+        ownerDid: ownerDid,
       );
-      final result = await dao.watchPreferenceByType('labelers').first;
+      final result = await dao.watchPreferenceByType('labelers', ownerDid).first;
       expect(result, isNotNull);
       expect(result!.type, 'labelers');
     });
···
         type: 'mutedWords',
         data: '{"items":[]}',
         lastSynced: DateTime.now(),
+        ownerDid: ownerDid,
       );
 
       final emissions = <String?>[];
       final subscription = dao
-          .watchPreferenceByType('mutedWords')
+          .watchPreferenceByType('mutedWords', ownerDid)
           .listen((pref) => emissions.add(pref?.data));
 
       await Future<void>.delayed(const Duration(milliseconds: 50));
···
         type: 'mutedWords',
         data: '{"items":[{"id":"1","value":"test"}]}',
         lastSynced: DateTime.now(),
+        ownerDid: ownerDid,
       );
       await Future<void>.delayed(const Duration(milliseconds: 50));
       await subscription.cancel();
···
 
   group('watchAllPreferences', () {
     test('emits empty list initially', () async {
-      final result = await dao.watchAllPreferences().first;
+      final result = await dao.watchAllPreferences(ownerDid).first;
       expect(result, isEmpty);
     });
 
     test('emits updates when preferences are added', () async {
       final emissions = <int>[];
-      final subscription = dao.watchAllPreferences().listen(
-        (prefs) => emissions.add(prefs.length),
-      );
+      final subscription = dao
+          .watchAllPreferences(ownerDid)
+          .listen((prefs) => emissions.add(prefs.length));
 
       await Future<void>.delayed(const Duration(milliseconds: 50));
-      await dao.upsertPreference(type: 'adultContent', data: '{}', lastSynced: DateTime.now());
+      await dao.upsertPreference(
+        type: 'adultContent',
+        data: '{}',
+        lastSynced: DateTime.now(),
+        ownerDid: ownerDid,
+      );
       await Future<void>.delayed(const Duration(milliseconds: 50));
       await subscription.cancel();
 
···
 
   group('deletePreference', () {
     test('removes a preference by type', () async {
-      await dao.upsertPreference(type: 'feedView', data: '{}', lastSynced: DateTime.now());
+      await dao.upsertPreference(
+        type: 'feedView',
+        data: '{}',
+        lastSynced: DateTime.now(),
+        ownerDid: ownerDid,
+      );
 
-      final deleted = await dao.deletePreference('feedView');
+      final deleted = await dao.deletePreference('feedView', ownerDid);
       expect(deleted, 1);
 
-      final result = await dao.getPreferenceByType('feedView');
+      final result = await dao.getPreferenceByType('feedView', ownerDid);
       expect(result, isNull);
     });
 
     test('returns 0 when type does not exist', () async {
-      final deleted = await dao.deletePreference('nonexistent');
+      final deleted = await dao.deletePreference('nonexistent', ownerDid);
       expect(deleted, 0);
     });
   });
···
   group('clearAll', () {
     test('removes all preferences', () async {
       final now = DateTime.now();
-      await dao.upsertPreference(type: 'type1', data: '{}', lastSynced: now);
-      await dao.upsertPreference(type: 'type2', data: '{}', lastSynced: now);
-      await dao.upsertPreference(type: 'type3', data: '{}', lastSynced: now);
+      await dao.upsertPreference(type: 'type1', data: '{}', lastSynced: now, ownerDid: ownerDid);
+      await dao.upsertPreference(type: 'type2', data: '{}', lastSynced: now, ownerDid: ownerDid);
+      await dao.upsertPreference(type: 'type3', data: '{}', lastSynced: now, ownerDid: ownerDid);
 
-      final cleared = await dao.clearAll();
+      final cleared = await dao.clearAll(ownerDid);
       expect(cleared, 3);
 
-      final result = await dao.getAllPreferences();
+      final result = await dao.getAllPreferences(ownerDid);
       expect(result, isEmpty);
     });
 
     test('returns 0 when no preferences exist', () async {
-      final cleared = await dao.clearAll();
+      final cleared = await dao.clearAll(ownerDid);
       expect(cleared, 0);
     });
   });

test/src/infrastructure/db/daos/dm_convos_dao_test.dart

···
 void main() {
   late AppDatabase database;
   late DmConvosDao dao;
+  const ownerDid = 'did:web:tester';
 
   setUp(() {
     database = AppDatabase(NativeDatabase.memory());
···
             lastMessageText: const Value('Hello!'),
             lastMessageAt: Value(DateTime.now()),
             cachedAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         ];
 
         await dao.insertConvosBatch(newConvos: convos, newProfiles: profiles);
 
-        final results = await dao.watchConversations().first;
+        final results = await dao.watchConversations(ownerDid).first;
         expect(results, hasLength(1));
         expect(results.first.convo.convoId, 'convo1');
         expect(results.first.convo.lastMessageText, 'Hello!');
···
           lastMessageText: const Value('First message'),
           unreadCount: const Value(1),
           cachedAt: DateTime.now(),
+          ownerDid: ownerDid,
         );
 
         await dao.insertConvosBatch(newConvos: [convo1], newProfiles: profiles);
···
           lastMessageText: const Value('Updated message'),
           unreadCount: const Value(3),
           cachedAt: DateTime.now(),
+          ownerDid: ownerDid,
         );
 
         await dao.insertConvosBatch(newConvos: [convo2], newProfiles: profiles);
 
-        final results = await dao.watchConversations().first;
+        final results = await dao.watchConversations(ownerDid).first;
         expect(results, hasLength(1));
         expect(results.first.convo.lastMessageText, 'Updated message');
         expect(results.first.convo.unreadCount, 3);
···
             membersJson: '["did:plc:member1"]',
             lastMessageAt: Value(now.subtract(const Duration(hours: 2))),
             cachedAt: now,
+            ownerDid: ownerDid,
           ),
           DmConvosCompanion.insert(
             convoId: 'convo2',
             membersJson: '["did:plc:member1"]',
             lastMessageAt: Value(now),
             cachedAt: now,
+            ownerDid: ownerDid,
           ),
           DmConvosCompanion.insert(
             convoId: 'convo3',
             membersJson: '["did:plc:member1"]',
             lastMessageAt: Value(now.subtract(const Duration(hours: 1))),
             cachedAt: now,
+            ownerDid: ownerDid,
           ),
         ];
 
         await dao.insertConvosBatch(newConvos: convos, newProfiles: profiles);
 
-        final results = await dao.watchConversations().first;
+        final results = await dao.watchConversations(ownerDid).first;
         expect(results, hasLength(3));
         expect(results[0].convo.convoId, 'convo2');
         expect(results[1].convo.convoId, 'convo3');
···
               convoId: 'convo1',
               membersJson: '["did:plc:member1"]',
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
           ],
           newProfiles: profiles,
         );
 
-        final result = await dao.getConvo('convo1');
+        final result = await dao.getConvo('convo1', ownerDid);
         expect(result, isNotNull);
         expect(result!.convo.convoId, 'convo1');
       });
 
       test('returns null for non-existent conversation', () async {
-        final result = await dao.getConvo('nonexistent');
+        final result = await dao.getConvo('nonexistent', ownerDid);
         expect(result, isNull);
       });
     });
···
               membersJson: '["did:plc:member1"]',
               unreadCount: const Value(5),
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
           ],
           newProfiles: profiles,
         );
 
-        await dao.updateReadState(convoId: 'convo1', lastReadMessageId: 'msg123', unreadCount: 0);
+        await dao.updateReadState(
+          convoId: 'convo1',
+          lastReadMessageId: 'msg123',
+          unreadCount: 0,
+          ownerDid: ownerDid,
+        );
 
-        final result = await dao.getConvo('convo1');
+        final result = await dao.getConvo('convo1', ownerDid);
         expect(result!.convo.lastReadMessageId, 'msg123');
         expect(result.convo.unreadCount, 0);
       });
···
               membersJson: '["did:plc:member1"]',
               isAccepted: const Value(false),
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
           ],
           newProfiles: profiles,
         );
 
-        await dao.acceptConvo('convo1');
+        await dao.acceptConvo('convo1', ownerDid);
 
-        final result = await dao.getConvo('convo1');
+        final result = await dao.getConvo('convo1', ownerDid);
         expect(result!.convo.isAccepted, isTrue);
       });
     });
···
               convoId: 'convo1',
               membersJson: '["did:plc:member1"]',
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
             DmConvosCompanion.insert(
               convoId: 'convo2',
               membersJson: '["did:plc:member1"]',
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
           ],
           newProfiles: profiles,
         );
 
-        await dao.clearConversations();
+        await dao.clearConversations(ownerDid);
 
-        final results = await dao.watchConversations().first;
+        final results = await dao.watchConversations(ownerDid).first;
         expect(results, isEmpty);
       });
     });

test/src/infrastructure/db/daos/dm_messages_dao_test.dart

···
 void main() {
   late AppDatabase database;
   late DmMessagesDao dao;
+  const ownerDid = 'did:web:tester';
 
   setUp(() {
     database = AppDatabase(NativeDatabase.memory());
···
             sentAt: DateTime.now(),
             status: 'sent',
             cachedAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         ];
 
         await dao.insertMessagesBatch(newMessages: messages, newProfiles: profiles);
 
-        final results = await dao.watchMessagesByConvo('convo1').first;
+        final results = await dao.watchMessagesByConvo('convo1', ownerDid).first;
         expect(results, hasLength(1));
         expect(results.first.message.content, 'Hello!');
         expect(results.first.sender.handle, 'sender1.bsky.social');
···
           sentAt: DateTime.now(),
           status: 'pending',
           cachedAt: DateTime.now(),
+          ownerDid: ownerDid,
         );
 
         await dao.insertMessagesBatch(newMessages: [msg1], newProfiles: profiles);
···
           sentAt: DateTime.now(),
           status: 'sent',
           cachedAt: DateTime.now(),
+          ownerDid: ownerDid,
         );
 
         await dao.insertMessagesBatch(newMessages: [msg2], newProfiles: profiles);
 
-        final results = await dao.watchMessagesByConvo('convo1').first;
+        final results = await dao.watchMessagesByConvo('convo1', ownerDid).first;
         expect(results, hasLength(1));
         expect(results.first.message.content, 'Updated');
         expect(results.first.message.status, 'sent');
···
             sentAt: now,
             status: 'sent',
             cachedAt: now,
+            ownerDid: ownerDid,
           ),
           DmMessagesCompanion.insert(
             messageId: 'msg1',
···
             sentAt: now.subtract(const Duration(hours: 2)),
             status: 'sent',
             cachedAt: now,
+            ownerDid: ownerDid,
           ),
           DmMessagesCompanion.insert(
             messageId: 'msg2',
···
             sentAt: now.subtract(const Duration(hours: 1)),
             status: 'sent',
             cachedAt: now,
+            ownerDid: ownerDid,
           ),
         ];
 
         await dao.insertMessagesBatch(newMessages: messages, newProfiles: profiles);
 
-        final results = await dao.watchMessagesByConvo('convo1').first;
+        final results = await dao.watchMessagesByConvo('convo1', ownerDid).first;
         expect(results, hasLength(3));
         expect(results[0].message.content, 'First');
         expect(results[1].message.content, 'Second');
···
               sentAt: DateTime.now(),
               status: 'sent',
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
             DmMessagesCompanion.insert(
               messageId: 'msg2',
···
               sentAt: DateTime.now(),
               status: 'sent',
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
           ],
           newProfiles: profiles,
         );
 
-        final results = await dao.watchMessagesByConvo('convo1').first;
+        final results = await dao.watchMessagesByConvo('convo1', ownerDid).first;
         expect(results, hasLength(1));
         expect(results.first.message.content, 'Convo 1 message');
       });
···
               sentAt: DateTime.now(),
               status: 'pending',
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
           ],
           newProfiles: profiles,
         );
 
-        await dao.updateMessageStatus(messageId: 'msg1', status: 'sent');
+        await dao.updateMessageStatus(messageId: 'msg1', status: 'sent', ownerDid: ownerDid);
 
-        final results = await dao.watchMessagesByConvo('convo1').first;
+        final results = await dao.watchMessagesByConvo('convo1', ownerDid).first;
         expect(results.first.message.status, 'sent');
       });
     });
···
               sentAt: now.subtract(const Duration(hours: 1)),
               status: 'sent',
               cachedAt: now,
+              ownerDid: ownerDid,
             ),
             DmMessagesCompanion.insert(
               messageId: 'msg2',
···
               sentAt: now,
               status: 'sent',
               cachedAt: now,
+              ownerDid: ownerDid,
             ),
           ],
           newProfiles: profiles,
         );
 
-        final result = await dao.getLatestMessage('convo1');
+        final result = await dao.getLatestMessage('convo1', ownerDid);
         expect(result, isNotNull);
         expect(result!.content, 'Latest');
       });
 
       test('returns null for empty conversation', () async {
-        final result = await dao.getLatestMessage('nonexistent');
+        final result = await dao.getLatestMessage('nonexistent', ownerDid);
         expect(result, isNull);
       });
     });
···
               sentAt: DateTime.now(),
               status: 'sent',
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
             DmMessagesCompanion.insert(
               messageId: 'msg2',
···
               sentAt: DateTime.now(),
               status: 'sent',
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
             DmMessagesCompanion.insert(
               messageId: 'msg3',
···
               sentAt: DateTime.now(),
               status: 'sent',
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
           ],
           newProfiles: profiles,
         );
 
-        final deletedCount = await dao.deleteMessagesByConvo('convo1');
+        final deletedCount = await dao.deleteMessagesByConvo('convo1', ownerDid);
         expect(deletedCount, 2);
 
-        final convo1Results = await dao.watchMessagesByConvo('convo1').first;
+        final convo1Results = await dao.watchMessagesByConvo('convo1', ownerDid).first;
         expect(convo1Results, isEmpty);
 
-        final convo2Results = await dao.watchMessagesByConvo('convo2').first;
+        final convo2Results = await dao.watchMessagesByConvo('convo2', ownerDid).first;
         expect(convo2Results, hasLength(1));
       });
     });
···
               sentAt: DateTime.now(),
               status: 'sent',
               cachedAt: DateTime.now(),
+              ownerDid: ownerDid,
             ),
           ],
           newProfiles: profiles,
         );
 
-        await dao.clearMessages();
+        await dao.clearMessages(ownerDid);
 
-        final results = await dao.watchMessagesByConvo('convo1').first;
+        final results = await dao.watchMessagesByConvo('convo1', ownerDid).first;
         expect(results, isEmpty);
       });
     });

test/src/infrastructure/db/daos/dm_outbox_dao_test.dart

···
 void main() {
   late AppDatabase database;
   late DmOutboxDao dao;
+  const ownerDid = 'did:web:tester';
 
   setUp(() {
     database = AppDatabase(NativeDatabase.memory());
···
             messageText: 'Hello!',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
-        final pending = await dao.getPending();
+        final pending = await dao.getPending(ownerDid);
         expect(pending, hasLength(1));
         expect(pending.first.outboxId, 'outbox1');
         expect(pending.first.messageText, 'Hello!');
···
             messageText: 'Second',
             status: 'pending',
             createdAt: now,
+            ownerDid: ownerDid,
           ),
         );
         await dao.enqueue(
···
             messageText: 'First',
             status: 'pending',
             createdAt: now.subtract(const Duration(minutes: 1)),
+            ownerDid: ownerDid,
           ),
         );
 
-        final pending = await dao.getPending();
+        final pending = await dao.getPending(ownerDid);
         expect(pending, hasLength(2));
         expect(pending[0].outboxId, 'outbox1');
         expect(pending[1].outboxId, 'outbox2');
···
             messageText: 'Pending',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
         await dao.enqueue(
···
             messageText: 'Failed',
             status: 'failed',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
-        final pending = await dao.getPending();
+        final pending = await dao.getPending(ownerDid);
         expect(pending, hasLength(1));
         expect(pending.first.outboxId, 'outbox1');
       });
···
             messageText: 'Pending',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
         await dao.enqueue(
···
             messageText: 'Failed',
             status: 'failed',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
-        final failed = await dao.getFailed();
+        final failed = await dao.getFailed(ownerDid);
         expect(failed, hasLength(1));
         expect(failed.first.outboxId, 'outbox2');
       });
···
             messageText: 'Test',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
···
             messageText: 'Pending',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
         await dao.enqueue(
···
             messageText: 'Sending',
             status: 'sending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
         await dao.enqueue(
···
             messageText: 'Other convo',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
-        final results = await dao.getByConvo('convo1');
+        final results = await dao.getByConvo('convo1', ownerDid);
         expect(results, hasLength(2));
       });
     });
···
             messageText: 'Test',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
···
             messageText: 'Test',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
···
             status: 'pending',
             retryCount: const Value(0),
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
···
             messageText: 'Test',
             status: 'failed',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
         await dao.updateStatus(outboxId: 'outbox1', status: 'failed', errorMessage: 'Error');
···
             messageText: 'Test',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
···
             messageText: 'Pending 1',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
         await dao.enqueue(
···
             messageText: 'Pending 2',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
         await dao.enqueue(
···
             messageText: 'Failed',
             status: 'failed',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
-        final count = await dao.countPending();
+        final count = await dao.countPending(ownerDid);
         expect(count, 2);
       });
     });
···
             messageText: 'Test',
             status: 'pending',
             createdAt: DateTime.now(),
+            ownerDid: ownerDid,
           ),
         );
 
-        await dao.clearOutbox();
+        await dao.clearOutbox(ownerDid);
 
-        final pending = await dao.getPending();
+        final pending = await dao.getPending(ownerDid);
         expect(pending, isEmpty);
       });
     });

test/src/infrastructure/db/daos/notifications_dao_test.dart

···
 void main() {
   late AppDatabase database;
   late NotificationsDao dao;
+  const ownerDid = 'did:plc:owner';
 
   setUp(() {
     database = AppDatabase(NativeDatabase.memory());
···
           NotificationsCompanion.insert(
             uri: 'at://did:plc:user/app.bsky.notification/1',
             actorDid: 'did:plc:actor1',
+            ownerDid: ownerDid,
             type: 'like',
             indexedAt: DateTime.now(),
             cachedAt: DateTime.now(),
           ),
         ];
 
-        await dao.insertNotificationsBatch(newNotifications: notifications, newProfiles: profiles);
+        await dao.insertNotificationsBatch(
+          newNotifications: notifications,
+          newProfiles: profiles,
+          newCursor: null,
+          ownerDid: ownerDid,
+        );
 
-        final results = await dao.watchNotifications().first;
+        final results = await dao.watchNotifications(ownerDid).first;
         expect(results, hasLength(1));
         expect(results.first.notification.type, 'like');
         expect(results.first.actor.handle, 'actor1.bsky.social');
···
           newNotifications: [],
           newProfiles: [],
           newCursor: 'cursor123',
+          ownerDid: ownerDid,
         );
 
-        final cursor = await dao.getCursor();
+        final cursor = await dao.getCursor(ownerDid);
         expect(cursor, 'cursor123');
       });
 
···
         final notification1 = NotificationsCompanion.insert(
           uri: 'at://did:plc:user/app.bsky.notification/1',
           actorDid: 'did:plc:actor1',
+          ownerDid: ownerDid,
           type: 'like',
           isRead: const Value(false),
           indexedAt: DateTime.now(),
···
         await dao.insertNotificationsBatch(
           newNotifications: [notification1],
           newProfiles: profiles,
+          newCursor: null,
+          ownerDid: ownerDid,
         );
 
         final notification2 = NotificationsCompanion.insert(
           uri: 'at://did:plc:user/app.bsky.notification/1',
           actorDid: 'did:plc:actor1',
+          ownerDid: ownerDid,
           type: 'like',
           isRead: const Value(true),
           indexedAt: DateTime.now(),
···
         await dao.insertNotificationsBatch(
           newNotifications: [notification2],
           newProfiles: profiles,
+          newCursor: null,
+          ownerDid: ownerDid,
         );
 
-        final results = await dao.watchNotifications().first;
+        final results = await dao.watchNotifications(ownerDid).first;
         expect(results, hasLength(1));
         expect(results.first.notification.isRead, isTrue);
       });
···
           NotificationsCompanion.insert(
             uri: 'at://did:plc:user/app.bsky.notification/1',
             actorDid: 'did:plc:actor1',
+            ownerDid: ownerDid,
             type: 'like',
             indexedAt: now.subtract(const Duration(hours: 2)),
             cachedAt: now,
···
           NotificationsCompanion.insert(
             uri: 'at://did:plc:user/app.bsky.notification/2',
             actorDid: 'did:plc:actor1',
+            ownerDid: ownerDid,
             type: 'follow',
             indexedAt: now.subtract(const Duration(hours: 1)),
             cachedAt: now,
···
           NotificationsCompanion.insert(
             uri: 'at://did:plc:user/app.bsky.notification/3',
             actorDid: 'did:plc:actor1',
+            ownerDid: ownerDid,
             type: 'repost',
             indexedAt: now,
             cachedAt: now,
           ),
         ];
 
-        await dao.insertNotificationsBatch(newNotifications: notifications, newProfiles: profiles);
+        await dao.insertNotificationsBatch(
+          newNotifications: notifications,
+          newProfiles: profiles,
+          newCursor: null,
+          ownerDid: ownerDid,
+        );
 
-        final results = await dao.watchNotifications().first;
+        final results = await dao.watchNotifications(ownerDid).first;
         expect(results, hasLength(3));
         expect(results[0].notification.type, 'repost'); // Most recent
         expect(results[1].notification.type, 'follow');
···
           ProfilesCompanion.insert(did: 'did:plc:actor1', handle: 'actor1.bsky.social'),
         ];
 
-        final stream = dao.watchNotifications();
+        final stream = dao.watchNotifications(ownerDid);
         final emissions = <List<NotificationWithActor>>[];
         final subscription = stream.listen(emissions.add);
 
···
             NotificationsCompanion.insert(
               uri: 'at://did:plc:user/app.bsky.notification/1',
               actorDid: 'did:plc:actor1',
+              ownerDid: ownerDid,
               type: 'like',
               indexedAt: DateTime.now(),
               cachedAt: DateTime.now(),
             ),
           ],
           newProfiles: profiles,
+          newCursor: null,
+          ownerDid: ownerDid,
         );
 
         await Future<void>.delayed(const Duration(milliseconds: 50));
···
 
     group('getCursor', () {
       test('returns null when no cursor exists', () async {
-        final cursor = await dao.getCursor();
+        final cursor = await dao.getCursor(ownerDid);
         expect(cursor, isNull);
       });
 
···
           newNotifications: [],
           newProfiles: [],
           newCursor: 'test_cursor',
+          ownerDid: ownerDid,
         );
 
-        final cursor = await dao.getCursor();
+        final cursor = await dao.getCursor(ownerDid);
         expect(cursor, 'test_cursor');
       });
     });
···
             NotificationsCompanion.insert(
               uri: 'at://did:plc:user/app.bsky.notification/1',
               actorDid: 'did:plc:actor1',
+              ownerDid: ownerDid,
               type: 'like',
               indexedAt: DateTime.now(),
               cachedAt: DateTime.now(),
···
           ],
           newProfiles: profiles,
           newCursor: 'cursor123',
+          ownerDid: ownerDid,
         );
 
-        await dao.clearNotifications();
+        await dao.clearNotifications(ownerDid);
 
-        final results = await dao.watchNotifications().first;
+        final results = await dao.watchNotifications(ownerDid).first;
         expect(results, isEmpty);
 
-        final cursor = await dao.getCursor();
+        final cursor = await dao.getCursor(ownerDid);
         expect(cursor, isNull);
       });
     });
···
             NotificationsCompanion.insert(
               uri: 'at://did:plc:user/app.bsky.notification/old',
               actorDid: 'did:plc:actor1',
+              ownerDid: ownerDid,
               type: 'like',
               indexedAt: stale,
               cachedAt: stale,
···
             NotificationsCompanion.insert(
               uri: 'at://did:plc:user/app.bsky.notification/new',
               actorDid: 'did:plc:actor1',
+              ownerDid: ownerDid,
               type: 'follow',
               indexedAt: fresh,
               cachedAt: fresh,
             ),
           ],
           newProfiles: profiles,
+          newCursor: null,
+          ownerDid: ownerDid,
         );
 
         final threshold = now.subtract(const Duration(days: 30));
-        final deletedCount = await dao.deleteStaleNotifications(threshold);
+        final deletedCount = await dao.deleteStaleNotifications(threshold, ownerDid);
 
         expect(deletedCount, 1);
 
-        final results = await dao.watchNotifications().first;
+        final results = await dao.watchNotifications(ownerDid).first;
         expect(results, hasLength(1));
         expect(results.first.notification.type, 'follow');
       });
···
             NotificationsCompanion.insert(
               uri: 'at://did:plc:user/app.bsky.notification/1',
               actorDid: 'did:plc:actor1',
+              ownerDid: ownerDid,
               type: 'like',
               isRead: const Value(false),
               indexedAt: DateTime.now(),
···
             NotificationsCompanion.insert(
               uri: 'at://did:plc:user/app.bsky.notification/2',
               actorDid: 'did:plc:actor1',
+              ownerDid: ownerDid,
               type: 'follow',
               isRead: const Value(false),
               indexedAt: DateTime.now(),
···
             ),
           ],
           newProfiles: profiles,
+          newCursor: null,
+          ownerDid: ownerDid,
         );
 
-        await dao.markAllAsRead();
+        await dao.markAllAsRead(ownerDid);
 
-        final results = await dao.watchNotifications().first;
+        final results = await dao.watchNotifications(ownerDid).first;
         expect(results, hasLength(2));
         expect(results.every((n) => n.notification.isRead), isTrue);
       });

test/src/infrastructure/db/daos/notifications_sync_queue_dao_test.dart

···
   group('NotificationsSyncQueueDao', () {
     late AppDatabase db;
     late NotificationsSyncQueueDao dao;
+    const ownerDid = 'did:web:tester';
 
     setUp(() {
       db = AppDatabase(NativeDatabase.memory());
···
 
     test('enqueueMarkSeen adds item to queue', () async {
       final now = DateTime.now();
-      await dao.enqueueMarkSeen(now);
+      await dao.enqueueMarkSeen(now, ownerDid);
 
-      final pending = await dao.getRetryableItems();
+      final pending = await dao.getRetryableItems(ownerDid);
       expect(pending.length, 1);
       expect(pending.first.type, 'mark_seen');
       expect(pending.first.seenAt, now.toIso8601String());
···
       final now = DateTime.now();
       final earlier = now.subtract(const Duration(hours: 1));
 
-      await dao.enqueueMarkSeen(earlier);
-      await dao.enqueueMarkSeen(now);
+      await dao.enqueueMarkSeen(earlier, ownerDid);
+      await dao.enqueueMarkSeen(now, ownerDid);
 
-      final pending = await dao.getRetryableItems();
+      final pending = await dao.getRetryableItems(ownerDid);
       expect(pending.length, 2);
       expect(DateTime.parse(pending[0].seenAt), earlier);
       expect(DateTime.parse(pending[1].seenAt), now);
···
       final earlier = now.subtract(const Duration(hours: 1));
       final earliest = now.subtract(const Duration(hours: 2));
 
-      await dao.enqueueMarkSeen(earliest);
-      await dao.enqueueMarkSeen(earlier);
-      await dao.enqueueMarkSeen(now);
+      await dao.enqueueMarkSeen(earliest, ownerDid);
+      await dao.enqueueMarkSeen(earlier, ownerDid);
+      await dao.enqueueMarkSeen(now, ownerDid);
 
-      final latest = await dao.getLatestSeenAt();
+      final latest = await dao.getLatestSeenAt(ownerDid);
       expect(latest, now);
     });
 
     test('getLatestSeenAt returns null when queue is empty', () async {
-      final latest = await dao.getLatestSeenAt();
+      final latest = await dao.getLatestSeenAt(ownerDid);
       expect(latest, null);
     });
 
···
       final now = DateTime.now();
       final older = now.subtract(const Duration(hours: 1));
 
-      await dao.enqueueMarkSeen(older);
+      await dao.enqueueMarkSeen(older, ownerDid);
 
       await db
           .into(db.notificationsSyncQueue)
···
               seenAt: now.toIso8601String(),
               createdAt: DateTime.now(),
               retryCount: const Value(kMaxNotificationSyncRetries),
+              ownerDid: ownerDid,
             ),
           );
 
-      final latest = await dao.getLatestSeenAt();
+      final latest = await dao.getLatestSeenAt(ownerDid);
       expect(latest, older);
     });
 
     test('deleteItem removes specific item', () async {
       final now = DateTime.now();
-      await dao.enqueueMarkSeen(now);
+      await dao.enqueueMarkSeen(now, ownerDid);
 
-      var pending = await dao.getRetryableItems();
+      var pending = await dao.getRetryableItems(ownerDid);
       final id = pending.first.id;
 
       await dao.deleteItem(id);
 
-      pending = await dao.getRetryableItems();
+      pending = await dao.getRetryableItems(ownerDid);
       expect(pending, isEmpty);
     });
 
···
       final earliest = now.subtract(const Duration(hours: 2));
       final later = now.add(const Duration(hours: 1));
 
-      await dao.enqueueMarkSeen(earliest);
-      await dao.enqueueMarkSeen(earlier);
-      await dao.enqueueMarkSeen(now);
-      await dao.enqueueMarkSeen(later);
+      await dao.enqueueMarkSeen(earliest, ownerDid);
+      await dao.enqueueMarkSeen(earlier, ownerDid);
+      await dao.enqueueMarkSeen(now, ownerDid);
+      await dao.enqueueMarkSeen(later, ownerDid);
 
-      await dao.deleteItemsUpTo(now);
+      await dao.deleteItemsUpTo(now, ownerDid);
 
-      final remaining = await dao.getRetryableItems();
+      final remaining = await dao.getRetryableItems(ownerDid);
       expect(remaining.length, 1);
       expect(DateTime.parse(remaining.first.seenAt), later);
     });
 
     test('clearQueue removes all items', () async {
       final now = DateTime.now();
-      await dao.enqueueMarkSeen(now);
-      await dao.enqueueMarkSeen(now.add(const Duration(hours: 1)));
+      await dao.enqueueMarkSeen(now, ownerDid);
+      await dao.enqueueMarkSeen(now.add(const Duration(hours: 1)), ownerDid);
 
-      await dao.clearQueue();
+      await dao.clearQueue(ownerDid);
 
-      final pending = await dao.getRetryableItems();
+      final pending = await dao.getRetryableItems(ownerDid);
       expect(pending, isEmpty);
     });
 
···
         () async {
           final now = DateTime.now();
 
-          await dao.enqueueMarkSeen(now);
+          await dao.enqueueMarkSeen(now, ownerDid);
 
           await db
               .into(db.notificationsSyncQueue)
···
                   seenAt: now.subtract(const Duration(hours: 1)).toIso8601String(),
                   createdAt: now,
                   retryCount: const Value(4),
+                  ownerDid: ownerDid,
                 ),
               );
 
···
                   seenAt: now.subtract(const Duration(hours: 2)).toIso8601String(),
                   createdAt: now,
                   retryCount: const Value(5),
+                  ownerDid: ownerDid,
                 ),
               );
 
-          final retryable = await dao.getRetryableItems();
+          final retryable = await dao.getRetryableItems(ownerDid);
           expect(retryable.length, 2);
           expect(retryable.map((r) => r.retryCount), containsAll([0, 4]));
         },
···
 
       test('incrementRetryCount updates the retry count', () async {
         final now = DateTime.now();
-        final id = await dao.enqueueMarkSeen(now);
+        final id = await dao.enqueueMarkSeen(now, ownerDid);
 
-        var items = await dao.getRetryableItems();
+        var items = await dao.getRetryableItems(ownerDid);
         expect(items.first.retryCount, 0);
 
         await dao.incrementRetryCount(id);
 
-        items = await dao.getRetryableItems();
+        items = await dao.getRetryableItems(ownerDid);
         expect(items.first.retryCount, 1);
 
         await dao.incrementRetryCount(id);
         await dao.incrementRetryCount(id);
 
-        items = await dao.getRetryableItems();
+        items = await dao.getRetryableItems(ownerDid);
         expect(items.first.retryCount, 3);
       });
 
···
                 seenAt: now.subtract(const Duration(days: 50)).toIso8601String(),
                 createdAt: now.subtract(const Duration(days: 45)),
                 retryCount: const Value(5),
+                ownerDid: ownerDid,
               ),
             );
 
···
                 seenAt: now.subtract(const Duration(days: 50)).toIso8601String(),
                 createdAt: now.subtract(const Duration(days: 45)),
                 retryCount: const Value(3),
+                ownerDid: ownerDid,
               ),
             );
 
···
                 seenAt: now.toIso8601String(),
                 createdAt: now.subtract(const Duration(days: 5)),
                 retryCount: const Value(5),
+                ownerDid: ownerDid,
               ),
             );
 
-        await dao.enqueueMarkSeen(now);
+        await dao.enqueueMarkSeen(now, ownerDid);
 
         final deleted = await dao.cleanupOldFailedItems(threshold);
         expect(deleted, 1);
 
-        final remaining = await dao.getRetryableItems();
+        final remaining = await dao.getRetryableItems(ownerDid);
         expect(remaining.length, 2);
       });
 
       test('cleanupOldFailedItems returns 0 when nothing to clean', () async {
         final now = DateTime.now();
-        await dao.enqueueMarkSeen(now);
+        await dao.enqueueMarkSeen(now, ownerDid);
 
         final deleted = await dao.cleanupOldFailedItems(now.subtract(const Duration(days: 30)));
         expect(deleted, 0);
 
-        final remaining = await dao.getRetryableItems();
+        final remaining = await dao.getRetryableItems(ownerDid);
         expect(remaining.length, 1);
       });
     });

test/src/infrastructure/db/daos/preference_sync_queue_dao_test.dart

···
   group('PreferenceSyncQueueDao', () {
     late AppDatabase db;
     late PreferenceSyncQueueDao dao;
+    const ownerDid = 'did:web:tester';
 
     setUp(() {
       db = AppDatabase(NativeDatabase.memory());
···
           type: 'save',
           payload: 'at://test',
           createdAt: now,
+          ownerDid: ownerDid,
         ),
       );
 
-      final pending = await dao.getPendingItems();
+      final pending = await dao.getPendingItems(ownerDid);
       expect(pending.length, 1);
       expect(pending.first.category, 'feed');
       expect(pending.first.type, 'save');
···
     });
 
     test('enqueueFeedSync adds feed item with correct category', () async {
-      await dao.enqueueFeedSync(type: 'save', feedUri: 'at://test-feed');
+      await dao.enqueueFeedSync(type: 'save', feedUri: 'at://test-feed', ownerDid: ownerDid);
 
-      final pending = await dao.getPendingItems();
+      final pending = await dao.getPendingItems(ownerDid);
       expect(pending.length, 1);
       expect(pending.first.category, 'feed');
       expect(pending.first.type, 'save');
···
       await dao.enqueueBlueskyPrefSync(
         preferenceType: 'adultContent',
         preferenceData: '{"enabled": true}',
+        ownerDid: ownerDid,
       );
 
-      final pending = await dao.getPendingItems();
+      final pending = await dao.getPendingItems(ownerDid);
       expect(pending.length, 1);
       expect(pending.first.category, 'bluesky_pref');
       expect(pending.first.type, 'adultContent');
···
           type: 'save',
           payload: 'first',
           createdAt: now,
+          ownerDid: ownerDid,
         ),
       );
       await dao.enqueue(
···
           type: 'remove',
           payload: 'second',
           createdAt: now.add(const Duration(seconds: 1)),
+          ownerDid: ownerDid,
         ),
       );
 
-      final pending = await dao.getPendingItems();
+      final pending = await dao.getPendingItems(ownerDid);
       expect(pending.length, 2);
       expect(pending[0].payload, 'first');
       expect(pending[1].payload, 'second');
···
           type: 'save',
           payload: 'at://test',
           createdAt: now,
+          ownerDid: ownerDid,
         ),
       );
 
-      var pending = await dao.getPendingItems();
+      var pending = await dao.getPendingItems(ownerDid);
       final id = pending.first.id;
 
       await dao.deleteItem(id);
 
-      pending = await dao.getPendingItems();
+      pending = await dao.getPendingItems(ownerDid);
       expect(pending, isEmpty);
     });
 
···
           type: 'save',
           payload: '1',
           createdAt: now,
+          ownerDid: ownerDid,
         ),
       );
       await dao.enqueue(
···
           type: 'save',
           payload: '2',
           createdAt: now,
+          ownerDid: ownerDid,
         ),
       );
 
-      await dao.clearQueue();
+      await dao.clearQueue(ownerDid);
 
-      final pending = await dao.getPendingItems();
+      final pending = await dao.getPendingItems(ownerDid);
       expect(pending, isEmpty);
     });
 
···
             type: 'save',
             payload: 'at://retryable',
             createdAt: now,
+            ownerDid: ownerDid,
           ),
         );
 
···
                 payload: 'at://almost-maxed',
                 createdAt: now,
                 retryCount: const Value(4),
+                ownerDid: ownerDid,
               ),
             );
 
···
                 payload: 'at://maxed-out',
                 createdAt: now,
                 retryCount: const Value(5),
+                ownerDid: ownerDid,
               ),
             );
 
-        final retryable = await dao.getRetryableItems();
+        final retryable = await dao.getRetryableItems(ownerDid);
         expect(retryable.length, 2);
         expect(
           retryable.map((r) => r.payload),
···
       });
 
       test('getRetryableFeedItems filters by feed category', () async {
-        await dao.enqueueFeedSync(type: 'save', feedUri: 'at://feed1');
-        await dao.enqueueFeedSync(type: 'remove', feedUri: 'at://feed2');
+        await dao.enqueueFeedSync(type: 'save', feedUri: 'at://feed1', ownerDid: ownerDid);
+        await dao.enqueueFeedSync(type: 'remove', feedUri: 'at://feed2', ownerDid: ownerDid);
         await dao.enqueueBlueskyPrefSync(
           preferenceType: 'adultContent',
           preferenceData: '{"enabled": true}',
+          ownerDid: ownerDid,
         );
 
-        final feedItems = await dao.getRetryableFeedItems();
+        final feedItems = await dao.getRetryableFeedItems(ownerDid);
         expect(feedItems.length, 2);
         expect(feedItems.every((item) => item.category == 'feed'), true);
         expect(feedItems.map((r) => r.payload), containsAll(['at://feed1', 'at://feed2']));
       });
 
       test('getRetryableBlueskyPrefItems filters by bluesky_pref category', () async {
-        await dao.enqueueFeedSync(type: 'save', feedUri: 'at://feed1');
+        await dao.enqueueFeedSync(type: 'save', feedUri: 'at://feed1', ownerDid: ownerDid);
         await dao.enqueueBlueskyPrefSync(
           preferenceType: 'adultContent',
           preferenceData: '{"enabled": true}',
+          ownerDid: ownerDid,
         );
-        await dao.enqueueBlueskyPrefSync(preferenceType: 'contentLabels', preferenceData: '[]');
+        await dao.enqueueBlueskyPrefSync(
+          preferenceType: 'contentLabels',
+          preferenceData: '[]',
+          ownerDid: ownerDid,
+        );
 
-        final prefItems = await dao.getRetryableBlueskyPrefItems();
+        final prefItems = await dao.getRetryableBlueskyPrefItems(ownerDid);
         expect(prefItems.length, 2);
         expect(prefItems.every((item) => item.category == 'bluesky_pref'), true);
         expect(prefItems.map((r) => r.payload), containsAll(['{"enabled": true}', '[]']));
···
             type: 'save',
             payload: 'at://test',
             createdAt: now,
+            ownerDid: ownerDid,
           ),
         );
 
-        var items = await dao.getPendingItems();
+        var items = await dao.getPendingItems(ownerDid);
         expect(items.first.retryCount, 0);
 
         await dao.incrementRetryCount(id);
 
-        items = await dao.getPendingItems();
+        items = await dao.getPendingItems(ownerDid);
         expect(items.first.retryCount, 1);
 
         await dao.incrementRetryCount(id);
         await dao.incrementRetryCount(id);
 
-        items = await dao.getPendingItems();
+        items = await dao.getPendingItems(ownerDid);
         expect(items.first.retryCount, 3);
       });
 
···
                 payload: 'at://old-failed',
                 createdAt: now.subtract(const Duration(days: 45)),
                 retryCount: const Value(5),
+                ownerDid: ownerDid,
               ),
             );
 
···
                 payload: 'at://old-retryable',
                 createdAt: now.subtract(const Duration(days: 45)),
                 retryCount: const Value(3),
+                ownerDid: ownerDid,
               ),
             );
 
···
                 payload: 'at://recent-failed',
                 createdAt: now.subtract(const Duration(days: 5)),
                 retryCount: const Value(5),
+                ownerDid: ownerDid,
               ),
             );
 
···
             type: 'save',
             payload: 'at://new-item',
             createdAt: now,
+            ownerDid: ownerDid,
           ),
         );
 
         final deleted = await dao.cleanupOldFailedItems(threshold);
         expect(deleted, 1);
 
-        final remaining = await dao.getPendingItems();
+        final remaining = await dao.getPendingItems(ownerDid);
         expect(remaining.length, 3);
         expect(
           remaining.map((r) => r.payload),
···
             type: 'save',
             payload: 'at://test',
             createdAt: now,
+            ownerDid: ownerDid,
           ),
         );
 
         final deleted = await dao.cleanupOldFailedItems(now.subtract(const Duration(days: 30)));
         expect(deleted, 0);
 
-        final remaining = await dao.getPendingItems();
+        final remaining = await dao.getPendingItems(ownerDid);
         expect(remaining.length, 1);
       });
     });

test/src/infrastructure/db/daos/saved_feeds_dao_test.dart

···
 void main() {
   late AppDatabase db;
   late SavedFeedsDao dao;
+  const ownerDid = 'did:plc:owner';
 
   setUp(() {
     db = AppDatabase(NativeDatabase.memory());
···
         uri: 'at://did:plc:abc/app.bsky.feed.generator/test',
         displayName: 'Test Feed',
         creatorDid: 'did:plc:abc',
+        ownerDid: ownerDid,
         sortOrder: 0,
         lastSynced: DateTime(2025, 1, 1),
       );
 
       await dao.upsertFeed(feed);
 
-      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test');
+      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test', ownerDid);
       expect(result, isNotNull);
       expect(result!.displayName, 'Test Feed');
       expect(result.creatorDid, 'did:plc:abc');
···
         uri: 'at://did:plc:abc/app.bsky.feed.generator/test',
         displayName: 'Test Feed',
         creatorDid: 'did:plc:abc',
+        ownerDid: ownerDid,
         sortOrder: 0,
         lastSynced: DateTime(2025, 1, 1),
         likeCount: const Value(10),
···
         uri: 'at://did:plc:abc/app.bsky.feed.generator/test',
         displayName: 'Updated Feed',
         creatorDid: 'did:plc:abc',
+        ownerDid: ownerDid,
         sortOrder: 1,
         lastSynced: DateTime(2025, 1, 2),
         likeCount: const Value(20),
···
 
       await dao.upsertFeed(updated);
 
-      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test');
+      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test', ownerDid);
       expect(result!.displayName, 'Updated Feed');
       expect(result.sortOrder, 1);
       expect(result.likeCount, 20);
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/feed1',
           displayName: 'Feed 1',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 1),
         ),
···
           uri: 'at://did:plc:def/app.bsky.feed.generator/feed2',
           displayName: 'Feed 2',
           creatorDid: 'did:plc:def',
+          ownerDid: ownerDid,
           sortOrder: 1,
           lastSynced: DateTime(2025, 1, 1),
         ),
···
 
       await dao.upsertFeeds(feeds);
 
-      final result = await dao.getAllFeeds();
+      final result = await dao.getAllFeeds(ownerDid);
       expect(result, hasLength(2));
       expect(result[0].displayName, 'Feed 1');
       expect(result[1].displayName, 'Feed 2');
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/feed1',
           displayName: 'Feed 1',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 1),
         ),
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/feed1',
           displayName: 'Updated Feed 1',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 2),
         ),
···
 
       await dao.upsertFeeds(updates);
 
-      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/feed1');
+      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/feed1', ownerDid);
       expect(result!.displayName, 'Updated Feed 1');
     });
   });
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/test',
           displayName: 'Test Feed',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 1),
         ),
       );
 
-      final deleted = await dao.deleteFeed('at://did:plc:abc/app.bsky.feed.generator/test');
+      final deleted = await dao.deleteFeed(
+        'at://did:plc:abc/app.bsky.feed.generator/test',
+        ownerDid,
+      );
       expect(deleted, 1);
 
-      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test');
+      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test', ownerDid);
       expect(result, isNull);
     });
 
     test('returns 0 when feed does not exist', () async {
       final deleted = await dao.deleteFeed(
         'at://did:plc:nonexistent/app.bsky.feed.generator/test',
+        ownerDid,
       );
       expect(deleted, 0);
     });
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/feed1',
           displayName: 'Feed 1',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 1),
         ),
···
           uri: 'at://did:plc:def/app.bsky.feed.generator/feed2',
           displayName: 'Feed 2',
           creatorDid: 'did:plc:def',
+          ownerDid: ownerDid,
           sortOrder: 1,
           lastSynced: DateTime(2025, 1, 1),
         ),
       ]);
 
-      final deleted = await dao.deleteAllFeeds();
+      final deleted = await dao.deleteAllFeeds(ownerDid);
       expect(deleted, 2);
 
-      final result = await dao.getAllFeeds();
+      final result = await dao.getAllFeeds(ownerDid);
       expect(result, isEmpty);
     });
   });
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/test',
           displayName: 'Test Feed',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 1),
         ),
       );
 
-      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test');
+      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test', ownerDid);
       expect(result, isNotNull);
       expect(result!.displayName, 'Test Feed');
     });
 
     test('returns null when feed does not exist', () async {
-      final result = await dao.getFeed('at://did:plc:nonexistent/app.bsky.feed.generator/test');
+      final result = await dao.getFeed(
+        'at://did:plc:nonexistent/app.bsky.feed.generator/test',
+        ownerDid,
+      );
       expect(result, isNull);
     });
   });
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/test',
           displayName: 'Test Feed',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 1),
         ),
       );
 
-      final result = await dao.watchFeed('at://did:plc:abc/app.bsky.feed.generator/test').first;
+      final result = await dao
+          .watchFeed('at://did:plc:abc/app.bsky.feed.generator/test', ownerDid)
+          .first;
       expect(result, isNotNull);
       expect(result!.displayName, 'Test Feed');
     });
 
     test('emits null when feed does not exist', () async {
       final result = await dao
-          .watchFeed('at://did:plc:nonexistent/app.bsky.feed.generator/test')
+          .watchFeed('at://did:plc:nonexistent/app.bsky.feed.generator/test', ownerDid)
           .first;
       expect(result, isNull);
     });
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/feed3',
           displayName: 'Feed 3',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 2,
           lastSynced: DateTime(2025, 1, 1),
         ),
···
           uri: 'at://did:plc:def/app.bsky.feed.generator/feed1',
           displayName: 'Feed 1',
           creatorDid: 'did:plc:def',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 1),
         ),
···
           uri: 'at://did:plc:ghi/app.bsky.feed.generator/feed2',
           displayName: 'Feed 2',
           creatorDid: 'did:plc:ghi',
+          ownerDid: ownerDid,
           sortOrder: 1,
           lastSynced: DateTime(2025, 1, 1),
         ),
       ]);
 
-      final result = await dao.getAllFeeds();
+      final result = await dao.getAllFeeds(ownerDid);
       expect(result, hasLength(3));
       expect(result[0].displayName, 'Feed 1');
       expect(result[1].displayName, 'Feed 2');
···
     });
 
     test('returns empty list when no feeds exist', () async {
-      final result = await dao.getAllFeeds();
+      final result = await dao.getAllFeeds(ownerDid);
       expect(result, isEmpty);
     });
   });
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/feed2',
           displayName: 'Feed 2',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 1,
           lastSynced: DateTime(2025, 1, 1),
         ),
···
           uri: 'at://did:plc:def/app.bsky.feed.generator/feed1',
           displayName: 'Feed 1',
           creatorDid: 'did:plc:def',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 1),
         ),
       ]);
 
-      final result = await dao.watchAllFeeds().first;
+      final result = await dao.watchAllFeeds(ownerDid).first;
       expect(result, hasLength(2));
       expect(result[0].displayName, 'Feed 1');
       expect(result[1].displayName, 'Feed 2');
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/feed1',
           displayName: 'Feed 1',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           isPinned: const Value(true),
           lastSynced: DateTime(2025, 1, 1),
···
           uri: 'at://did:plc:def/app.bsky.feed.generator/feed2',
           displayName: 'Feed 2',
           creatorDid: 'did:plc:def',
+          ownerDid: ownerDid,
           sortOrder: 1,
           isPinned: const Value(false),
           lastSynced: DateTime(2025, 1, 1),
···
           uri: 'at://did:plc:ghi/app.bsky.feed.generator/feed3',
           displayName: 'Feed 3',
           creatorDid: 'did:plc:ghi',
+          ownerDid: ownerDid,
           sortOrder: 2,
           isPinned: const Value(true),
           lastSynced: DateTime(2025, 1, 1),
         ),
       ]);
 
-      final result = await dao.getPinnedFeeds();
+      final result = await dao.getPinnedFeeds(ownerDid);
       expect(result, hasLength(2));
       expect(result[0].displayName, 'Feed 1');
       expect(result[1].displayName, 'Feed 3');
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/feed1',
           displayName: 'Feed 1',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           isPinned: const Value(false),
           lastSynced: DateTime(2025, 1, 1),
         ),
       );
 
-      final result = await dao.getPinnedFeeds();
+      final result = await dao.getPinnedFeeds(ownerDid);
       expect(result, isEmpty);
     });
   });
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/feed1',
           displayName: 'Feed 1',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           isPinned: const Value(true),
           lastSynced: DateTime(2025, 1, 1),
···
           uri: 'at://did:plc:def/app.bsky.feed.generator/feed2',
           displayName: 'Feed 2',
           creatorDid: 'did:plc:def',
+          ownerDid: ownerDid,
           sortOrder: 1,
           isPinned: const Value(false),
           lastSynced: DateTime(2025, 1, 1),
         ),
       ]);
 
-      final result = await dao.watchPinnedFeeds().first;
+      final result = await dao.watchPinnedFeeds(ownerDid).first;
       expect(result, hasLength(1));
       expect(result[0].displayName, 'Feed 1');
     });
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/fresh',
           displayName: 'Fresh Feed',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: now,
         ),
···
           uri: 'at://did:plc:def/app.bsky.feed.generator/stale1',
           displayName: 'Stale Feed 1',
           creatorDid: 'did:plc:def',
+          ownerDid: ownerDid,
           sortOrder: 1,
           lastSynced: yesterday,
         ),
···
           uri: 'at://did:plc:ghi/app.bsky.feed.generator/stale2',
           displayName: 'Stale Feed 2',
           creatorDid: 'did:plc:ghi',
+          ownerDid: ownerDid,
           sortOrder: 2,
           lastSynced: weekAgo,
         ),
       ]);
 
       final threshold = DateTime(2025, 1, 4, 12);
-      final result = await dao.getStaleFeeds(threshold);
+      final result = await dao.getStaleFeeds(threshold, ownerDid);
 
       expect(result, hasLength(2));
       expect(result.any((f) => f.displayName == 'Stale Feed 1'), true);
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/fresh',
           displayName: 'Fresh Feed',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 5),
         ),
       );
 
       final threshold = DateTime(2025, 1, 1);
-      final result = await dao.getStaleFeeds(threshold);
+      final result = await dao.getStaleFeeds(threshold, ownerDid);
       expect(result, isEmpty);
     });
   });
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/test',
           displayName: 'Test Feed',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           lastSynced: DateTime(2025, 1, 1),
         ),
···
       final updated = await dao.updateSortOrder(
         'at://did:plc:abc/app.bsky.feed.generator/test',
         5,
+        ownerDid,
       );
       expect(updated, 1);
 
-      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test');
+      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test', ownerDid);
       expect(result!.sortOrder, 5);
     });
 
···
       final updated = await dao.updateSortOrder(
         'at://did:plc:nonexistent/app.bsky.feed.generator/test',
         5,
+        ownerDid,
       );
       expect(updated, 0);
     });
···
           uri: 'at://did:plc:abc/app.bsky.feed.generator/test',
           displayName: 'Test Feed',
           creatorDid: 'did:plc:abc',
+          ownerDid: ownerDid,
           sortOrder: 0,
           isPinned: const Value(false),
           lastSynced: DateTime(2025, 1, 1),
···
       final updated = await dao.updatePinnedStatus(
         'at://did:plc:abc/app.bsky.feed.generator/test',
         true,
+        ownerDid,
       );
       expect(updated, 1);
 
-      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test');
+      final result = await dao.getFeed('at://did:plc:abc/app.bsky.feed.generator/test', ownerDid);
       expect(result!.isPinned, true);
     });
 
···
       final updated = await dao.updatePinnedStatus(
         'at://did:plc:nonexistent/app.bsky.feed.generator/test',
         true,
+        ownerDid,
       );
       expect(updated, 0);
     });

test/src/infrastructure/network/providers_test.dart

···
       when(() => mockSessionStorage.getSession()).thenAnswer((_) async => null);
       when(() => mockSessionStorage.clearSession()).thenAnswer((_) async {});
       when(() => mockDatabase.feedContentDao).thenReturn(mockFeedContentDao);
-      when(() => mockFeedContentDao.clearFeedContent(any())).thenAnswer((_) async {});
+      when(
+        () => mockFeedContentDao.clearFeedContent(any(), any(named: 'ownerDid')),
+      ).thenAnswer((_) async {});
     });
 
     test('returns null when user is not authenticated', () {
···
       await Future<void>.delayed(Duration.zero);
 
       expect(notifier.logoutInvoked, isTrue);
-      verify(() => mockFeedContentDao.clearFeedContent('home')).called(1);
+      verify(() => mockFeedContentDao.clearFeedContent('home', any(named: 'ownerDid'))).called(1);
     });
   });
 }

test/src/infrastructure/preferences/bluesky_preferences_repository_test.dart

···
 import '../../../helpers/mocks.dart';
 
 void main() {
+  const ownerDid = 'did:web:tester';
   late AppDatabase db;
   late MockXrpcClient mockApi;
   late Logger logger;
···
     test('skips sync for unauthenticated user', () async {
       when(() => mockApi.isAuthenticated).thenReturn(false);
 
-      await repository.syncPreferencesFromRemote();
+      await repository.syncPreferencesFromRemote(ownerDid);
 
       verifyNever(() => mockApi.call(any()));
     });
···
         },
       );
 
-      await repository.syncPreferencesFromRemote();
+      await repository.syncPreferencesFromRemote(ownerDid);
 
-      final pref = await repository.getAdultContentPref();
+      final pref = await repository.getAdultContentPref(ownerDid);
       expect(pref.enabled, isTrue);
     });
 
···
         },
       );
 
-      await repository.syncPreferencesFromRemote();
+      await repository.syncPreferencesFromRemote(ownerDid);
 
-      final prefs = await repository.getContentLabelPrefs();
+      final prefs = await repository.getContentLabelPrefs(ownerDid);
       expect(prefs.items, hasLength(2));
       expect(prefs.getVisibility('sexual'), LabelVisibility.hide);
       expect(prefs.getVisibility('nudity'), LabelVisibility.warn);
···
         },
       );
 
-      await repository.syncPreferencesFromRemote();
+      await repository.syncPreferencesFromRemote(ownerDid);
 
-      final pref = await repository.getLabelersPref();
+      final pref = await repository.getLabelersPref(ownerDid);
       expect(pref.labelerDids, ['did:plc:test1', 'did:plc:test2']);
     });
 
···
         },
       );
 
-      await repository.syncPreferencesFromRemote();
+      await repository.syncPreferencesFromRemote(ownerDid);
 
-      final pref = await repository.getFeedViewPref();
+      final pref = await repository.getFeedViewPref(ownerDid);
       expect(pref.hideReplies, isTrue);
       expect(pref.hideReposts, isTrue);
     });
···
         },
       );
 
-      await repository.syncPreferencesFromRemote();
+      await repository.syncPreferencesFromRemote(ownerDid);
 
-      final pref = await repository.getThreadViewPref();
+      final pref = await repository.getThreadViewPref(ownerDid);
       expect(pref.sort, ThreadSortOrder.newest);
       expect(pref.prioritizeFollowedUsers, isFalse);
     });
···
         },
       );
 
-      await repository.syncPreferencesFromRemote();
+      await repository.syncPreferencesFromRemote(ownerDid);
 
-      final pref = await repository.getMutedWordsPref();
+      final pref = await repository.getMutedWordsPref(ownerDid);
       expect(pref.items, hasLength(1));
       expect(pref.items[0].value, 'test-word');
     });
···
         },
       );
 
-      await repository.syncPreferencesFromRemote();
+      await repository.syncPreferencesFromRemote(ownerDid);
 
-      expect((await repository.getAdultContentPref()).enabled, isTrue);
-      expect((await repository.getContentLabelPrefs()).items, hasLength(1));
-      expect((await repository.getLabelersPref()).labelers, isEmpty);
-      expect((await repository.getFeedViewPref()).hideQuotePosts, isTrue);
-      expect((await repository.getThreadViewPref()).sort, ThreadSortOrder.hotness);
-      expect((await repository.getMutedWordsPref()).items, isEmpty);
+      expect((await repository.getAdultContentPref(ownerDid)).enabled, isTrue);
+      expect((await repository.getContentLabelPrefs(ownerDid)).items, hasLength(1));
+      expect((await repository.getLabelersPref(ownerDid)).labelers, isEmpty);
+      expect((await repository.getFeedViewPref(ownerDid)).hideQuotePosts, isTrue);
+      expect((await repository.getThreadViewPref(ownerDid)).sort, ThreadSortOrder.hotness);
+      expect((await repository.getMutedWordsPref(ownerDid)).items, isEmpty);
     });
 
     test('handles malformed preference gracefully', () async {
···
       when(() => mockApi.call('app.bsky.actor.getPreferences')).thenAnswer(
         (_) async => {
           'preferences': [
-            'not-a-map', // Invalid
+            'not-a-map',
             {r'$type': 'app.bsky.actor.defs#adultContentPref', 'enabled': true},
           ],
         },
       );
 
-      await repository.syncPreferencesFromRemote();
+      await repository.syncPreferencesFromRemote(ownerDid);
 
-      final pref = await repository.getAdultContentPref();
+      final pref = await repository.getAdultContentPref(ownerDid);
       expect(pref.enabled, isTrue);
     });
   });
 
   group('getters return defaults when not synced', () {
     test('getAdultContentPref returns false by default', () async {
-      final pref = await repository.getAdultContentPref();
+      final pref = await repository.getAdultContentPref(ownerDid);
       expect(pref.enabled, isFalse);
     });
 
     test('getContentLabelPrefs returns empty by default', () async {
-      final prefs = await repository.getContentLabelPrefs();
+      final prefs = await repository.getContentLabelPrefs(ownerDid);
       expect(prefs.items, isEmpty);
     });
 
     test('getLabelersPref returns empty by default', () async {
-      final pref = await repository.getLabelersPref();
+      final pref = await repository.getLabelersPref(ownerDid);
       expect(pref.labelers, isEmpty);
     });
 
     test('getFeedViewPref returns defaults', () async {
-      final pref = await repository.getFeedViewPref();
+      final pref = await repository.getFeedViewPref(ownerDid);
       expect(pref.hideReplies, isFalse);
       expect(pref.hideReposts, isFalse);
     });
 
     test('getThreadViewPref returns defaults', () async {
-      final pref = await repository.getThreadViewPref();
+      final pref = await repository.getThreadViewPref(ownerDid);
       expect(pref.sort, ThreadSortOrder.oldest);
       expect(pref.prioritizeFollowedUsers, isTrue);
     });
 
     test('getMutedWordsPref returns empty by default', () async {
-      final pref = await repository.getMutedWordsPref();
+      final pref = await repository.getMutedWordsPref(ownerDid);
       expect(pref.items, isEmpty);
     });
   });
···
         },
       );
 
-      final stream = repository.watchAdultContentPref();
+      final stream = repository.watchAdultContentPref(ownerDid);
       expect((await stream.first).enabled, isFalse);
 
-      await repository.syncPreferencesFromRemote();
+      await repository.syncPreferencesFromRemote(ownerDid);
       expect((await stream.first).enabled, isTrue);
     });
   });
···
         },
       );
 
-      await repository.syncPreferencesFromRemote();
-      expect((await repository.getAdultContentPref()).enabled, isTrue);
+      await repository.syncPreferencesFromRemote(ownerDid);
+      expect((await repository.getAdultContentPref(ownerDid)).enabled, isTrue);
 
-      await repository.clearAll();
+      await repository.clearAll(ownerDid);
 
-      expect((await repository.getAdultContentPref()).enabled, isFalse);
+      expect((await repository.getAdultContentPref(ownerDid)).enabled, isFalse);
     });
   });
 
···
     test('persists preference to database', () async {
       const pref = FeedViewPref(hideReplies: true, hideReposts: true, hideQuotePosts: false);
 
-      await repository.updateFeedViewPref(pref);
+      await repository.updateFeedViewPref(pref, ownerDid);
 
-      final stored = await repository.getFeedViewPref();
+      final stored = await repository.getFeedViewPref(ownerDid);
       expect(stored.hideReplies, isTrue);
       expect(stored.hideReposts, isTrue);
       expect(stored.hideQuotePosts, isFalse);
···
     test('queues sync item', () async {
       const pref = FeedViewPref(hideReplies: true);
 
-      await repository.updateFeedViewPref(pref);
+      await repository.updateFeedViewPref(pref, ownerDid);
 
-      final queued = await db.preferenceSyncQueueDao.getPendingItems();
+      final queued = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queued, hasLength(1));
       expect(queued[0].type, 'feedView');
     });
···
     test('persists preference to database', () async {
       const pref = ThreadViewPref(sort: ThreadSortOrder.newest, prioritizeFollowedUsers: false);
 
-      await repository.updateThreadViewPref(pref);
+      await repository.updateThreadViewPref(pref, ownerDid);
 
-      final stored = await repository.getThreadViewPref();
+      final stored = await repository.getThreadViewPref(ownerDid);
       expect(stored.sort, ThreadSortOrder.newest);
       expect(stored.prioritizeFollowedUsers, isFalse);
     });
···
     test('queues sync item', () async {
       const pref = ThreadViewPref(sort: ThreadSortOrder.mostLikes);
 
-      await repository.updateThreadViewPref(pref);
+      await repository.updateThreadViewPref(pref, ownerDid);
 
-      final queued = await db.preferenceSyncQueueDao.getPendingItems();
+      final queued = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queued, hasLength(1));
       expect(queued[0].type, 'threadView');
     });
···
     test('persists preference to database', () async {
       const pref = AdultContentPref(enabled: true);
 
-      await repository.updateAdultContentPref(pref);
+      await repository.updateAdultContentPref(pref, ownerDid);
 
-      final stored = await repository.getAdultContentPref();
+      final stored = await repository.getAdultContentPref(ownerDid);
       expect(stored.enabled, isTrue);
     });
 
     test('queues sync item', () async {
       const pref = AdultContentPref(enabled: true);
 
-      await repository.updateAdultContentPref(pref);
+      await repository.updateAdultContentPref(pref, ownerDid);
 
-      final queued = await db.preferenceSyncQueueDao.getPendingItems();
+      final queued = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queued, hasLength(1));
       expect(queued[0].type, 'adultContent');
     });
 
     test('updates from enabled to disabled', () async {
-      await repository.updateAdultContentPref(const AdultContentPref(enabled: true));
-      expect((await repository.getAdultContentPref()).enabled, isTrue);
+      await repository.updateAdultContentPref(const AdultContentPref(enabled: true), ownerDid);
+      expect((await repository.getAdultContentPref(ownerDid)).enabled, isTrue);
 
-      await repository.updateAdultContentPref(const AdultContentPref(enabled: false));
-      expect((await repository.getAdultContentPref()).enabled, isFalse);
+      await repository.updateAdultContentPref(const AdultContentPref(enabled: false), ownerDid);
+      expect((await repository.getAdultContentPref(ownerDid)).enabled, isFalse);
     });
   });
 
···
         ],
       );
 
-      await repository.updateContentLabelPrefs(prefs);
+      await repository.updateContentLabelPrefs(prefs, ownerDid);
 
-      final stored = await repository.getContentLabelPrefs();
+      final stored = await repository.getContentLabelPrefs(ownerDid);
       expect(stored.items, hasLength(2));
       expect(stored.getVisibility('sexual'), LabelVisibility.hide);
       expect(stored.getVisibility('gore'), LabelVisibility.warn);
···
         items: [ContentLabelPref(label: 'spam', visibility: LabelVisibility.hide)],
       );
 
-      await repository.updateContentLabelPrefs(prefs);
+      await repository.updateContentLabelPrefs(prefs, ownerDid);
 
-      final queued = await db.preferenceSyncQueueDao.getPendingItems();
+      final queued = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queued, hasLength(1));
       expect(queued[0].type, 'contentLabels');
     });
···
         const ContentLabelPrefs(
           items: [ContentLabelPref(label: 'sexual', visibility: LabelVisibility.hide)],
         ),
+        ownerDid,
       );
 
       await repository.updateContentLabelPrefs(
         const ContentLabelPrefs(
           items: [ContentLabelPref(label: 'gore', visibility: LabelVisibility.warn)],
         ),
+        ownerDid,
       );
 
-      final stored = await repository.getContentLabelPrefs();
+      final stored = await repository.getContentLabelPrefs(ownerDid);
       expect(stored.items, hasLength(1));
       expect(stored.getVisibility('gore'), LabelVisibility.warn);
       expect(stored.getVisibility('sexual'), isNull);
···
         ],
       );
 
-      await repository.updateMutedWordsPref(pref);
+      await repository.updateMutedWordsPref(pref, ownerDid);
 
-      final stored = await repository.getMutedWordsPref();
+      final stored = await repository.getMutedWordsPref(ownerDid);
       expect(stored.items, hasLength(2));
       expect(stored.items[0].value, 'spam');
       expect(stored.items[1].value, 'scam');
···
         ],
       );
 
-      await repository.updateMutedWordsPref(pref);
+      await repository.updateMutedWordsPref(pref, ownerDid);
 
-      final queued = await db.preferenceSyncQueueDao.getPendingItems();
+      final queued = await db.preferenceSyncQueueDao.getPendingItems(ownerDid);
       expect(queued, hasLength(1));
       expect(queued[0].type, 'mutedWords');
     });
···
             MutedWord(id: '1', value: 'old', targets: [MutedWordTarget.content]),
           ],
         ),
+        ownerDid,
       );
 
       await repository.updateMutedWordsPref(
···
             MutedWord(id: '2', value: 'new', targets: [MutedWordTarget.content]),
           ],
         ),
+        ownerDid,
       );
 
-      final stored = await repository.getMutedWordsPref();
+      final stored = await repository.getMutedWordsPref(ownerDid);
       expect(stored.items, hasLength(1));
       expect(stored.items[0].value, 'new');
     });